diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000..96b35539c9
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,9 @@
+# Auto detect text files and perform normalization
+*          text=auto eol=lf
+
+*.rs       text diff=rust eol=lf
+*.toml     text diff=toml eol=lf
+Cargo.lock text eol=lf
+
+*.sh       text eol=lf
+*.ps1      text eol=crlf
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000000..2dad4588be
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,29 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: 'C-bug'
+assignees: ''
+
+---
+
+## Lapce Version
+
+The Lapce version you are using, which can be found in "About Lapce" at the top right settings icon. 
+
+## System information
+
+the operating system used, including its version, e.g. Windows 10, Ubuntu 18.04
+
+## Describe the bug
+A clear and concise description of what the bug is.
+
+## Additional information
+
+Other information that can be used to further reproduce or isolate the problem.
+This commonly includes:
+
+- screenshots
+- logs
+- theories about what might be going wrong
+- workarounds that you used
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000000..aac61aa4ed
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Lapce community on Discord
+    url: https://discord.gg/n8tGJ6Rn6D
+    about: Please ask and answer questions here.
+  - name: Lapce community on Matrix
+    url: https://matrix.to/#/#lapce-editor:matrix.org
+    about: Please ask and answer questions here.
+  - name: Lapce documentation
+    url: https://docs.lapce.dev/
+    about: Documentation for Lapce
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000000..2464024d03
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,24 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: 'C-feature'
+assignees: ''
+
+---
+
+## Is your feature request related to a problem? Please describe.
+
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+## Describe the solution you'd like
+
+A clear and concise description of what you want to happen.
+
+## Describe alternatives you've considered
+
+A clear and concise description of any alternative solutions or features you've considered.
+
+## Additional context
+
+Add any other context or screenshots about the feature request here.
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 0000000000..e3e1d64c45
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1 @@
+- [ ] Added an entry to `CHANGELOG.md` if this change could be valuable to users
\ No newline at end of file
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000000..0a8ff26e31
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,11 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'
+
+  - package-ecosystem: 'cargo'
+    directory: '/'
+    schedule:
+      interval: 'weekly'
\ No newline at end of file
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 27e4f79b36..f554569421 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,75 +2,101 @@ on:
   push:
     branches:
       - master
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
 
 name: CI
 
+concurrency:
+  group: ${{ github.ref }}-${{ github.workflow }}
+  cancel-in-progress: true
+
 jobs:
   build:
-    name: Rust (${{ matrix.toolchain }}) on ${{ matrix.os }}
+    name: Rust on ${{ matrix.os }}
+    if: github.event.pull_request.draft == false
+    needs: [fmt, clippy]
     strategy:
       fail-fast: false
       matrix:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
-        toolchain: [ stable ]
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v2
+      - name: Checkout repo
+        uses: actions/checkout@v3
 
       - name: Install dependencies on Ubuntu
         if: startsWith(matrix.os, 'ubuntu')
         run: sudo apt-get update && sudo apt-get install cmake pkg-config libgtk-3-dev
 
-      - name: Install toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.toolchain }}
+      - name: Update toolchain & add llvm-tools
+        run: |
+          rustup update
+          rustup component add llvm-tools-preview
 
-      - uses: Swatinem/rust-cache@v1
+      - name: Cache Rust dependencies
+        uses: Swatinem/rust-cache@v2
+        
+      - name: Fetch dependencies
+        run: cargo fetch --locked
 
       - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-  
-      - name: Run tests
-        uses: actions-rs/cargo@v1
+        run: cargo build --frozen
+
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
+
+      - name: Run tests and coverage
+        run: cargo llvm-cov --all-features --workspace --lcov --output-path lcov.info
+          
+      - name: Run doc tests
+        run: cargo test --doc --workspace
+
+      - name: Upload coverage
+        uses: codecov/codecov-action@v3
         with:
-          command: test
-          args: --workspace
+          files: lcov.info
+
   fmt:
     name: Rustfmt
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - run: rustup component add rustfmt
-      - uses: Swatinem/rust-cache@v1
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
+      - name: Checkout repo
+        uses: actions/checkout@v3
+
+      - name: Update toolchain & add rustfmt
+        run: |
+          rustup update
+          rustup component add rustfmt
+
+      - name: Run rustfmt
+        run: cargo fmt --all --check
 
   clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
+    name: Clippy on ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-latest, windows-latest, macos-latest ]
+    runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - run: rustup component add clippy
+      - name: Checkout repo
+        uses: actions/checkout@v3
+
+      - name: Update toolchain & add clippy
+        run: |
+          rustup update
+          rustup component add clippy
+
       - name: Install dependencies on Ubuntu
+        if: startsWith(matrix.os, 'ubuntu')
         run: sudo apt-get update && sudo apt-get install cmake pkg-config libgtk-3-dev
-      - uses: Swatinem/rust-cache@v1
-      - uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: -- -D warnings
+
+      - name: Cache Rust dependencies
+        uses: Swatinem/rust-cache@v2
+        
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Run clippy
+        run: cargo clippy -- -D warnings
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
deleted file mode 100644
index 5ac33a9c4f..0000000000
--- a/.github/workflows/pr.yml
+++ /dev/null
@@ -1,69 +0,0 @@
-on:
-  pull_request:
-    types: [opened, synchronize, reopened, ready_for_review]
-
-name: Pull request checks
-
-jobs:
-  check:
-    name: Rust (${{ matrix.toolchain }}) on ${{ matrix.os }}
-    if: github.event.pull_request.draft == false
-
-    strategy:
-      matrix:
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
-        toolchain: [ stable ]
-
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install dependencies on Ubuntu
-        if: startsWith(matrix.os, 'ubuntu')
-        run: sudo apt-get update && sudo apt-get install cmake pkg-config libgtk-3-dev
-
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.toolchain }}
-
-      - uses: Swatinem/rust-cache@v1
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace
-
-  fmt:
-    name: Rustfmt
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - run: rustup component add rustfmt
-      - uses: Swatinem/rust-cache@v1
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - run: rustup component add clippy
-      - name: Install dependencies on Ubuntu
-        run: sudo apt-get update && sudo apt-get install cmake pkg-config libgtk-3-dev
-      - uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: -- -D warnings
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 4018d8874d..1364f93503 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,29 +1,80 @@
 name: Release
 
 on:
+  schedule:
+    - cron: 0 0 * * *
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: 'Tag name for release'
+        required: false
+        default: nightly
   push:
     tags: ["v[0-9]+.[0-9]+.[0-9]+*"]
+  pull_request:
+    paths:
+      # trigger release workflow only if this file changed
+      - .github/workflows/release.yml
 
 env:
   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
   CARGO_TERM_COLOR: always
 
 jobs:
+  tagname:
+    runs-on: ubuntu-latest
+    outputs:
+      tag_name: ${{ steps.tag.outputs.tag }}
+    steps:
+      - if: github.event_name == 'workflow_dispatch'
+        run: echo "TAG_NAME=${{ github.event.inputs.tag_name }}" >> $GITHUB_ENV
+
+      - if: github.event_name == 'schedule'
+        run: echo 'TAG_NAME=nightly' >> $GITHUB_ENV
+
+      - if: github.event_name == 'push'
+        run: |
+          TAG_NAME=${{ github.ref }}
+          echo "TAG_NAME=${TAG_NAME#refs/tags/}" >> $GITHUB_ENV
+          
+      - if: github.event_name == 'pull_request'
+        run: echo 'TAG_NAME=debug' >> $GITHUB_ENV
+
+      - id: vars
+        shell: bash
+        run: echo "sha_short=${GITHUB_SHA::7}" >> $GITHUB_OUTPUT
+
+      - if: env.TAG_NAME == 'nightly'
+        run: echo 'TAG_NAME=nightly-${{ steps.vars.outputs.sha_short }}' >> $GITHUB_ENV
+
+      - id: tag
+        run: echo "tag=$TAG_NAME" >> $GITHUB_OUTPUT
+  
   windows:
     runs-on: windows-latest
+    needs: tagname
+    env:
+      RELEASE_TAG_NAME: ${{ needs.tagname.outputs.tag_name }}
 
     defaults:
       run:
         shell: bash
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
+
       - name: Update rust
         run: rustup update
+        
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
       - name: Build
-        run: cargo build --profile release-lto
+        run: cargo build --frozen --profile release-lto
+
       - name: Install WiX
         run: nuget install WiX
+
       - name: Crate msi installer
         run: |
           ./WiX.*/tools/candle.exe -arch "x64" -ext WixUIExtension -ext WixUtilExtension \
@@ -31,95 +82,255 @@ jobs:
           ./WiX.*/tools/light.exe -ext WixUIExtension -ext WixUtilExtension \
             -out "./Lapce-windows.msi" -sice:ICE61 -sice:ICE91 \
             "./lapce.wixobj"
+
       - name: Create portable
         shell: pwsh
         run: |
+          cargo build --profile release-lto --features lapce-ui/portable
           Compress-Archive ./target/release-lto/lapce.exe ./Lapce-windows-portable.zip
-      - name: Upload msi installer
-        uses: svenstaro/upload-release-action@v2
-        with:
-          repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: ./Lapce-windows.msi
-          file_glob: true
-          tag: ${{ github.ref }}
-          overwrite: true
-      - name: Upload portable
-        uses: svenstaro/upload-release-action@v2
+
+      - name: Create lapce-proxy archive
+        shell: pwsh
+        run: |
+          $file = [System.IO.File]::Open((Join-Path $PWD '.\target\release-lto\lapce-proxy.exe'), [System.IO.FileMode]::Open)
+          $archive = [System.IO.File]::Create((Join-Path $PWD '.\lapce-proxy-windows-x86_64.gz'))
+          $compressor = [System.IO.Compression.GZipStream]::new($archive, [System.IO.Compression.CompressionMode]::Compress)
+          $file.CopyTo($compressor)
+          Start-Sleep -Seconds 10
+          $compressor.close()
+
+      - uses: actions/upload-artifact@v3
         with:
-          repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: ./Lapce-windows-portable.zip
-          file_glob: true
-          tag: ${{ github.ref }}
-          overwrite: true
+          name: lapce-windows
+          path: |
+            ./lapce-proxy-windows-*.gz
+            ./Lapce-windows-portable.zip
+            ./Lapce-windows.msi
+          retention-days: 1
 
   linux:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-latest
+    container: ubuntu:18.04
+    needs: tagname
+    env:
+      RELEASE_TAG_NAME: ${{ needs.tagname.outputs.tag_name }}
+      DEBIAN_FRONTEND: noninteractive
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Install dependencies
         run: |
-          sudo apt-get install cmake pkg-config libfontconfig-dev libgtk-3-dev
-      - name: Update rust
-        run: rustup update
+          apt-get -y update
+          apt-get -y install cmake pkg-config libfontconfig-dev libgtk-3-dev
+      
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          target: x86_64-unknown-linux-gnu
+          profile: minimal
+
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
       - name: Build
-        run: cargo build --profile release-lto
+        run: cargo build --frozen --profile release-lto --bin lapce
+
       - name: Gzip
         run: |
           mkdir Lapce
           cp ./target/release-lto/lapce Lapce/
           tar -zcvf ./Lapce-linux.tar.gz Lapce
-          gzip -c "./target/release-lto/lapce-proxy" > ./lapce-proxy-linux.gz
-      - name: Upload Application
-        uses: svenstaro/upload-release-action@v2
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: lapce-linux
+          path: |
+            ./Lapce-linux.tar.gz
+          retention-days: 1
+
+  linux-musl:
+    name: Build lapce-proxy for ${{ matrix.platform }}
+    runs-on: ubuntu-latest
+    needs: tagname
+    env:
+      RELEASE_TAG_NAME: ${{ needs.tagname.outputs.tag_name }}
+      CROSS_SYSROOT: /mnt/alpine-${{ matrix.platform }}
+      PACKAGES: >
+        zlib-static freetype-static fontconfig-static
+        libgit2-static libssh2-static openssl-libs-static
+        libssl3 gtk+3.0-dev http-parser-dev rustup
+        build-base openssl-dev git lld clang
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - triple: x86_64-unknown-linux-musl
+            platform: x86_64
+          - triple: aarch64-unknown-linux-musl
+            platform: aarch64
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Alpine Linux for ${{ matrix.platform }} (target arch)
+        id: alpine-target
+        uses: jirutka/setup-alpine@v1
+        with:
+          arch: ${{ matrix.platform }}
+          branch: edge
+          packages: ${{ env.PACKAGES }}
+          shell-name: alpine-target.sh
+
+      - name: Set up Alpine Linux for x86_64 (build arch)
+        uses: jirutka/setup-alpine@v1
         with:
-          repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: ./Lapce-linux.tar.gz
-          file_glob: true
-          tag: ${{ github.ref }}
-          overwrite: true
-      - name: Upload Application
-        uses: svenstaro/upload-release-action@v2
+          arch: x86_64
+          branch: edge
+          packages: ${{ env.PACKAGES }}
+          volumes: ${{ steps.alpine-target.outputs.root-path }}:${{ env.CROSS_SYSROOT }}
+          shell-name: alpine.sh
+
+      - name: Install Rust stable toolchain via rustup
+        run: rustup-init --target ${{ matrix.triple }} --default-toolchain stable --profile minimal -y
+        shell: alpine.sh {0}
+
+      - name: Build ${{ matrix.triple }}
+        shell: alpine.sh {0}
+        env:
+          LIBZ_SYS_STATIC: 1
+          LIBSSH2_STATIC: 1
+          LIBGIT2_STATIC: 1
+          OPENSSL_STATIC: 1
+          OPENSSL_DIR: ${{ env.CROSS_SYSROOT }}/usr # static/dynamic lib workaround <3
+          OPENSSL_NO_VENDOR: 1 # don't even try to build without it on musl
+          PKG_CONFIG_ALL_STATIC: 1
+          PKG_CONFIG_LIBDIR: ${{ env.CROSS_SYSROOT }}/usr/lib/pkgconfig
+          RUSTFLAGS: -C target-feature=+crt-static -C linker=/usr/bin/ld.lld # link runtime static, use universal linker
+          CARGO_BUILD_TARGET: ${{ matrix.triple }}
+          CARGO_PROFILE_RELEASE_LTO: 'true'
+          CARGO_PROFILE_RELEASE_STRIP: symbols # remove unneeded debug stuff
+          CARGO_PROFILE_RELEASE_OPT_LEVEL: 's' # optimise for size
+          CARGO_PROFILE_RELEASE_CODEGEN_UNITS: '1' # optimise each crate
+          SYSROOT: /dummy  # workaround for https://github.com/rust-lang/pkg-config-rs/issues/102
+          CC: clang
+        run: |
+          # Workaround for https://github.com/rust-lang/pkg-config-rs/issues/102
+          echo -e '#!/bin/sh\nPKG_CONFIG_SYSROOT_DIR=${{ env.CROSS_SYSROOT }} exec pkgconf "$@"' \
+              | install -m755 /dev/stdin pkg-config
+          export PKG_CONFIG="$(pwd)/pkg-config"
+          cargo fetch --locked
+          cargo build \
+            --frozen \
+            --verbose \
+            --release \
+            --bin lapce-proxy \
+            --manifest-path lapce-proxy/Cargo.toml
+
+      - name: Gzip
+        run: |
+          gzip -c ./target/${{ matrix.triple }}/release/lapce-proxy > ./lapce-proxy-linux-${{ matrix.platform }}.gz
+
+      - uses: actions/upload-artifact@v3
         with:
-          repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: ./lapce-proxy-linux.gz
-          file_glob: true
-          tag: ${{ github.ref }}
-          overwrite: true
+          name: lapce-proxy-linux-${{ matrix.platform }}
+          path: |
+            ./lapce-proxy-linux-*.gz
+          retention-days: 1
 
   macos:
     runs-on: macos-11
-
+    needs: tagname
     env:
+      RELEASE_TAG_NAME: ${{ needs.tagname.outputs.tag_name }}
+
       NOTARIZE_USERNAME: ${{ secrets.NOTARIZE_USERNAME }}
       NOTARIZE_PASSWORD: ${{ secrets.NOTARIZE_PASSWORD }}
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
+
       - name: Install ARM target
         run: rustup update && rustup target add aarch64-apple-darwin
+
       - name: Import Certificate
-        uses: apple-actions/import-codesign-certs@v1
+        uses: lapce/import-codesign-certs@72dec84923586f8bef2bed09fdb4f9475c8f623d # use updated action, can be dropped once/if upstream is fixed
         with:
           p12-file-base64: ${{ secrets.MACOS_CERTIFICATE }}
           p12-password: ${{ secrets.MACOS_CERTIFICATE_PWD }}
+
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
       - name: Make DMG
         run: make dmg-universal
+
       - name: Rename
         run: |
           cp ./target/release-lto/macos/Lapce.dmg ./target/release-lto/macos/Lapce-macos.dmg
+
+      - name: Gzip lapce-proxy
+        run: |
+          gzip -c ./target/x86_64-apple-darwin/release-lto/lapce-proxy > ./target/release-lto/macos/lapce-proxy-darwin-x86_64.gz
+          gzip -c ./target/aarch64-apple-darwin/release-lto/lapce-proxy > ./target/release-lto/macos/lapce-proxy-darwin-aarch64.gz
+
       - name: "Notarize Release Build"
         run: |
           npx notarize-cli --file ./target/release-lto/macos/Lapce-macos.dmg --bundle-id io.lapce --asc-provider CYSGAZFR8D
+
       - name: "Staple Release Build"
-        uses: devbotsxyz/xcode-staple@v1
+        uses: lapce/xcode-staple@062485d6eeafe841c18a412f012e80f49e23c517
         with:
           product-path: "./target/release-lto/macos/Lapce-macos.dmg"
-      - name: Upload Application
-        uses: svenstaro/upload-release-action@v2
+
+      - uses: actions/upload-artifact@v3
         with:
-          repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: ./target/release-lto/macos/Lapce-macos.dmg
-          file_glob: true
-          tag: ${{ github.ref }}
-          overwrite: true
+          name: lapce-macos
+          path: |
+            ./target/release-lto/macos/lapce-proxy-darwin-*.gz
+            ./target/release-lto/macos/Lapce-macos.dmg
+          retention-days: 1
+
+  publish:
+    if: github.event_name != 'pull_request'
+    needs: [linux, linux-musl, windows, macos]
+    runs-on: ubuntu-latest
+    env:
+      GH_REPO: ${{ github.repository }}
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    permissions:
+      contents: write
+    steps:
+      # Must perform checkout first, since it deletes the target directory
+      # before running, and would therefore delete the downloaded artifacts
+      - uses: actions/checkout@v3
+
+      - uses: actions/download-artifact@v3          
+      
+      - if: github.event_name == 'workflow_dispatch'
+        run: echo "TAG_NAME=${{ github.event.inputs.tag_name }}" >> $GITHUB_ENV
+
+      - if: github.event_name == 'schedule'
+        run: echo 'TAG_NAME=nightly' >> $GITHUB_ENV
+
+      - if: github.event_name == 'push'
+        run: |
+          TAG_NAME=${{ github.ref }}
+          echo "TAG_NAME=${TAG_NAME#refs/tags/}" >> $GITHUB_ENV
+
+      - if: env.TAG_NAME == 'nightly'
+        run: |
+          (echo 'SUBJECT=Lapce development build';
+           echo 'PRERELEASE=--prerelease') >> $GITHUB_ENV
+          gh release delete nightly --yes || true
+          git push origin :nightly || true
+
+      - if: env.TAG_NAME != 'nightly'
+        run: |
+          (echo 'SUBJECT=Lapce release build';
+           echo 'PRERELEASE=') >> $GITHUB_ENV
+
+      - name: Publish release
+        env:
+          DEBUG: api
+        run: |
+          gh release create $TAG_NAME $PRERELEASE --title "$TAG_NAME" --target $GITHUB_SHA lapce-macos/* lapce-linux/* lapce-proxy-linux-*/* lapce-windows/*
diff --git a/.gitignore b/.gitignore
index 3c15873097..f327728e8a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,10 @@
 .vscode
 .lapce
 .idea
+.fleet
+shell.nix
 lib/
 target/
 core/languages/
+
+.DS_Store
diff --git a/.rustfmt.toml b/.rustfmt.toml
index 3c67608274..06900d0d9b 100644
--- a/.rustfmt.toml
+++ b/.rustfmt.toml
@@ -1 +1,4 @@
 max_width = 85
+# below requires nightly
+# imports_granularity = "Crate"
+# group_imports = "StdExternalCrate"
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000000..0e8e085f66
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,240 @@
+# Changelog
+
+## Unreleased
+
+### Features/Changes
+
+### Bug Fixes
+
+## 0.2.6
+
+### Breaking changes
+
+- [#1820](https://github.com/lapce/lapce/pull/1820): Add remote svg icon colour to theme, disable plugin settings when none are available
+- [#1988](https://github.com/lapce/lapce/pull/1987): Replace modal status background with background/foreground theme keys
+
+### Features/Changes
+- [#1899](https://github.com/lapce/lapce/pull/1899): Improve sorting files with numbers
+- [#1831](https://github.com/lapce/lapce/pull/1831): Plugin settings shown on right click
+- [#1830](https://github.com/lapce/lapce/pull/1830): Adds Clojure language support
+- [#1835](https://github.com/lapce/lapce/pull/1835): Add mouse keybinds
+- [#1856](https://github.com/lapce/lapce/pull/1856): Highlight git/VCS modified files in explorer, palette, and buffer tabs
+- [#1574](https://github.com/lapce/lapce/pull/1574): Panel sections can be expanded/collapsed
+- [#1938](https://github.com/lapce/lapce/pull/1938): Use dropdown for theme selection in settings
+- [#1960](https://github.com/lapce/lapce/pull/1960): Add sticky headers and code lens for PHP
+- [#1968](https://github.com/lapce/lapce/pull/1968): Completion lens (disabled by default)
+  - ![image](https://user-images.githubusercontent.com/13157904/211959283-c3229cfc-28d7-4676-a50d-aec7d47cde9f.png)
+- [#1972](https://github.com/lapce/lapce/pull/1972): Add file duplication option in fs tree context menu
+- [#1991](https://github.com/lapce/lapce/pull/1991): Implement rendering of images in markdown views
+- [#2004](https://github.com/lapce/lapce/pull/2004): Add ToggleHistory command
+- [#2033](https://github.com/lapce/lapce/pull/2033): Add setting for double click delay (Currently only works for opening file from the explorer)
+- [#2045](https://github.com/lapce/lapce/pull/2045): Add 'Rename Symbol' option on right-click
+- [#2071](https://github.com/lapce/lapce/pull/2071): Add command and keybinds to delete line
+- [#2073](https://github.com/lapce/lapce/pull/2073): Add Ctrl+{a,e,k} keybinds on macOS
+- [#2128](https://github.com/lapce/lapce/pull/2128): Add Lapce app icon to logo collection
+- [#2127](https://github.com/lapce/lapce/pull/2127): Extended double-click options with file-only and file + folders mode
+
+### Bug Fixes
+- [#1911](https://github.com/lapce/lapce/pull/1911): Fix movement on selections with left/right arrow keys
+- [#1939](https://github.com/lapce/lapce/pull/1939): Fix saving/editing newly saved-as files
+- [#1971](https://github.com/lapce/lapce/pull/1971): Fix up/down movement on first/last line
+- [#2036](https://github.com/lapce/lapce/pull/2036): Fix movement on selections with up/down arrow keys
+- [#2056](https://github.com/lapce/lapce/pull/2056): Fix default directory of remote session file picker
+- [#2072](https://github.com/lapce/lapce/pull/2072): Fix connection issues from Windows to lapce proxy
+- [#2069](https://github.com/lapce/lapce/pull/2045): Fix not finding git repositories in parent path
+- [#2131](https://github.com/lapce/lapce/pull/2131): Fix overwriting symlink
+- [#2188](https://github.com/lapce/lapce/pull/2188): Fix auto closing matching pairs in inappropriate inputs
+
+## 0.2.5
+
+### Breaking changes
+
+- [#1726](https://github.com/lapce/lapce/pull/1726): Add more panel theme keys, apply hover first, then current item colour
+
+### Features/Changes
+- [#1791](https://github.com/lapce/lapce/pull/1791): Add highlighting for scope lines
+- [#1767](https://github.com/lapce/lapce/pull/1767): Added CMake tree-sitter syntax highlighting
+- [#1759](https://github.com/lapce/lapce/pull/1759): Update C tree-sitter and highlight queries
+- [#1758](https://github.com/lapce/lapce/pull/1758): Replaced dlang syntax highlighting
+- [#1713](https://github.com/lapce/lapce/pull/1713): Add protobuf syntax and highlighting
+- [#1720](https://github.com/lapce/lapce/pull/1720): Display signature/parameter information from LSP
+- [#1723](https://github.com/lapce/lapce/pull/1723): In the palette, display the keybind for a command adjacent to it
+- [#1722](https://github.com/lapce/lapce/pull/1722): Add 'Save without Formatting'; Add option to disable formatting on autosave
+- [#1741](https://github.com/lapce/lapce/pull/1741): Add syntax highlighting for glsl
+- [#1756](https://github.com/lapce/lapce/pull/1756): Add support for ssh port with ```[user@]host[:port]```
+- [#1760](https://github.com/lapce/lapce/pull/1760): Add vim motions `cw`, `ce`, `cc`, `S`, and QOL modal bind `gf`
+- [#1770](https://github.com/lapce/lapce/pull/1770): Add support for terminal tabs
+
+### Bug Fixes
+- [#1771](https://github.com/lapce/lapce/pull/1771): Update tree-sitter-bash
+- [#1737](https://github.com/lapce/lapce/pull/1726): Fix an issue that plugins can't be upgraded
+- [#1724](https://github.com/lapce/lapce/pull/1724): Files and hidden folders no longer will be considered when trying to open a plugin base folder
+- [#1753](https://github.com/lapce/lapce/pull/1753): Limit proxy search response size in order to avoid issues with absurdly long lines
+- [#1805](https://github.com/lapce/lapce/pull/1805): Fix some LSP bugs causing code actions to not show up correctly
+
+## 0.2.4
+
+### Features/Changes
+- [#1700](https://github.com/lapce/lapce/pull/1700): Add prisma syntax and highlighting
+- [#1702](https://github.com/lapce/lapce/pull/1702): Improved svelte treesitter queries
+- [#1690](https://github.com/lapce/lapce/pull/1690): Add codelens and sticky headers for Dart
+- [#1711](https://github.com/lapce/lapce/pull/1711): Add zstd support for plugin
+- [#1715](https://github.com/lapce/lapce/pull/1715): Add support for requests from plugins
+
+### Bug Fixes
+- [#1710](https://github.com/lapce/lapce/pull/1710): Fix autosave trying to save scratch files
+- [#1709](https://github.com/lapce/lapce/pull/1709): Fix search result ordering
+- [#1708](https://github.com/lapce/lapce/pull/1708): Fix visual issue when search panel is placed to either side panel
+
+## 0.2.3
+
+### Features/Changes
+
+- [#1655](https://github.com/lapce/lapce/pull/1655): Add status foreground theme key, use author colour for plugin version
+- [#1646](https://github.com/lapce/lapce/pull/1646): Fork the process when started from terminal
+- [#1653](https://github.com/lapce/lapce/pull/1653): Paint plugin icons
+- [#1644](https://github.com/lapce/lapce/pull/1644): Added "Reveal in File Tree" action to the editor tabs context menu
+- [#1645](https://github.com/lapce/lapce/pull/1645): Add plugin search
+
+### Bug Fixes
+
+- [#1651](https://github.com/lapce/lapce/pull/1651): Fixed an issue where new windows would never be created after closing all windows on macOS.
+- [#1637](https://github.com/lapce/lapce/issues/1637): Fix python using 7 spaces instead of 4 spaces to indent
+- [#1669](https://github.com/lapce/lapce/issues/1669): It will now remember panel states when open a new project
+- [#1706](https://github.com/lapce/lapce/issues/1706): Fix the issue that color can't be changed in theme settings
+
+## 0.2.2
+
+### Features/Changes
+
+- [#1643](https://github.com/lapce/lapce/pull/1643): Use https://plugins.lapce.dev/ as the plugin registry
+- [#1620](https://github.com/lapce/lapce/pull/1620): Added "Show Hover" keybinding that will trigger the hover at the cursor location
+- [#1619](https://github.com/lapce/lapce/pull/1619):
+  - Add active/inactive tab colours
+  - Add primary button colour
+  - Add hover effect in source control panel
+  - Add colour preview in settings
+- [#1617](https://github.com/lapce/lapce/pull/1617): Fixed a stack overflow that would crash lapce when attempting to sort a large number of PaletteItems
+- [#1609](https://github.com/lapce/lapce/pull/1609): Add syntax highlighting for erlang
+- [#1590](https://github.com/lapce/lapce/pull/1590): Added ability to open file and file diff from source control context menu
+- [#1570](https://github.com/lapce/lapce/pull/1570): Added a basic tab context menu with common close actions
+- [#1560](https://github.com/lapce/lapce/pull/1560): Added ability to copy active editor remote file path to clipboard
+- [#1510](https://github.com/lapce/lapce/pull/1510): Added support to discard changes to a file
+- [#1459](https://github.com/lapce/lapce/pull/1459): Implement icon theme system
+  - **This is a breaking change for colour themes!**
+  - Colour themes should now use `[color-theme]` table format in theme TOML
+  - `volt.toml` now use `color-themes` and `icon-themes` keys. `themes` key is not used anymore.
+- [#1554](https://github.com/lapce/lapce/pull/1554): Added XML language support
+- [#1472](https://github.com/lapce/lapce/pull/1472): Added SQL language support
+- [#1531](https://github.com/lapce/lapce/pull/1531): Improved Ctrl+Left command on spaces at the beginning of a line
+- [#1491](https://github.com/lapce/lapce/pull/1491): Added Vim shift+c to delete remainder of line
+- [#1508](https://github.com/lapce/lapce/pull/1508): Show in progress when Lapce is self updating
+- [#1475](https://github.com/lapce/lapce/pull/1475): Add editor setting: "Cursor Surrounding Lines" which sets minimum number of lines above and below cursor
+- [#1525](https://github.com/lapce/lapce/pull/1525): Add editor indent guide
+- [#1521](https://github.com/lapce/lapce/pull/1521): Show unique paths to disambiguate same file names
+- [#1452](https://github.com/lapce/lapce/pull/1452): Wrap selected text with brackets/quotes
+- [#1421](https://github.com/lapce/lapce/pull/1421): Add matching bracket highlighting
+- [#1541](https://github.com/lapce/lapce/pull/1541): Order palette items according to last execute time
+
+### Bug Fixes
+
+- [#1566](https://github.com/lapce/lapce/pull/1565)|[#1568](https://github.com/lapce/lapce/pull/1568): Use separate colour for drag and drop background
+- [#1459](https://github.com/lapce/lapce/pull/1459): Fix opening currently used logfile
+- [#1505](https://github.com/lapce/lapce/pull/1505): Fix proxy download for hosts with curl without -Z flag
+- [#1483](https://github.com/lapce/lapce/pull/1483): Fix showing the close icon for the first tab when opening multiple tab
+- [#1477](https://github.com/lapce/lapce/pull/1477): Now use `esc` to close searchbar regarless of the current focus
+- [#1507](https://github.com/lapce/lapce/pull/1507): Fixed a crash when scratch buffer is closed
+- [#1547](https://github.com/lapce/lapce/pull/1547): Fix infinite cycle in workspace symbol search
+- [#1628](https://github.com/lapce/lapce/pull/1541): Fix kts files not being recognized
+
+## 0.2.1
+
+### Features/Changes
+
+- [#1050](https://github.com/lapce/lapce/pull/1050): Collapse groups of problems in the problem list panel
+- [#1165](https://github.com/lapce/lapce/pull/1165): Command to reveal item in system file explorer
+- [#1196](https://github.com/lapce/lapce/pull/1196): Always show close button on focused editor tabs
+- [#1208](https://github.com/lapce/lapce/pull/1208): Sticky header breadcrumbs
+  - This provides a header at the top which tells you information about the current scope! Especially useful for long blocks of code
+  - ![image](https://user-images.githubusercontent.com/13157904/195404556-2c329ebb-f721-4d55-aa22-56a54f8e8454.png)
+  - As well, you can see that there is now a breadcrumb path to the current file.
+  - A language with syntax highlighting can have this added, even without an LSP. Take a look at `language.rs` if your language isn't supported!
+- [#1198](https://github.com/lapce/lapce/pull/1198): Focus current theme/language in palette
+- [#1244](https://github.com/lapce/lapce/pull/1244); Prettier plugin panel
+- [#1238](https://github.com/lapce/lapce/pull/1238): Improved multicursor selection
+- [#1291](https://github.com/lapce/lapce/pull/1291): Use link colour for empty editor buttons
+- [#1234](https://github.com/lapce/lapce/commit/07390f0c90c0700d1f69409bf48723d15090c474): Automatic line height
+- [#1262](https://github.com/lapce/lapce/pull/1262): Add absolute/relative copy path to file explorer
+- [#1284](https://github.com/lapce/lapce/pull/1284): Render whitespace (default: none)
+  - ![image](https://user-images.githubusercontent.com/13157904/195410868-f27db85f-d7d2-4197-84f0-12d6c44e2053.png)
+- [#1308](https://github.com/lapce/lapce/pull/1308): Handle LSP ResourceOp
+- [#1251](https://github.com/lapce/lapce/pull/1251): Add vim's paste-before `P` command
+- [#1319](https://github.com/lapce/lapce/pull/1319): Add information page for plugins
+- [#1344](https://github.com/lapce/lapce/pull/1344): Replace the branch-selector menu with a scrollable list
+- [#1352](https://github.com/lapce/lapce/pull/1352): Add duplicate line up/down commands
+- [#1281](https://github.com/lapce/lapce/pull/1281): Implement logic for displaying plugin installation status
+- [#1353](https://github.com/lapce/lapce/pull/1353): Implement syntax aware selection
+- [#1358](https://github.com/lapce/lapce/pull/1358): Add autosave implementation
+- [#1381](https://github.com/lapce/lapce/pull/1381): Show multiple hover items in the hover box
+- [#1040](https://github.com/lapce/lapce/pull/1040): Add keybindings for `Shift-Del`, `Shift-Ins`, and `Ctrl-Ins`
+- [#1401](https://github.com/lapce/lapce/pull/1401): Merge semantic and tree-sitter syntax highlighting
+- [#1426](https://github.com/lapce/lapce/pull/1426): Add cursor position/current selection in status bar
+  - ![image](https://user-images.githubusercontent.com/13157904/195414557-dbf6cff1-3ab2-49ec-ba9d-c7507b2fc83a.png)
+- [#1420](https://github.com/lapce/lapce/pull/1420): Add LSP `codeAction/resolve` support
+- [#1440](https://github.com/lapce/lapce/pull/1440): IME support
+- [#1449](https://github.com/lapce/lapce/pull/1449): Plugin settings in the editor support. Though this still needs some work from plugins to expose them all nicely!
+- [#1441](https://github.com/lapce/lapce/pull/1441): Button for Case-Sensitive search
+- [#1471](https://github.com/lapce/lapce/pull/1471): Add command to (un)install Lapce from/to PATH
+- [#1419](https://github.com/lapce/lapce/pull/1419): Add atomic soft tabs: now you can move your cursor over four spaces as if it was a single block
+
+### Syntax / Extensions
+
+- [#957](https://github.com/lapce/lapce/pull/957): Replace existing tree-sitter syntax highlighting code with part of Helix's better implementation
+  - This means that syntax highlighting for more languages! Such as fixing markdown support, and making so that languages embedded in others (like JavaScript in HTML) work.
+  - Note that not all themes have updated themselves to include the extra scopes/colors.
+- [#1036](https://github.com/lapce/lapce/pull/1036): Recognize ESM/CJS extensions for JavaScript/TypeScript
+- [#1007](https://github.com/lapce/lapce/pull/1007): Add ability to bind a key shortcut for quitting the editor
+- [#1104](https://github.com/lapce/lapce/pull/1104): Add syntax highlighting for Dockerfile, C#, and Nix
+- [#1118](https://github.com/lapce/lapce/pull/1118): Recognize `pyi, pyc, pyd, pyw` extensions for Python
+- [#1122](https://github.com/lapce/lapce/pull/1122): Recognize extensions for DLang
+- [#1335](https://github.com/lapce/lapce/pull/1335): Highlighting for DLang
+- [#1153](https://github.com/lapce/lapce/pull/1050): Recognize and add highlighting for Dart
+- [#1161](https://github.com/lapce/lapce/pull/1161): Recognize and add highlighting for Svelte and LaTeX files
+- [#1299](https://github.com/lapce/lapce/pull/1299): Recognize and add highlighting for Kotlin
+- [#1326](https://github.com/lapce/lapce/pull/1326): Recognize and add highlighting for Vue
+- [#1370](https://github.com/lapce/lapce/pull/1370): Recognize and add highlighting for R
+- [#1416](https://github.com/lapce/lapce/pull/1416): Recognize and add highlighting for Scheme
+- [#1145](https://github.com/lapce/lapce/pull/1145): Adds/Fixes highlighting for C/C++/TypeScript/JavaScript/Zig/Bash
+- [#1272](https://github.com/lapce/lapce/pull/1272): Adds/Fixes highlighting for Elm/JSX/TSX
+- [#1450](https://github.com/lapce/lapce/pull/1450): Add `tf` extension for HCL
+
+### Bug Fixes
+
+- [#1030](https://github.com/lapce/lapce/pull/1030): Don't try to open an font file with an empty name if there is no font family set
+- [9f0120d](https://github.com/lapce/lapce/commit/9f0120df85e3aaaef7fbb43385bb15d88443260a): Fix excessive CPU usage in part of the code
+- [bf5a98a](https://github.com/lapce/lapce/commit/bf5a98a6d432f9d2abdc1737da2d075e204771fb): Fix issue where sometimes Lapce can't open
+- [#1084](https://github.com/lapce/lapce/pull/1084): Use host shell in terminal when running inside Flatpak
+- [#1120](https://github.com/lapce/lapce/pull/1120): Make Alt+Backspace work in the terminal properly
+- [#1127](https://github.com/lapce/lapce/pull/1127): Improve Julia highlighting
+- [#1179](https://github.com/lapce/lapce/pull/1179): Various improvements/fixes to window-tab functionality
+- [#1210](https://github.com/lapce/lapce/pull/1210): Fixed closing modified file when closing split
+- [#1219](https://github.com/lapce/lapce/pull/1219): Fix append command behavior
+- [#1250](https://github.com/lapce/lapce/pull/1250): Fix too long socket path for proxy
+- [#1252](https://github.com/lapce/lapce/pull/1252): Check whether the active editor tab index actually exists, avoiding a potential crash
+- [#1294](https://github.com/lapce/lapce/pull/1294): Backward word deletion should respect whitespace better
+- [#1301](https://github.com/lapce/lapce/pull/1301): Fix incorrect path when going from Url -> PathBuf (such as from an LSP)
+- [#1368](https://github.com/lapce/lapce/pull/1368): Fix tabstop for postfix completions
+- [#1388](https://github.com/lapce/lapce/pull/1388): Fix regex search within the terminal
+- [#1423](https://github.com/lapce/lapce/pull/1423): Fix multiple cursor offset after inserting opening pair
+- [#1434](https://github.com/lapce/lapce/pull/1434): Join PATH with correct platform separator
+- [#1443](https://github.com/lapce/lapce/pull/1443): Correct terminal font sizing
+- [#1453](https://github.com/lapce/lapce/pull/1453): Trim whitespace from search results
+- [#1461](https://github.com/lapce/lapce/pull/1461): Load shell environment when launching from GUI
+- Many more fixes!
+
+### Other
+
+- [#1191](https://github.com/lapce/lapce/pull/1191): Tone down default inlay hint background color in Lapce dark theme
+- [#1227](https://github.com/lapce/lapce/pull/1227): Don't restore cursor mode on undo
+- [#1413](https://github.com/lapce/lapce/pull/1413): Disable format-on-save by default. Remember to re-enable this if you want it!
+- [#1404](https://github.com/lapce/lapce/pull/1404): Log panics with full backtrace as error
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 447f51bd91..59f4b5f963 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -22,6 +22,8 @@ If you encounter a bug when using Lapce, check the issues to see if anyone else
 
 If you want to write some code, develop the documentation, or otherwise work on a certain feature or bug, let us know by replying to or creating an [issue](https://github.com/lapce/lapce/issues).
 
+Run `cargo fmt --all` and `cargo clippy` on your code before submitting pull requests and fix any issues; this makes sure that the CI runs only fail on genuine build errors and not formatting/Clippy lints.
+
 We are currently in the process of improving the documentation for new developers/code contributors. Feel free to get started, or post a message on [Discord](https://discord.gg/n8tGJ6Rn6D) to see what can be done.
 
 ## Contact
diff --git a/Cargo.lock b/Cargo.lock
index c9acaa7a30..f8a6af8049 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14,9 +14,9 @@ dependencies = [
 
 [[package]]
 name = "addr2line"
-version = "0.16.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e61f2b7f93d2c7d2b08263acaa4a363b3e276806c68af6134c44f523bf1aacd"
+checksum = "b9ecd88a8c8378ca913a680cd98f0f13ac67383d35993f86c90a70e3f137816b"
 dependencies = [
  "gimli",
 ]
@@ -27,12 +27,6 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
-[[package]]
-name = "adler32"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
-
 [[package]]
 name = "ahash"
 version = "0.7.6"
@@ -46,18 +40,29 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "0.7.18"
+version = "0.7.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "alacritty_config_derive"
+name = "alacritty_config"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77044c45bdb871e501b5789ad16293ecb619e5733b60f4bb01d1cb31c463c336"
+checksum = "b0c9edf2a6899fc12e9f8718485fa70f2c311bc86c25ff329783b16de7227dfd"
+dependencies = [
+ "log 0.4.17",
+ "serde",
+ "serde_yaml",
+]
+
+[[package]]
+name = "alacritty_config_derive"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37164df1dc70b36db94e2df45b121c1f57b2946778d5f7e56f4b0d1c118e1b54"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -66,24 +71,25 @@ dependencies = [
 
 [[package]]
 name = "alacritty_terminal"
-version = "0.16.1"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02fb5d4af84e39f9754d039ff6de2233c8996dbae0af74910156e559e5766e2f"
+checksum = "043d0bc52432b59149ca25e45ea617cc4cfd2e34acc00d2f7ea976b9934be477"
 dependencies = [
+ "alacritty_config",
  "alacritty_config_derive",
- "base64",
+ "base64 0.13.0",
  "bitflags",
  "dirs",
  "libc",
- "log",
+ "log 0.4.17",
  "mio 0.6.23",
  "mio-anonymous-pipes",
  "mio-extras",
  "miow 0.3.7",
  "nix",
- "parking_lot",
+ "parking_lot 0.12.1",
  "regex-automata",
- "serde 1.0.130",
+ "serde",
  "serde_yaml",
  "signal-hook",
  "signal-hook-mio",
@@ -92,6 +98,21 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "ambient-authority"
+version = "0.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec8ad6edb4840b78c5c3d88de606b22252d552b55f3a4699fbb10fc070ec3049"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "ansi_term"
 version = "0.12.1"
@@ -103,9 +124,15 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.43"
+version = "1.0.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98161a4e3e2184da77bb14f02184cdd111e83bbbcc9979dfee3c44b9a85f5602"
+
+[[package]]
+name = "arc-swap"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28ae2b3dec75a406790005a200b1bd89785afc02517a00ca99ecfe093ee9e6cf"
+checksum = "983cd8b9d4b02a6dc6ffa557262eb5858a27a0038ffffe21a0f133eaa819a164"
 
 [[package]]
 name = "arrayref"
@@ -125,6 +152,34 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
 
+[[package]]
+name = "async-channel"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e14485364214912d3b19cc3435dde4df66065127f05fa0d75c712f36f12c2f28"
+dependencies = [
+ "concurrent-queue",
+ "event-listener",
+ "futures-core",
+]
+
+[[package]]
+name = "async-task"
+version = "4.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a40729d2133846d9ed0ea60a8b9541bccddab49cd30f0715a1da672fe9a2524"
+
+[[package]]
+name = "async-trait"
+version = "0.1.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76464446b8bc32758d7e88ee1a804d9914cd9b1cb264c029899680b0be29826f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "atk"
 version = "0.14.0"
@@ -149,32 +204,53 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "atomic-waker"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "065374052e7df7ee4047b1160cca5e1467a12351a40b3da123c870ba0b8eda2a"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi 0.1.19",
+ "libc",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "autocfg"
-version = "1.0.1"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "backtrace"
-version = "0.3.61"
+version = "0.3.66"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7a905d892734eea339e896738c14b9afce22b5318f64b951e70bf3844419b01"
+checksum = "cab84319d616cfb654d03394f38ab7e6f0919e181b1b57e1fd15e7fb4077d9a7"
 dependencies = [
  "addr2line",
  "cc",
  "cfg-if 1.0.0",
  "libc",
- "miniz_oxide 0.4.4",
- "object 0.26.2",
+ "miniz_oxide",
+ "object",
  "rustc-demangle",
 ]
 
 [[package]]
-name = "base-x"
-version = "0.2.8"
+name = "base64"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4521f3e3d031370679b3b140beb36dfe4801b09ac77e30c61941f97df3ef28b"
+checksum = "7c4a342b450b268e1be8036311e2c613d7f8a7ed31214dff1cc3b60852a3168d"
+dependencies = [
+ "byteorder",
+ "safemem",
+]
 
 [[package]]
 name = "base64"
@@ -183,10 +259,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
 
 [[package]]
-name = "bit-vec"
-version = "0.5.1"
+name = "bincode"
+version = "1.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f59bbe95d4e52a6398ec21238d31577f2b28a9d86807f06ca59d191d8440d0bb"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "bit_field"
@@ -225,63 +304,65 @@ dependencies = [
 ]
 
 [[package]]
-name = "bstr"
-version = "0.2.17"
+name = "block-buffer"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
+checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e"
 dependencies = [
- "lazy_static",
- "memchr",
- "regex-automata",
+ "generic-array",
 ]
 
 [[package]]
-name = "bumpalo"
-version = "3.7.0"
+name = "blocking"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c59e7af012c713f529e7a3ee57ce9b31ddd858d4b512923602f74608b009631"
+checksum = "c6ccb65d468978a086b69884437ded69a90faab3bbe6e67f242173ea728acccc"
+dependencies = [
+ "async-channel",
+ "async-task",
+ "atomic-waker",
+ "fastrand",
+ "futures-lite",
+ "once_cell",
+]
 
 [[package]]
-name = "bytecheck"
-version = "0.6.7"
+name = "bstr"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "314889ea31cda264cb7c3d6e6e5c9415a987ecb0e72c17c00d36fbb881d34abe"
+checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
 dependencies = [
- "bytecheck_derive",
- "ptr_meta",
+ "lazy_static",
+ "memchr",
+ "regex-automata",
 ]
 
 [[package]]
-name = "bytecheck_derive"
-version = "0.6.7"
+name = "bumpalo"
+version = "3.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a2b3b92c135dae665a6f760205b89187638e83bed17ef3e44e83c712cf30600"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
+checksum = "c1ad822118d20d2c234f427000d5acc36eabe1e29a348c89b63dd60b13f28e5d"
 
 [[package]]
 name = "bytecount"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72feb31ffc86498dacdbd0fcebb56138e7177a8cc5cea4516031d15ae85a742e"
+checksum = "2c676a478f63e9fa2dd5368a42f28bba0d6c560b775f38583c8bbaa7fcd67c9c"
 
 [[package]]
 name = "bytemuck"
-version = "1.8.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e851ca7c24871e7336801608a4797d7376545b6928a10d32d75685687141ead"
+checksum = "2f5715e491b5a1598fc2bef5a606847b5dc1d48ea625bd3c02c00de8285591da"
 dependencies = [
  "bytemuck_derive",
 ]
 
 [[package]]
 name = "bytemuck_derive"
-version = "1.0.1"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e215f8c2f9f79cb53c8335e687ffd07d5bfcb6fe5fc80723762d0be46e7cc54"
+checksum = "1b9e1f5fa78f69496407a27ae9ed989e3c3b072310286f5ef385525e4cbc24a9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -296,9 +377,15 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "bytes"
-version = "1.1.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
+checksum = "ec8a7b6a70fde80372154c65702f00a0f56f3e1c36abbc6c440484be248856db"
+
+[[package]]
+name = "cache-padded"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1db59621ec70f09c5e9b597b220c7a2b43611f4710dc03ceb8748637775692c"
 
 [[package]]
 name = "cairo-rs"
@@ -324,11 +411,76 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "cap-fs-ext"
+version = "0.25.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "438ca7f5bb15c799ea146429e4f8b7bfd25ff1eb05319024549a7728de45800c"
+dependencies = [
+ "cap-primitives",
+ "cap-std",
+ "io-lifetimes",
+ "windows-sys",
+]
+
+[[package]]
+name = "cap-primitives"
+version = "0.25.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba063daa90ed40882bb288ac4ecaa942d655d15cf74393d41d2267b5d7daf120"
+dependencies = [
+ "ambient-authority",
+ "fs-set-times",
+ "io-extras",
+ "io-lifetimes",
+ "ipnet",
+ "maybe-owned",
+ "rustix",
+ "winapi-util",
+ "windows-sys",
+ "winx",
+]
+
+[[package]]
+name = "cap-rand"
+version = "0.25.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c720808e249f0ae846ec647fe48cef3cea67e4e5026cf869c041c278b7dcae45"
+dependencies = [
+ "ambient-authority",
+ "rand",
+]
+
+[[package]]
+name = "cap-std"
+version = "0.25.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e3a603c9f3bd2181ed128ab3cd32fbde7cff76afc64a3576662701c4aee7e2b"
+dependencies = [
+ "cap-primitives",
+ "io-extras",
+ "io-lifetimes",
+ "ipnet",
+ "rustix",
+]
+
+[[package]]
+name = "cap-time-ext"
+version = "0.25.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da76e64f3e46f8c8479e392a7fe3faa2e76b8c1cea4618bae445276fdec12082"
+dependencies = [
+ "cap-primitives",
+ "once_cell",
+ "rustix",
+ "winx",
+]
+
 [[package]]
 name = "cc"
-version = "1.0.69"
+version = "1.0.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
 dependencies = [
  "jobserver",
 ]
@@ -365,22 +517,63 @@ dependencies = [
 
 [[package]]
 name = "chrono"
-version = "0.4.19"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
+checksum = "bfd4d1b31faaa3a89d7934dbded3111da0d2ef28e3ebccdb4f0179f5929d1ef1"
 dependencies = [
- "libc",
+ "iana-time-zone",
+ "js-sys",
  "num-integer",
- "num-traits 0.2.14",
+ "num-traits",
  "time 0.1.44",
+ "wasm-bindgen",
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "clap"
+version = "3.2.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86447ad904c7fb335a790c9d7fe3d0d971dc523b8ccd1561a520de9a85302750"
+dependencies = [
+ "atty",
+ "bitflags",
+ "clap_derive",
+ "clap_lex",
+ "indexmap",
+ "once_cell",
+ "strsim",
+ "termcolor",
+ "textwrap",
+]
+
+[[package]]
+name = "clap_derive"
+version = "3.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea0c8bce528c4be4da13ea6fead8965e95b6073585a2f05204bd8f4119f82a65"
+dependencies = [
+ "heck 0.4.0",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+dependencies = [
+ "os_str_bytes",
+]
+
 [[package]]
 name = "cmake"
-version = "0.1.45"
+version = "0.1.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb6210b637171dfba4cda12e579ac6dc73f5165ad56133e5d72ef3131f320855"
+checksum = "e8ad8cef104ac57b68b89df3208164d228503abbdce70f6880ffa3d970e7443a"
 dependencies = [
  "cc",
 ]
@@ -422,29 +615,46 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
+[[package]]
+name = "combine"
+version = "4.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "1.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af4780a44ab5696ea9e28294517f1fffb421a83a25af521333c838635509db9c"
+dependencies = [
+ "cache-padded",
+]
+
 [[package]]
 name = "config"
-version = "0.11.0"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1b9d958c2b1368a663f05538fc1b5975adce1e19f435acceae987aceeeb369"
+checksum = "11f1667b8320afa80d69d8bbe40830df2c8a06003d86f73d8e003b2c48df416d"
 dependencies = [
+ "async-trait",
  "lazy_static",
  "nom",
- "rust-ini",
- "serde 1.0.130",
- "serde-hjson",
- "serde_json",
+ "pathdiff",
+ "serde",
  "toml",
- "yaml-rust",
 ]
 
 [[package]]
 name = "console_error_panic_hook"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8d976903543e0c48546a91908f21588a680a8c8f984df9a5d69feccb2b2a211"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
 dependencies = [
- "cfg-if 0.1.10",
+ "cfg-if 1.0.0",
  "wasm-bindgen",
 ]
 
@@ -454,17 +664,11 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed3d0b5ff30645a68f35ece8cea4556ca14ef8a1651455f789a099a0513532a6"
 
-[[package]]
-name = "const_fn"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f92cfa0fd5690b3cf8c1ef2cabbd9b7ef22fa53cf5e1f92b05103f6d5d1cf6e7"
-
 [[package]]
 name = "core-foundation"
-version = "0.9.1"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a89e2ae426ea83155dccf10c0fa6b1463ef6d5fcb44cee0b224a408fa640a62"
+checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -472,15 +676,15 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea221b5284a47e40033bf9b66f35f984ec0ea2931eb03505246cd27a963f981b"
+checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
 
 [[package]]
 name = "core-graphics"
-version = "0.22.2"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "269f35f69b542b80e736a20a89a05215c0ce80c2c03c514abb2e318b78379d86"
+checksum = "2581bbab3b8ffc6fcbd550bf46c355135d16e9ff2a6ea032ad6b9bf1d7efe4fb"
 dependencies = [
  "bitflags",
  "core-foundation",
@@ -513,89 +717,136 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "cpp_demangle"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eeaa953eaad386a53111e47172c2fedba671e5684c8dd601a5f474f4f118710f"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
 [[package]]
 name = "cpufeatures"
-version = "0.2.1"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
+checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.76.0"
+version = "0.88.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e6bea67967505247f54fa2c85cf4f6e0e31c4e5692c9b70e4ae58e339067333"
+checksum = "52056f6d0584484b57fa6c1a65c1fcb15f3780d8b6a758426d9e3084169b2ddd"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.76.0"
+version = "0.88.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48194035d2752bdd5bdae429e3ab88676e95f52a2b1355a5d4e809f9e39b1d74"
+checksum = "18fed94c8770dc25d01154c3ffa64ed0b3ba9d583736f305fed7beebe5d9cf74"
 dependencies = [
+ "arrayvec 0.7.2",
+ "bumpalo",
  "cranelift-bforest",
  "cranelift-codegen-meta",
  "cranelift-codegen-shared",
  "cranelift-entity",
+ "cranelift-isle",
  "gimli",
- "log",
- "regalloc",
+ "log 0.4.17",
+ "regalloc2",
  "smallvec",
  "target-lexicon",
 ]
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.76.0"
+version = "0.88.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976efb22fcab4f2cd6bd4e9913764616a54d895c1a23530128d04e03633c555f"
+checksum = "1c451b81faf237d11c7e4f3165eeb6bac61112762c5cfe7b4c0fb7241474358f"
 dependencies = [
  "cranelift-codegen-shared",
- "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.76.0"
+version = "0.88.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dabb5fe66e04d4652e434195b45ae65b5c8172d520247b8f66d8df42b2b45dc"
+checksum = "e7c940133198426d26128f08be2b40b0bd117b84771fd36798969c4d712d81fc"
 
 [[package]]
 name = "cranelift-entity"
-version = "0.76.0"
+version = "0.88.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3329733e4d4b8e91c809efcaa4faee80bf66f20164e3dd16d707346bd3494799"
+checksum = "87a0f1b2fdc18776956370cf8d9b009ded3f855350c480c1c52142510961f352"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.76.0"
+version = "0.88.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "279afcc0d3e651b773f94837c3d581177b348c8d69e928104b2e9fccb226f921"
+checksum = "34897538b36b216cc8dd324e73263596d51b8cf610da6498322838b2546baf8a"
 dependencies = [
  "cranelift-codegen",
- "log",
+ "log 0.4.17",
  "smallvec",
  "target-lexicon",
 ]
 
+[[package]]
+name = "cranelift-isle"
+version = "0.88.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b2629a569fae540f16a76b70afcc87ad7decb38dc28fa6c648ac73b51e78470"
+
+[[package]]
+name = "cranelift-native"
+version = "0.88.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20937dab4e14d3e225c5adfc9c7106bafd4ac669bdb43027b911ff794c6fb318"
+dependencies = [
+ "cranelift-codegen",
+ "libc",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-wasm"
+version = "0.88.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80fc2288957a94fd342a015811479de1837850924166d1f1856d8406e6f3609b"
+dependencies = [
+ "cranelift-codegen",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "itertools",
+ "log 0.4.17",
+ "smallvec",
+ "wasmparser",
+ "wasmtime-types",
+]
+
 [[package]]
 name = "crc32fast"
-version = "1.2.1"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81156fece84ab6a9f2afdb109ce3ae577e42b1228441eded99bd77f627953b1a"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
 dependencies = [
  "cfg-if 1.0.0",
 ]
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.1"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
+checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
 dependencies = [
  "cfg-if 1.0.0",
  "crossbeam-utils",
@@ -603,9 +854,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
+checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
 dependencies = [
  "cfg-if 1.0.0",
  "crossbeam-epoch",
@@ -614,32 +865,43 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.5"
+version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
+checksum = "045ebe27666471bb549370b4b0b3e51b07f56325befa4284db65fc89c02511b1"
 dependencies = [
+ "autocfg",
  "cfg-if 1.0.0",
  "crossbeam-utils",
- "lazy_static",
  "memoffset",
+ "once_cell",
  "scopeguard",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.5"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
+checksum = "51887d4adc7b564537b15adcfb307936f8075dfcd5f00dde9a9f1d29383682bc"
 dependencies = [
  "cfg-if 1.0.0",
- "lazy_static",
+ "once_cell",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
 ]
 
 [[package]]
 name = "darling"
-version = "0.13.1"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0d720b8683f8dd83c65155f0530560cba68cd2bf395f6513a483caee57ff7f4"
+checksum = "a01d95850c592940db9b8194bc39f4bc0e89dee5c4265e4b1807c34a9aba453c"
 dependencies = [
  "darling_core",
  "darling_macro",
@@ -647,9 +909,9 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.13.1"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a340f241d2ceed1deb47ae36c4144b2707ec7dd0b649f894cb39bb595986324"
+checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610"
 dependencies = [
  "fnv",
  "ident_case",
@@ -661,9 +923,9 @@ dependencies = [
 
 [[package]]
 name = "darling_macro"
-version = "0.13.1"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72c41b3b7352feb3211a0d743dc5700a4e3b60f51bd2b368892d1e0f9a95f44b"
+checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835"
 dependencies = [
  "darling_core",
  "quote",
@@ -672,35 +934,30 @@ dependencies = [
 
 [[package]]
 name = "data-url"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d33fe99ccedd6e84bc035f1931bb2e6be79739d6242bd895e7311c886c50dc9c"
+checksum = "3a30bfce702bcfa94e906ef82421f2c0e61c076ad76030c16ee5d2e9a32fe193"
 dependencies = [
  "matches",
 ]
 
 [[package]]
-name = "deflate"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c86f7e25f518f4b81808a2cf1c50996a61f5c2eb394b2393bd87f2a4780a432f"
+name = "digest"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
 dependencies = [
- "adler32",
+ "generic-array",
 ]
 
-[[package]]
-name = "diff"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
-
 [[package]]
 name = "digest"
-version = "0.9.0"
+version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+checksum = "adfbc57365a37acbd2ebf2b64d7e69bb766e2fea813521ed536f5d0520dcf86c"
 dependencies = [
- "generic-array",
+ "block-buffer 0.10.3",
+ "crypto-common",
 ]
 
 [[package]]
@@ -712,11 +969,21 @@ dependencies = [
  "dirs-sys",
 ]
 
+[[package]]
+name = "directories-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339ee130d97a610ea5a5872d2bbb130fdf68884ff09d3028b81bec8a1ac23bbc"
+dependencies = [
+ "cfg-if 1.0.0",
+ "dirs-sys-next",
+]
+
 [[package]]
 name = "dirs"
-version = "3.0.2"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30baa043103c9d0c2a57cf537cc2f35623889dc0d405e6c3cccfadbc81c71309"
+checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
 dependencies = [
  "dirs-sys",
 ]
@@ -733,9 +1000,9 @@ dependencies = [
 
 [[package]]
 name = "dirs-sys"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03d86534ed367a67548dc68113a0f5db55432fdfbb6e6f9d77704397d95d5780"
+checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
 dependencies = [
  "libc",
  "redox_users",
@@ -753,12 +1020,6 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
-[[package]]
-name = "discard"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "212d0f5754cb6769937f4501cc0e67f4f4483c8d2c3e1e922ee9edbe4ab4c7c0"
-
 [[package]]
 name = "dlib"
 version = "0.5.0"
@@ -768,10 +1029,20 @@ dependencies = [
  "libloading",
 ]
 
+[[package]]
+name = "dmg"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e565b39e64e4030c75320536cc18cd51f0636811c53d98a05f01ec5deb8dd8f"
+dependencies = [
+ "log 0.3.9",
+ "plist",
+]
+
 [[package]]
 name = "druid"
 version = "0.7.0"
-source = "git+https://github.com/lapce/druid?branch=shell_opengl#5a8f806121332581114a2628b9dc9937b70e52c2"
+source = "git+https://github.com/lapce/druid?branch=shell_opengl#0b9c00fcda238e392e758382f25166cd748fd305"
 dependencies = [
  "console_error_panic_hook",
  "druid-derive",
@@ -783,7 +1054,7 @@ dependencies = [
  "im",
  "instant",
  "tracing",
- "tracing-subscriber 0.3.6",
+ "tracing-subscriber",
  "tracing-wasm",
  "unic-langid",
  "unicode-segmentation",
@@ -794,7 +1065,7 @@ dependencies = [
 [[package]]
 name = "druid-derive"
 version = "0.4.0"
-source = "git+https://github.com/lapce/druid?branch=shell_opengl#5a8f806121332581114a2628b9dc9937b70e52c2"
+source = "git+https://github.com/lapce/druid?branch=shell_opengl#0b9c00fcda238e392e758382f25166cd748fd305"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -804,7 +1075,7 @@ dependencies = [
 [[package]]
 name = "druid-shell"
 version = "0.7.0"
-source = "git+https://github.com/lapce/druid?branch=shell_opengl#5a8f806121332581114a2628b9dc9937b70e52c2"
+source = "git+https://github.com/lapce/druid?branch=shell_opengl#0b9c00fcda238e392e758382f25166cd748fd305"
 dependencies = [
  "anyhow",
  "bitflags",
@@ -831,7 +1102,7 @@ dependencies = [
  "objc",
  "piet-wgpu",
  "scopeguard",
- "time 0.3.9",
+ "time 0.3.14",
  "tracing",
  "wasm-bindgen",
  "web-sys",
@@ -839,12 +1110,6 @@ dependencies = [
  "wio",
 ]
 
-[[package]]
-name = "dtoa"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56899898ce76aaf4a0f24d914c97ea6ed976d42fec6ad33fcbb0a1103e07b2b0"
-
 [[package]]
 name = "dwrote"
 version = "0.11.0"
@@ -857,17 +1122,23 @@ dependencies = [
  "wio",
 ]
 
+[[package]]
+name = "dyn-clone"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9b0705efd4599c15a38151f4721f7bc388306f61084d3bfd50bd07fbca5cb60"
+
 [[package]]
 name = "either"
-version = "1.6.1"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
 
 [[package]]
 name = "encoding_rs"
-version = "0.8.30"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7896dc8abb250ffdda33912550faa54c88ec8b998dec0b2c55ab224921ce11df"
+checksum = "9852635589dc9f9ea1b6fe9f05b50ef208c85c834a562f0c6abb1c475736ec2b"
 dependencies = [
  "cfg-if 1.0.0",
 ]
@@ -882,47 +1153,65 @@ dependencies = [
 ]
 
 [[package]]
-name = "enumset"
-version = "1.0.8"
+name = "env_logger"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6216d2c19a6fb5f29d1ada1dc7bc4367a8cbf0fa4af5cf12e07b5bbdde6b5b2c"
+checksum = "c90bf5f19754d10198ccb95b70664fc925bd1fc090a0fd9a6ebc54acc8cd6272"
 dependencies = [
- "enumset_derive",
+ "atty",
+ "humantime",
+ "log 0.4.17",
+ "regex",
+ "termcolor",
 ]
 
 [[package]]
-name = "enumset_derive"
-version = "0.5.5"
+name = "errno"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6451128aa6655d880755345d085494cf7561a6bee7c8dc821e5d77e6d267ecd4"
+checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
 dependencies = [
- "darling",
- "proc-macro2",
- "quote",
- "syn",
+ "errno-dragonfly",
+ "libc",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "errno-dragonfly"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+dependencies = [
+ "cc",
+ "libc",
 ]
 
 [[package]]
 name = "euclid"
-version = "0.22.6"
+version = "0.22.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da96828553a086d7b18dcebfc579bd9628b016f86590d7453c115e490fa74b80"
+checksum = "b52c2ef4a78da0ba68fbe1fd920627411096d2ac478f7f4c9f3a54ba6705bade"
 dependencies = [
- "num-traits 0.2.14",
+ "num-traits",
 ]
 
+[[package]]
+name = "event-listener"
+version = "2.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
+
 [[package]]
 name = "exr"
-version = "1.4.2"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14cc0e06fb5f67e5d6beadf3a382fec9baca1aa751c6d5368fdeee7e5932c215"
+checksum = "c9a7880199e74c6d3fe45579df2f436c5913a71405494cb89d59234d86b47dc5"
 dependencies = [
  "bit_field",
- "deflate",
  "flume",
  "half",
- "inflate",
  "lebe",
+ "miniz_oxide",
  "smallvec",
  "threadpool",
 ]
@@ -935,20 +1224,20 @@ checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
 
 [[package]]
 name = "fastrand"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
 dependencies = [
  "instant",
 ]
 
 [[package]]
 name = "fern"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9a4820f0ccc8a7afd67c39a0f1a0f4b07ca1725164271a64939d7aeb9af065"
+checksum = "3bdd7b0849075e79ee9a1836df22c717d1eba30451796fdc631b04565dd11e2a"
 dependencies = [
- "log",
+ "log 0.4.17",
 ]
 
 [[package]]
@@ -958,19 +1247,29 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e1c54951450cbd39f3dbcf1005ac413b49487dabf18a720ad2383eccfeffb92"
 dependencies = [
  "memoffset",
- "rustc_version 0.3.3",
+ "rustc_version",
+]
+
+[[package]]
+name = "file-per-thread-logger"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21e16290574b39ee41c71aeb90ae960c504ebaf1e2a1c87bd52aa56ed6e1a02f"
+dependencies = [
+ "env_logger",
+ "log 0.4.17",
 ]
 
 [[package]]
 name = "filetime"
-version = "0.2.15"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "975ccf83d8d9d0d84682850a38c8169027be83368805971cc4f238c2b245bc98"
+checksum = "e94a7bbaa59354bc20dd75b67f23e2797b4490e9d6928203fb105c79e448c86c"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
  "redox_syscall",
- "winapi 0.3.9",
+ "windows-sys",
 ]
 
 [[package]]
@@ -981,14 +1280,12 @@ checksum = "37ab347416e802de484e4d03c7316c48f1ecb56574dfd4a46a80f173ce1de04d"
 
 [[package]]
 name = "flate2"
-version = "1.0.22"
+version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e6988e897c1c9c485f43b47a529cef42fde0547f9d8d41a7062518f1d8fc53f"
+checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
 dependencies = [
- "cfg-if 1.0.0",
  "crc32fast",
- "libc",
- "miniz_oxide 0.4.4",
+ "miniz_oxide",
 ]
 
 [[package]]
@@ -1015,21 +1312,21 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4fc612c5837986b7104a87a0df74a5460931f1c5274be12f8d0f40aa2f30d632"
 dependencies = [
- "num-traits 0.2.14",
+ "num-traits",
 ]
 
 [[package]]
 name = "fluent-bundle"
-version = "0.15.1"
+version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8acf044eeb4872d9dbf2667541fbf461f5965c57e343878ad0fb24b5793fa007"
+checksum = "e242c601dec9711505f6d5bbff5bedd4b61b2469f2e8bb8e57ee7c9747a87ffd"
 dependencies = [
  "fluent-langneg",
  "fluent-syntax",
  "intl-memoizer",
  "intl_pluralrules",
- "ouroboros",
  "rustc-hash",
+ "self_cell",
  "smallvec",
  "unic-langid",
 ]
@@ -1054,9 +1351,9 @@ dependencies = [
 
 [[package]]
 name = "flume"
-version = "0.10.12"
+version = "0.10.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843c03199d0c0ca54bc1ea90ac0d507274c28abcc4f691ae8b4eaa375087c76a"
+checksum = "1657b4441c3403d9f7b3409e47575237dac27b1b5726df654a6ecbf92f0f7577"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1087,7 +1384,7 @@ dependencies = [
  "freetype",
  "lazy_static",
  "libc",
- "log",
+ "log 0.4.17",
  "pathfinder_geometry",
  "pathfinder_simd",
  "walkdir",
@@ -1110,7 +1407,7 @@ version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e58903f4f8d5b58c7d300908e4ebe5289c1bfdf5587964330f12023b8ff17fd1"
 dependencies = [
- "log",
+ "log 0.4.17",
  "memmap2 0.2.3",
  "ttf-parser 0.12.3",
 ]
@@ -1122,9 +1419,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "122fa73a5566372f9df09768a16e8e3dad7ad18abe07835f1f0b71f84078ba4c"
 dependencies = [
  "fontconfig-parser",
- "log",
- "memmap2 0.5.3",
- "ttf-parser 0.15.0",
+ "log 0.4.17",
+ "memmap2 0.5.7",
+ "ttf-parser 0.15.2",
 ]
 
 [[package]]
@@ -1144,21 +1441,20 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 
 [[package]]
 name = "form_urlencoded"
-version = "1.0.1"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
+checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
 dependencies = [
- "matches",
  "percent-encoding",
 ]
 
 [[package]]
 name = "fount"
 version = "0.1.0"
-source = "git+https://github.com/lapce/fount#bfe215c0f82595361dc2385bed5a8687a41e5dd2"
+source = "git+https://github.com/lapce/fount#3bfdc689c0cfbeb498358c79c7be2cb3beb44efe"
 dependencies = [
  "font-kit",
- "memmap2 0.5.3",
+ "memmap2 0.5.7",
  "swash",
 ]
 
@@ -1184,33 +1480,31 @@ dependencies = [
 ]
 
 [[package]]
-name = "fs2"
-version = "0.4.3"
+name = "fs-set-times"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
+checksum = "a267b6a9304912e018610d53fe07115d8b530b160e85db4d2d3a59f3ddde1aec"
 dependencies = [
- "libc",
- "winapi 0.3.9",
+ "io-lifetimes",
+ "rustix",
+ "windows-sys",
 ]
 
 [[package]]
-name = "fsevent"
-version = "0.4.0"
+name = "fs2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ab7d1bd1bd33cc98b0889831b72da23c0aa4df9cec7e0702f46ecea04b35db6"
+checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
 dependencies = [
- "bitflags",
- "fsevent-sys 2.0.1",
+ "libc",
+ "winapi 0.3.9",
 ]
 
 [[package]]
-name = "fsevent-sys"
-version = "2.0.1"
+name = "fs_extra"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f41b048a94555da0f42f1d632e2e19510084fb8e303b0daa2816e733fb3644a0"
-dependencies = [
- "libc",
-]
+checksum = "2022715d62ab30faffd124d40b76f4134a550a87792276512b18d63272333394"
 
 [[package]]
 name = "fsevent-sys"
@@ -1237,26 +1531,42 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
 
+[[package]]
+name = "futures"
+version = "0.3.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f21eda599937fba36daeb58a22e8f5cee2d14c4a17b5b7739c7c8e5e3b8230c"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-channel"
-version = "0.3.21"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3083ce4b914124575708913bca19bfe887522d6e2e6d0952943f5eac4a74010"
+checksum = "30bdd20c28fadd505d0fd6712cdfcb0d4b5648baf45faef7f852afb2399bb050"
 dependencies = [
  "futures-core",
+ "futures-sink",
 ]
 
 [[package]]
 name = "futures-core"
-version = "0.3.21"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3"
+checksum = "4e5aa3de05362c3fb88de6531e6296e85cde7739cccad4b9dfeeb7f6ebce56bf"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.21"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9420b90cfa29e327d0429f19be13e7ddb68fa1cccb09d65e5706b8c7a749b8a6"
+checksum = "9ff63c23854bee61b6e9cd331d523909f238fc7636290b96826e9cfa5faa00ab"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1265,30 +1575,59 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.21"
+version = "0.3.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbf4d2a7a308fd4578637c0b17c7e1c7ba127b8f6ba00b29f717e9655d85eb68"
+
+[[package]]
+name = "futures-lite"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694489acd39452c77daa48516b894c153f192c3578d5a839b62c58099fcbf48"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "memchr",
+ "parking",
+ "pin-project-lite",
+ "waker-fn",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc4045962a5a5e935ee2fdedaa4e08284547402885ab326734432bed5d12966b"
+checksum = "42cd15d1c7456c04dbdf7e88bcd69760d74f3a798d6444e16974b505b0e62f17"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "futures-sink"
-version = "0.3.21"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21163e139fa306126e6eedaf49ecdb4588f939600f0b1e770f4205ee4b7fa868"
+checksum = "21b20ba5a92e727ba30e72834706623d94ac93a725410b6a6b6fbc1b07f7ba56"
 
 [[package]]
 name = "futures-task"
-version = "0.3.21"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c66a976bf5909d801bbef33416c41372779507e7a6b3a5e25e4749c58f776a"
+checksum = "a6508c467c73851293f390476d4491cf4d227dbabcd4170f3bb6044959b294f1"
 
 [[package]]
 name = "futures-util"
-version = "0.3.21"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8b7abd5d659d9b90c8cba917f6ec750a74e2dc23902ef9cd4cc8c8b22e6036a"
+checksum = "44fb6cb1be61cc1d2e43b262516aafcf63b241cffdb1d3fa115f91d9c7b09c90"
 dependencies = [
+ "futures-channel",
  "futures-core",
  "futures-io",
+ "futures-macro",
+ "futures-sink",
  "futures-task",
  "memchr",
  "pin-project-lite",
@@ -1372,20 +1711,11 @@ dependencies = [
  "system-deps",
 ]
 
-[[package]]
-name = "generational-arena"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e1d3b771574f62d0548cee0ad9057857e9fc25d7a3335f140c84f6acd0bf601"
-dependencies = [
- "cfg-if 0.1.10",
-]
-
 [[package]]
 name = "generic-array"
-version = "0.14.4"
+version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
+checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
 dependencies = [
  "typenum",
  "version_check",
@@ -1402,22 +1732,22 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.6"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad"
+checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6"
 dependencies = [
  "cfg-if 1.0.0",
  "js-sys",
  "libc",
- "wasi 0.10.0+wasi-snapshot-preview1",
+ "wasi 0.11.0+wasi-snapshot-preview1",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "gif"
-version = "0.11.3"
+version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3a7187e78088aead22ceedeee99779455b23fc231fe13ec443f99bb71694e5b"
+checksum = "3edd93c6756b4dfaf2709eafcc345ba2636565295c198a9cfbf75fa5e3e00b06"
 dependencies = [
  "color_quant",
  "weezl",
@@ -1425,9 +1755,9 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.25.0"
+version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0a01e0497841a3b2db4f8afa483cce65f7e96a3498bd6c541734792aeac8fe7"
+checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d"
 dependencies = [
  "fallible-iterator",
  "indexmap",
@@ -1466,14 +1796,14 @@ dependencies = [
 
 [[package]]
 name = "git2"
-version = "0.14.4"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0155506aab710a86160ddb504a480d2964d7ab5b9e62419be69e0032bc5931c"
+checksum = "ccf7f68c2995f392c49fffb4f95ae2c873297830eb25c6bc4c114ce8f4562acc"
 dependencies = [
  "bitflags",
  "libc",
  "libgit2-sys",
- "log",
+ "log 0.4.17",
  "openssl-probe",
  "openssl-sys",
  "url",
@@ -1486,8 +1816,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d"
 dependencies = [
  "khronos_api",
- "log",
- "xml-rs",
+ "log 0.4.17",
+ "xml-rs 0.8.4",
 ]
 
 [[package]]
@@ -1561,14 +1891,14 @@ checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
 
 [[package]]
 name = "globset"
-version = "0.4.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd"
+checksum = "0a1e17342619edbc21a964c2afbeb6c820c6a2560032872f397bb97ea127bd0a"
 dependencies = [
  "aho-corasick",
  "bstr",
  "fnv",
- "log",
+ "log 0.4.17",
  "regex",
 ]
 
@@ -1615,14 +1945,14 @@ dependencies = [
 
 [[package]]
 name = "grep-regex"
-version = "0.1.9"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "121553c9768c363839b92fc2d7cdbbad44a3b70e8d6e7b1b72b05c977527bd06"
+checksum = "1345f8d33c89f2d5b081f2f2a41175adef9fd0bed2fea6a26c96c2deb027e58e"
 dependencies = [
  "aho-corasick",
  "bstr",
  "grep-matcher",
- "log",
+ "log 0.4.17",
  "regex",
  "regex-syntax",
  "thread_local",
@@ -1630,17 +1960,17 @@ dependencies = [
 
 [[package]]
 name = "grep-searcher"
-version = "0.1.8"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fbdbde90ba52adc240d2deef7b6ad1f99f53142d074b771fe9b7bede6c4c23d"
+checksum = "48852bd08f9b4eb3040ecb6d2f4ade224afe880a9a0909c5563cc59fa67932cc"
 dependencies = [
  "bstr",
  "bytecount",
  "encoding_rs",
  "encoding_rs_io",
  "grep-matcher",
- "log",
- "memmap2 0.3.1",
+ "log 0.4.17",
+ "memmap2 0.5.7",
 ]
 
 [[package]]
@@ -1701,9 +2031,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.3.13"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37a82c6d637fc9515a4694bbf1cb2457b79d81ce52b3108bdeea58b07dd34a57"
+checksum = "5ca32592cf21ac7ccab1825cd87f6c9b3d9022c44d086172ed0966bec8af30be"
 dependencies = [
  "bytes",
  "fnv",
@@ -1733,6 +2063,16 @@ dependencies = [
  "ahash",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash",
+ "serde",
+]
+
 [[package]]
 name = "heck"
 version = "0.3.3"
@@ -1758,22 +2098,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "home"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2456aef2e6b6a9784192ae780c0f15bc57df0e918585282325e8c8ac27737654"
-dependencies = [
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "hotwatch"
-version = "0.4.6"
+name = "hermit-abi"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39301670a6f5798b75f36a1b149a379a50df5aa7c71be50f4b41ec6eab445cb8"
+checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
 dependencies = [
- "log",
- "notify 4.0.17",
+ "libc",
 ]
 
 [[package]]
@@ -1784,7 +2114,7 @@ checksum = "75f43d41e26995c17e71ee126451dd3941010b0514a81a9d11f3b341debc2399"
 dependencies = [
  "bytes",
  "fnv",
- "itoa 1.0.2",
+ "itoa",
 ]
 
 [[package]]
@@ -1800,9 +2130,9 @@ dependencies = [
 
 [[package]]
 name = "httparse"
-version = "1.7.1"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "496ce29bb5a52785b44e0f7ca2847ae0bb839c9bd28f69acac9b99d461c0c04c"
+checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
 
 [[package]]
 name = "httpdate"
@@ -1810,11 +2140,22 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
 
+[[package]]
+name = "human-sort"
+version = "0.2.2"
+source = "git+https://github.com/dragazo/human-sort#1e74db1e09e8194ba88ad983723cf6f8b0c365da"
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
 [[package]]
 name = "hyper"
-version = "0.14.19"
+version = "0.14.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42dc3c131584288d375f2d07f822b0cb012d8c6fb899a5b9fdb3cb7eb9b6004f"
+checksum = "02c929dc5c39e335a03c405292728118860721b10190d98c2a0f0efd5baafbac"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -1825,7 +2166,7 @@ dependencies = [
  "http-body",
  "httparse",
  "httpdate",
- "itoa 1.0.2",
+ "itoa",
  "pin-project-lite",
  "socket2",
  "tokio",
@@ -1847,6 +2188,19 @@ dependencies = [
  "tokio-native-tls",
 ]
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd911b35d940d2bd0bea0f9100068e5b97b51a1cbe13d13382f132e0365257a0"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "js-sys",
+ "wasm-bindgen",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -1855,11 +2209,10 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
 [[package]]
 name = "idna"
-version = "0.2.3"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
 dependencies = [
- "matches",
  "unicode-bidi",
  "unicode-normalization",
 ]
@@ -1873,7 +2226,7 @@ dependencies = [
  "crossbeam-utils",
  "globset",
  "lazy_static",
- "log",
+ "log 0.4.17",
  "memchr",
  "regex",
  "same-file",
@@ -1884,14 +2237,14 @@ dependencies = [
 
 [[package]]
 name = "im"
-version = "15.0.0"
+version = "15.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "111c1983f3c5bb72732df25cddacee9b546d08325fb584b5ebd38148be7b0246"
+checksum = "d0acd33ff0285af998aaf9b57342af478078f53492322fafc47450e09397e0e9"
 dependencies = [
  "bitmaps",
  "rand_core",
  "rand_xoshiro",
- "serde 1.0.130",
+ "serde",
  "sized-chunks",
  "typenum",
  "version_check",
@@ -1899,9 +2252,9 @@ dependencies = [
 
 [[package]]
 name = "image"
-version = "0.24.2"
+version = "0.24.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28edd9d7bc256be2502e325ac0628bde30b7001b9b52e0abe31a1a9dc2701212"
+checksum = "bd8e4fb07cf672b1642304e731ef8a6a4c7891d67bb4fd4f5ce58cd6ed86803c"
 dependencies = [
  "bytemuck",
  "byteorder",
@@ -1909,9 +2262,8 @@ dependencies = [
  "exr",
  "gif",
  "jpeg-decoder",
- "num-iter",
  "num-rational",
- "num-traits 0.2.14",
+ "num-traits",
  "png",
  "scoped_threadpool",
  "tiff",
@@ -1919,9 +2271,9 @@ dependencies = [
 
 [[package]]
 name = "include_dir"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31a924bd335356c7622dff9ee33d06920afcf7f762a1a991236645e08c8a484b"
+checksum = "24b56e147e6187d61e9d0f039f10e070d0c0a887e24fe0bb9ca3f29bfde62cab"
 dependencies = [
  "glob",
  "include_dir_impl",
@@ -1930,9 +2282,9 @@ dependencies = [
 
 [[package]]
 name = "include_dir_impl"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afae3917f781921d7c7813992ccadff7e816f7e6ecb4b70a9ec3e740d51da3d6"
+checksum = "0a0c890c85da4bab7bce4204c707396bbd3c6c8a681716a51c8814cfc2b682df"
 dependencies = [
  "anyhow",
  "proc-macro-hack",
@@ -1943,33 +2295,13 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "1.7.0"
+version = "1.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc633605454125dec4b66843673f01c7df2b89479b32e0ed634e43a91cff62a5"
+checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
 dependencies = [
  "autocfg",
- "hashbrown",
- "serde 1.0.130",
-]
-
-[[package]]
-name = "inflate"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cdb29978cc5797bd8dcc8e5bf7de604891df2a8dc576973d71a281e916db2ff"
-dependencies = [
- "adler32",
-]
-
-[[package]]
-name = "inotify"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4816c66d2c8ae673df83366c18341538f234a26d65a9ecea5c348b453ac1d02f"
-dependencies = [
- "bitflags",
- "inotify-sys",
- "libc",
+ "hashbrown 0.12.3",
+ "serde",
 ]
 
 [[package]]
@@ -1994,9 +2326,9 @@ dependencies = [
 
 [[package]]
 name = "instant"
-version = "0.1.10"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bee0328b1209d157ef001c94dd85b4f8f64139adb0eac2659f4b08382b2f474d"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
 dependencies = [
  "cfg-if 1.0.0",
  "js-sys",
@@ -2004,6 +2336,23 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "interprocess"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c58ec7fbda1df9a93f587b780659db3c99f61f4be27f9c82c9b37684ffd0366"
+dependencies = [
+ "blocking",
+ "cfg-if 1.0.0",
+ "futures",
+ "intmap",
+ "libc",
+ "once_cell",
+ "spinning",
+ "thiserror",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "intl-memoizer"
 version = "0.5.1"
@@ -2024,6 +2373,32 @@ dependencies = [
  "unic-langid",
 ]
 
+[[package]]
+name = "intmap"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae52f28f45ac2bc96edb7714de995cffc174a395fb0abf5bff453587c980d7b9"
+
+[[package]]
+name = "io-extras"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5d8c2ab5becd8720e30fd25f8fa5500d8dc3fceadd8378f05859bd7b46fc49"
+dependencies = [
+ "io-lifetimes",
+ "windows-sys",
+]
+
+[[package]]
+name = "io-lifetimes"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ea37f355c05dde75b84bba2d767906ad522e97cd9e2eef2be7a4ab7fb442c06"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
 [[package]]
 name = "iovec"
 version = "0.1.4"
@@ -2040,60 +2415,86 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "879d54834c8c76457ef4293a689b2a8c59b076067ad77b15efafbb05f92a592b"
 
 [[package]]
-name = "itertools"
-version = "0.10.3"
+name = "is-terminal"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
+checksum = "0d508111813f9af3afd2f92758f77e4ed2cc9371b642112c6a48d22eb73105c5"
 dependencies = [
- "either",
+ "hermit-abi 0.2.6",
+ "io-lifetimes",
+ "rustix",
+ "windows-sys",
 ]
 
 [[package]]
-name = "itoa"
-version = "0.4.8"
+name = "itertools"
+version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
 
 [[package]]
 name = "itoa"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d"
+checksum = "6c8af84674fe1f223a982c933a0ee1086ac4d4052aa0fb8060c12c6ad838e754"
+
+[[package]]
+name = "ittapi"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8c4f6ff06169ce7048dac5150b1501c7e3716a929721aeb06b87e51a43e42f4"
+dependencies = [
+ "anyhow",
+ "ittapi-sys",
+ "log 0.4.17",
+]
+
+[[package]]
+name = "ittapi-sys"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e078cce01485f418bae3beb34dd604aaedf2065502853c7da17fbce8e64eda"
+dependencies = [
+ "cc",
+]
 
 [[package]]
 name = "jobserver"
-version = "0.1.24"
+version = "0.1.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af25a77299a7f711a01975c35a6a424eb6862092cc2d6c72c4ed6cbc56dfc1fa"
+checksum = "068b1ee6743e4d11fb9c6a1e6064b3693a1b600e7f5f5988047d98b3dc9fb90b"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "jpeg-decoder"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "744c24117572563a98a7e9168a5ac1ee4a1ca7f702211258797bbe0ed0346c3c"
+checksum = "9478aa10f73e7528198d75109c8be5cd7d15fb530238040148d5f9a22d4c5b3b"
 dependencies = [
  "rayon",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.53"
+version = "0.3.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4bf49d50e2961077d9c99f4b7997d770a1114f087c3c2e0069b36c13fc2979d"
+checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
 dependencies = [
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "jsonrpc-lite"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a98d245f26984add78277a5306ca0cf774863d4eddb4912b31d94ee3fa1a22d4"
+checksum = "bb4128aba82294c14af2998831c4df3c843940e92b5cfc41bac1229d1e63b88c"
 dependencies = [
- "serde 1.0.130",
+ "serde",
  "serde_derive",
  "serde_json",
 ]
@@ -2125,9 +2526,9 @@ checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
 
 [[package]]
 name = "kqueue"
-version = "1.0.4"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "058a107a784f8be94c7d35c1300f4facced2e93d2fbe5b1452b44e905ddca4a9"
+checksum = "4d6112e8f37b59803ac47a42d14f1f3a59bbf72fc6857ffc5be455e28a691f8e"
 dependencies = [
  "kqueue-sys",
  "libc",
@@ -2150,12 +2551,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a53776d271cfb873b17c618af0298445c88afc52837f3e948fa3fafd131f449"
 dependencies = [
  "arrayvec 0.7.2",
- "serde 1.0.130",
+ "serde",
 ]
 
 [[package]]
 name = "lapce"
-version = "0.1.2"
+version = "0.2.6"
 dependencies = [
  "lapce-proxy",
  "lapce-ui",
@@ -2163,200 +2564,246 @@ dependencies = [
 
 [[package]]
 name = "lapce-core"
-version = "0.1.2"
+version = "0.2.6"
 dependencies = [
+ "anyhow",
+ "arc-swap",
  "bitflags",
+ "directories",
  "itertools",
  "lapce-rpc",
- "log",
+ "lapce-xi-rope",
+ "log 0.4.17",
  "lsp-types",
- "serde 1.0.130",
- "serde_json",
- "strum 0.24.0",
- "strum_macros 0.24.0",
+ "once_cell",
+ "serde",
+ "slotmap",
+ "strum",
+ "strum_macros",
  "thiserror",
  "tree-sitter",
+ "tree-sitter-bash",
  "tree-sitter-c",
+ "tree-sitter-c-sharp",
+ "tree-sitter-clojure",
+ "tree-sitter-cmake",
  "tree-sitter-cpp",
+ "tree-sitter-css",
+ "tree-sitter-d",
+ "tree-sitter-dart",
+ "tree-sitter-dockerfile",
  "tree-sitter-elixir",
  "tree-sitter-elm",
+ "tree-sitter-erlang",
  "tree-sitter-glimmer",
+ "tree-sitter-glsl",
  "tree-sitter-go",
+ "tree-sitter-hare",
  "tree-sitter-haskell",
  "tree-sitter-haxe",
  "tree-sitter-hcl",
- "tree-sitter-highlight",
  "tree-sitter-html",
  "tree-sitter-java",
  "tree-sitter-javascript",
  "tree-sitter-json",
+ "tree-sitter-julia",
+ "tree-sitter-kotlin",
+ "tree-sitter-latex",
+ "tree-sitter-lua",
  "tree-sitter-md",
+ "tree-sitter-nix",
  "tree-sitter-ocaml",
  "tree-sitter-php",
+ "tree-sitter-prisma-io",
+ "tree-sitter-protobuf",
  "tree-sitter-python",
  "tree-sitter-ql",
+ "tree-sitter-r",
  "tree-sitter-ruby",
  "tree-sitter-rust",
+ "tree-sitter-scheme",
  "tree-sitter-scss",
+ "tree-sitter-sql",
+ "tree-sitter-svelte",
  "tree-sitter-swift",
  "tree-sitter-toml",
  "tree-sitter-typescript",
- "xi-rope",
+ "tree-sitter-vue",
+ "tree-sitter-wgsl",
+ "tree-sitter-xml",
+ "tree-sitter-yaml",
+ "tree-sitter-zig",
 ]
 
 [[package]]
 name = "lapce-data"
-version = "0.1.2"
+version = "0.2.6"
 dependencies = [
- "Inflector",
  "alacritty_terminal",
  "anyhow",
- "base64",
- "bit-vec",
- "bitflags",
  "bytemuck",
  "chrono",
+ "clap",
  "config",
  "crossbeam-channel",
- "crossbeam-utils",
- "diff",
  "directories",
+ "dmg",
  "druid",
- "fern",
  "flate2",
+ "fs_extra",
  "fuzzy-matcher",
- "hashbrown",
+ "hashbrown 0.12.3",
  "im",
  "include_dir",
  "indexmap",
+ "interprocess",
  "itertools",
- "jsonrpc-lite",
  "lapce-core",
  "lapce-proxy",
  "lapce-rpc",
- "lazy_static",
- "libloading",
- "log",
+ "lapce-xi-rope",
+ "log 0.4.17",
  "lsp-types",
- "notify 5.0.0-pre.15",
- "parking_lot",
+ "notify",
+ "once_cell",
+ "parking_lot 0.11.2",
  "pulldown-cmark",
  "rayon",
  "regex",
  "reqwest",
- "serde 1.0.130",
+ "serde",
  "serde_json",
+ "sha2 0.10.6",
  "sled",
+ "smallvec",
  "structdesc",
- "strum 0.24.0",
- "strum_macros 0.24.0",
+ "strum",
+ "strum_macros",
+ "tar",
  "thiserror",
- "toml",
- "unicode-segmentation",
- "unicode-width",
+ "toml_edit",
+ "url",
  "uuid",
- "xi-rope",
- "xi-unicode",
+ "zip",
 ]
 
 [[package]]
 name = "lapce-proxy"
-version = "0.1.2"
+version = "0.2.6"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
- "base64",
+ "clap",
+ "cocoa",
  "crossbeam-channel",
  "directories",
+ "dyn-clone",
+ "flate2",
  "git2",
+ "globset",
  "grep-matcher",
  "grep-regex",
  "grep-searcher",
- "home",
- "hotwatch",
  "ignore",
+ "indexmap",
+ "interprocess",
  "jsonrpc-lite",
+ "lapce-core",
  "lapce-rpc",
+ "lapce-xi-rope",
+ "libc",
  "locale_config",
+ "log 0.4.17",
  "lsp-types",
  "mio 0.6.23",
- "notify 5.0.0-pre.15",
- "parking_lot",
+ "notify",
+ "objc",
+ "once_cell",
+ "parking_lot 0.11.2",
+ "psp-types",
  "regex",
  "reqwest",
- "serde 1.0.130",
+ "serde",
  "serde_json",
- "toml",
- "wasmer",
- "wasmer-wasi",
+ "strum",
+ "strum_macros",
+ "tar",
+ "toml_edit",
+ "trash",
+ "url",
+ "walkdir",
+ "wasi-common",
+ "wasi-experimental-http-wasmtime",
+ "wasmtime",
+ "wasmtime-wasi",
  "which",
- "xi-rope",
+ "zstd",
 ]
 
 [[package]]
 name = "lapce-rpc"
-version = "0.1.2"
+version = "0.2.6"
 dependencies = [
  "anyhow",
  "crossbeam-channel",
- "jsonrpc-lite",
+ "human-sort",
+ "indexmap",
+ "lapce-xi-rope",
+ "log 0.4.17",
  "lsp-types",
- "notify 5.0.0-pre.15",
- "parking_lot",
- "serde 1.0.130",
+ "parking_lot 0.11.2",
+ "serde",
  "serde_json",
- "xi-rope",
 ]
 
 [[package]]
 name = "lapce-ui"
-version = "0.1.2"
+version = "0.2.6"
 dependencies = [
  "Inflector",
  "alacritty_terminal",
  "anyhow",
- "base64",
- "bit-vec",
  "chrono",
- "config",
- "crossbeam-channel",
- "crossbeam-utils",
- "diff",
- "directories",
+ "clap",
  "druid",
  "fern",
- "flate2",
- "fuzzy-matcher",
- "hashbrown",
+ "hashbrown 0.12.3",
  "im",
  "image",
  "include_dir",
  "indexmap",
  "itertools",
- "jsonrpc-lite",
  "lapce-core",
  "lapce-data",
+ "lapce-proxy",
  "lapce-rpc",
- "lazy_static",
- "libloading",
- "log",
+ "lapce-xi-rope",
+ "log 0.4.17",
+ "log-panics",
  "lsp-types",
- "notify 5.0.0-pre.15",
- "parking_lot",
+ "once_cell",
+ "open",
  "rayon",
  "regex",
- "serde 1.0.130",
+ "serde",
  "serde_json",
- "sled",
- "structdesc",
- "strum 0.24.0",
- "strum_macros 0.24.0",
- "toml",
- "unicode-segmentation",
+ "smallvec",
+ "toml_edit",
  "unicode-width",
  "winres",
- "xi-rope",
- "xi-unicode",
+]
+
+[[package]]
+name = "lapce-xi-rope"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08ae23edb8cf91f01edd9a87c88623eae3977c8d647a31c57cb12f1a125ca10a"
+dependencies = [
+ "bytecount",
+ "memchr",
+ "regex",
+ "serde",
+ "unicode-segmentation",
 ]
 
 [[package]]
@@ -2379,34 +2826,21 @@ checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
 
 [[package]]
 name = "lebe"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7efd1d698db0759e6ef11a7cd44407407399a910c774dd804c64c032da7826ff"
-
-[[package]]
-name = "lexical-core"
-version = "0.7.6"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6607c62aa161d23d17a9072cc5da0be67cdfc89d3afb1e8d9c842bebc2525ffe"
-dependencies = [
- "arrayvec 0.5.2",
- "bitflags",
- "cfg-if 1.0.0",
- "ryu",
- "static_assertions",
-]
+checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
 
 [[package]]
 name = "libc"
-version = "0.2.121"
+version = "0.2.133"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efaa7b300f3b5fe8eb6bf21ce3895e1751d9665086af2d64b42f19701015ff4f"
+checksum = "c0f80d65747a3e43d1596c7c5492d95d5edddaabd45a7fcdb02b95f644164966"
 
 [[package]]
 name = "libgit2-sys"
-version = "0.13.4+1.4.2"
+version = "0.14.2+1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0fa6563431ede25f5cc7f6d803c6afbc1c5d3ad3d4925d12c882bf2b526f5d1"
+checksum = "7f3d95f6b51075fe9810a7ae22c7095f12b98005ab364d8544797a825ce946a4"
 dependencies = [
  "cc",
  "libc",
@@ -2418,9 +2852,9 @@ dependencies = [
 
 [[package]]
 name = "libloading"
-version = "0.7.0"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f84d96438c15fcd6c3f244c8fce01d1e2b9c6b5623e9c711dc9286d8fc92d6a"
+checksum = "efbc0f03f9a775e9f6aed295c6a1ba2253c5757a9e03d55c6caa46a681abcddd"
 dependencies = [
  "cfg-if 1.0.0",
  "winapi 0.3.9",
@@ -2428,9 +2862,9 @@ dependencies = [
 
 [[package]]
 name = "libssh2-sys"
-version = "0.2.21"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0186af0d8f171ae6b9c4c90ec51898bad5d08a2d5e470903a50d9ad8959cbee"
+checksum = "b094a36eb4b8b8c8a7b4b8ae43b2944502be3e59cd87687595cf6b0a71b3f4ca"
 dependencies = [
  "cc",
  "libc",
@@ -2442,9 +2876,9 @@ dependencies = [
 
 [[package]]
 name = "libz-sys"
-version = "1.1.3"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66"
+checksum = "9702761c3935f8cc2f101793272e202c72b99da8f4224a19ddcf1279a6450bbf"
 dependencies = [
  "cc",
  "libc",
@@ -2454,9 +2888,15 @@ dependencies = [
 
 [[package]]
 name = "linked-hash-map"
-version = "0.5.4"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.0.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4d2456c373231a208ad294c33dc5bff30051eafd954cd4caae83a712b12854d"
 
 [[package]]
 name = "locale_config"
@@ -2473,51 +2913,51 @@ dependencies = [
 
 [[package]]
 name = "lock_api"
-version = "0.4.5"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712a4d093c9976e24e7dbca41db895dabcbac38eb5f4045393d17a95bdfb1109"
+checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
 dependencies = [
+ "autocfg",
  "scopeguard",
 ]
 
 [[package]]
 name = "log"
-version = "0.4.14"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+checksum = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
 dependencies = [
- "cfg-if 1.0.0",
+ "log 0.4.17",
 ]
 
 [[package]]
-name = "loupe"
-version = "0.1.3"
+name = "log"
+version = "0.4.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b6a72dfa44fe15b5e76b94307eeb2ff995a8c5b283b55008940c02e0c5b634d"
+checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
 dependencies = [
- "indexmap",
- "loupe-derive",
- "rustversion",
+ "cfg-if 1.0.0",
+ "serde",
 ]
 
 [[package]]
-name = "loupe-derive"
-version = "0.1.3"
+name = "log-panics"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0fbfc88337168279f2e9ae06e157cfed4efd3316e14dc96ed074d4f2e6c5952"
+checksum = "68f9dd8546191c1850ecf67d22f5ff00a935b890d0e84713159a55495cc2ac5f"
 dependencies = [
- "quote",
- "syn",
+ "backtrace",
+ "log 0.4.17",
 ]
 
 [[package]]
 name = "lsp-types"
-version = "0.89.2"
+version = "0.93.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "852e0dedfd52cc32325598b2631e0eba31b7b708959676a9f837042f276b09a2"
+checksum = "a3bcfee315dde785ba887edb540b08765fd7df75a7d948844be6bf5712246734"
 dependencies = [
  "bitflags",
- "serde 1.0.130",
+ "serde",
  "serde_json",
  "serde_repr",
  "url",
@@ -2525,9 +2965,9 @@ dependencies = [
 
 [[package]]
 name = "lyon"
-version = "0.17.5"
+version = "0.17.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a146a460c58fb5361fc7faf8d7a68b274f11969ee1f6856875c162d679d0306"
+checksum = "cf0510ed5e3e2fb80f3db2061ef5ca92d87bfda1a624bb1eacf3bd50226e4cbb"
 dependencies = [
  "lyon_algorithms",
  "lyon_tessellation",
@@ -2535,9 +2975,9 @@ dependencies = [
 
 [[package]]
 name = "lyon_algorithms"
-version = "0.17.5"
+version = "0.17.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea1ebc5107076627bc9e402b09d11ba8ca68e06e3053b923bce9570ef70bf960"
+checksum = "8037f716541ba0d84d3de05c0069f8068baf73990d55980558b84d944c8a244a"
 dependencies = [
  "lyon_path",
  "sid",
@@ -2545,34 +2985,32 @@ dependencies = [
 
 [[package]]
 name = "lyon_geom"
-version = "0.17.5"
+version = "0.17.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe153a6ce93cb97c85ba47a007fd437079bbff5592b9c0f77195973b8b169d69"
+checksum = "71d89ccbdafd83d259403e22061be27bccc3254bba65cdc5303250c4227c8c8e"
 dependencies = [
  "arrayvec 0.5.2",
  "euclid",
- "num-traits 0.2.14",
+ "num-traits",
 ]
 
 [[package]]
 name = "lyon_path"
-version = "0.17.6"
+version = "0.17.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ef7433accd4515fc98f59bb3cdf565a9615f0c666f50bfcb96134bbd91ccc04"
+checksum = "5b0a59fdf767ca0d887aa61d1b48d4bbf6a124c1a45503593f7d38ab945bfbc0"
 dependencies = [
  "lyon_geom",
 ]
 
 [[package]]
 name = "lyon_tessellation"
-version = "0.17.9"
+version = "0.17.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56799e28a041fa98b0865a93d2e19f64de3c8f2708bfe96b8af5c7d491aef468"
+checksum = "7230e08dd0638048e46f387f255dbe7a7344a3e6705beab53242b5af25635760"
 dependencies = [
- "arrayvec 0.5.2",
  "float_next_after",
  "lyon_path",
- "sid",
 ]
 
 [[package]]
@@ -2599,44 +3037,50 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
 
+[[package]]
+name = "maybe-owned"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4facc753ae494aeb6e3c22f839b158aebd4f9270f55cd3c79906c45476c47ab4"
+
 [[package]]
 name = "memchr"
-version = "2.4.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
 [[package]]
-name = "memmap2"
-version = "0.2.3"
+name = "memfd"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "723e3ebdcdc5c023db1df315364573789f8857c11b631a2fdfad7c00f5c046b4"
+checksum = "480b5a5de855d11ff13195950bdc8b98b5e942ef47afc447f6615cdcc4e15d80"
 dependencies = [
- "libc",
+ "rustix",
 ]
 
 [[package]]
 name = "memmap2"
-version = "0.3.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b6c2ebff6180198788f5db08d7ce3bc1d0b617176678831a7510825973e357"
+checksum = "723e3ebdcdc5c023db1df315364573789f8857c11b631a2fdfad7c00f5c046b4"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "memmap2"
-version = "0.5.3"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "057a3db23999c867821a7a59feb06a578fcb03685e983dff90daf9e7d24ac08f"
+checksum = "95af15f345b17af2efc8ead6080fb8bc376f8cec1b35277b935637595fe77498"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "memoffset"
-version = "0.6.4"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
 dependencies = [
  "autocfg",
 ]
@@ -2648,20 +3092,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
 
 [[package]]
-name = "miniz_oxide"
-version = "0.4.4"
+name = "minimal-lexical"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
-dependencies = [
- "adler",
- "autocfg",
-]
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.5.1"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2b29bd4bc3f33391105ebee3589c19197c4271e3e5a9ec9bfe8127eeff8f082"
+checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
 dependencies = [
  "adler",
 ]
@@ -2678,7 +3118,7 @@ dependencies = [
  "iovec",
  "kernel32-sys",
  "libc",
- "log",
+ "log 0.4.17",
  "miow 0.2.2",
  "net2",
  "slab",
@@ -2687,16 +3127,14 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "0.8.2"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52da4364ffb0e4fe33a9841a98a3f3014fb964045ce4f7a45a398243c8d6b0c9"
+checksum = "57ee1c23c7c63b0c9250c339ffdc69255f110b298b901b9f6c82547b7b87caaf"
 dependencies = [
  "libc",
- "log",
- "miow 0.3.7",
- "ntapi",
+ "log 0.4.17",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "winapi 0.3.9",
+ "windows-sys",
 ]
 
 [[package]]
@@ -2707,7 +3145,7 @@ checksum = "6bc513025fe5005a3aa561b50fdb2cda5a150b84800ae02acd8aa9ed62ca1a6b"
 dependencies = [
  "mio 0.6.23",
  "miow 0.3.7",
- "parking_lot",
+ "parking_lot 0.11.2",
  "spsc-buffer",
  "winapi 0.3.9",
 ]
@@ -2719,7 +3157,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52403fe290012ce777c4626790c8951324a2b9e3316b3143779c72b029742f19"
 dependencies = [
  "lazycell",
- "log",
+ "log 0.4.17",
  "mio 0.6.23",
  "slab",
 ]
@@ -2756,12 +3194,6 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
-[[package]]
-name = "more-asserts"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
-
 [[package]]
 name = "nanorand"
 version = "0.7.0"
@@ -2779,7 +3211,7 @@ checksum = "fd7e2f3618557f980e0b17e8856252eee3c97fa12c54dff0ca290fb6266ca4a9"
 dependencies = [
  "lazy_static",
  "libc",
- "log",
+ "log 0.4.17",
  "openssl",
  "openssl-probe",
  "openssl-sys",
@@ -2802,12 +3234,11 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.22.3"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4916f159ed8e5de0082076562152a76b7a1f64a01fd9d1e0fea002c37624faf"
+checksum = "195cdbc1741b8134346d515b3a56a1c94b0912758009cfd53f99ea0f57b065fc"
 dependencies = [
  "bitflags",
- "cc",
  "cfg-if 1.0.0",
  "libc",
  "memoffset",
@@ -2815,107 +3246,59 @@ dependencies = [
 
 [[package]]
 name = "nom"
-version = "5.1.2"
+version = "7.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffb4262d26ed83a1c0a33a38fe2bb15797329c85770da05e6b828ddb782627af"
+checksum = "a8903e5a29a317527874d0402f867152a3d21c908bb0b933e416c65e301d4c36"
 dependencies = [
- "lexical-core",
  "memchr",
- "version_check",
-]
-
-[[package]]
-name = "notify"
-version = "4.0.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae03c8c853dba7bfd23e571ff0cff7bc9dceb40a4cd684cd1681824183f45257"
-dependencies = [
- "bitflags",
- "filetime",
- "fsevent",
- "fsevent-sys 2.0.1",
- "inotify 0.7.1",
- "libc",
- "mio 0.6.23",
- "mio-extras",
- "walkdir",
- "winapi 0.3.9",
+ "minimal-lexical",
 ]
 
 [[package]]
 name = "notify"
-version = "5.0.0-pre.15"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "553f9844ad0b0824605c20fb55a661679782680410abfb1a8144c2e7e437e7a7"
+checksum = "ed2c66da08abae1c024c01d635253e402341b4060a12e99b31c7594063bf490a"
 dependencies = [
  "bitflags",
  "crossbeam-channel",
  "filetime",
- "fsevent-sys 4.1.0",
- "inotify 0.9.6",
+ "fsevent-sys",
+ "inotify",
  "kqueue",
  "libc",
- "mio 0.8.2",
- "serde 1.0.130",
+ "mio 0.8.4",
+ "serde",
  "walkdir",
  "winapi 0.3.9",
 ]
 
-[[package]]
-name = "ntapi"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"
-dependencies = [
- "winapi 0.3.9",
-]
-
 [[package]]
 name = "num-integer"
-version = "0.1.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
-dependencies = [
- "autocfg",
- "num-traits 0.2.14",
-]
-
-[[package]]
-name = "num-iter"
-version = "0.1.43"
+version = "0.1.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
 dependencies = [
  "autocfg",
- "num-integer",
- "num-traits 0.2.14",
+ "num-traits",
 ]
 
 [[package]]
 name = "num-rational"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d41702bd167c2df5520b384281bc111a4b5efcf7fbc4c9c222c815b07e0a6a6a"
+checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0"
 dependencies = [
  "autocfg",
  "num-integer",
- "num-traits 0.2.14",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.1.43"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31"
-dependencies = [
- "num-traits 0.2.14",
+ "num-traits",
 ]
 
 [[package]]
 name = "num-traits"
-version = "0.2.14"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
 dependencies = [
  "autocfg",
 ]
@@ -2926,7 +3309,7 @@ version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.1.19",
  "libc",
 ]
 
@@ -2970,29 +3353,21 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.26.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39f37e50073ccad23b6d09bcb5b263f4e76d3bb6038e4a3c08e52162ffa8abc2"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "object"
-version = "0.27.1"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67ac1d3f9a1d3616fd9a60c8d74296f22406a238b6a72f5cc1e6f314df4ffbf9"
+checksum = "21158b2c33aa6d4561f1c0a6ea283ca92bc54802a93b263e910746d679a7eb53"
 dependencies = [
  "crc32fast",
+ "hashbrown 0.12.3",
  "indexmap",
  "memchr",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.10.0"
+version = "1.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9"
+checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
 
 [[package]]
 name = "opaque-debug"
@@ -3000,11 +3375,21 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
 
+[[package]]
+name = "open"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4a3100141f1733ea40b53381b0ae3117330735ef22309a190ac57b9576ea716"
+dependencies = [
+ "pathdiff",
+ "windows-sys",
+]
+
 [[package]]
 name = "openssl"
-version = "0.10.40"
+version = "0.10.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb81a6430ac911acb25fe5ac8f1d2af1b4ea8a4fdfda0f1ee4292af2e2d8eb0e"
+checksum = "12fc0523e3bd51a692c8850d075d74dc062ccf251c0110668cbd921917118a13"
 dependencies = [
  "bitflags",
  "cfg-if 1.0.0",
@@ -3028,24 +3413,24 @@ dependencies = [
 
 [[package]]
 name = "openssl-probe"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a"
+checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
 [[package]]
 name = "openssl-src"
-version = "111.16.0+1.1.1l"
+version = "111.22.0+1.1.1q"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ab2173f69416cf3ec12debb5823d244127d23a9b127d5a5189aa97c5fa2859f"
+checksum = "8f31f0d509d1c1ae9cada2f9539ff8f37933831fd5098879e482aa687d659853"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.74"
+version = "0.9.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "835363342df5fba8354c5b453325b110ffd54044e588c539cf2f20a8014e4cb1"
+checksum = "5230151e44c0f05157effb743e8d517472843121cf9243e8b81393edb5acd9ce"
 dependencies = [
  "autocfg",
  "cc",
@@ -3056,27 +3441,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "ouroboros"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbeff60e3e37407a80ead3e9458145b456e978c4068cddbfea6afb48572962ca"
-dependencies = [
- "ouroboros_macro",
- "stable_deref_trait",
-]
-
-[[package]]
-name = "ouroboros_macro"
-version = "0.9.5"
+name = "os_str_bytes"
+version = "6.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03f2cb802b5bdfdf52f1ffa0b54ce105e4d346e91990dd571f86c91321ad49e2"
-dependencies = [
- "Inflector",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn",
-]
+checksum = "9ff7415e9ae3fff1225851df9e0d9e4e5479f947619774677a63572e55e80eff"
 
 [[package]]
 name = "pango"
@@ -3103,6 +3471,12 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "parking"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72"
+
 [[package]]
 name = "parking_lot"
 version = "0.11.2"
@@ -3111,7 +3485,17 @@ checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
 dependencies = [
  "instant",
  "lock_api",
- "parking_lot_core",
+ "parking_lot_core 0.8.5",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+dependencies = [
+ "lock_api",
+ "parking_lot_core 0.9.3",
 ]
 
 [[package]]
@@ -3131,22 +3515,47 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "parking_lot_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09a279cbf25cb0757810394fbc1e359949b59e348145c643a939a525692e6929"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-sys",
+]
+
 [[package]]
 name = "parley"
 version = "0.1.0"
-source = "git+https://github.com/lapce/parley#6baaa02bbe3ab717822656ad98a95f8121febd53"
+source = "git+https://github.com/lapce/parley#c37477b889ff53b9a3033e2180becddf90b9bb17"
 dependencies = [
  "fount",
  "swash",
 ]
 
+[[package]]
+name = "paste"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1"
+
+[[package]]
+name = "pathdiff"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
+
 [[package]]
 name = "pathfinder_geometry"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b7b7e7b4ea703700ce73ebf128e1450eb69c3a8329199ffbfb9b2a0418e5ad3"
 dependencies = [
- "log",
+ "log 0.4.17",
  "pathfinder_simd",
 ]
 
@@ -3156,21 +3565,22 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39fe46acc5503595e5949c17b818714d26fdf9b4920eacf3b2947f0199f4a6ff"
 dependencies = [
- "rustc_version 0.3.3",
+ "rustc_version",
 ]
 
 [[package]]
 name = "percent-encoding"
-version = "2.1.0"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
+checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
 
 [[package]]
 name = "pest"
-version = "2.1.3"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"
+checksum = "cb779fcf4bb850fbbb0edc96ff6cf34fd90c4b1a112ce042653280d9a7364048"
 dependencies = [
+ "thiserror",
  "ucd-trie",
 ]
 
@@ -3203,21 +3613,22 @@ dependencies = [
 [[package]]
 name = "piet-wgpu"
 version = "0.1.0"
-source = "git+https://github.com/lapce/piet-wgpu?branch=shell_opengl#6e268b3b09a5480c17a241d964c9ef090fd02d98"
+source = "git+https://github.com/lapce/piet-wgpu?branch=shell_opengl#2024fe8f241dc95ad38f4024d39898bada8fe802"
 dependencies = [
  "bytemuck",
  "glam",
  "glow",
- "hashbrown",
+ "hashbrown 0.11.2",
+ "image",
  "include_dir",
  "linked-hash-map",
- "log",
+ "log 0.4.17",
  "lyon",
  "parley",
  "pathfinder_geometry",
  "piet",
  "resvg",
- "sha2",
+ "sha2 0.9.9",
  "swash",
  "tiny-skia",
  "unicode-width",
@@ -3226,18 +3637,18 @@ dependencies = [
 
 [[package]]
 name = "pin-project"
-version = "1.0.10"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58ad3879ad3baf4e44784bc6a718a8698867bb991f8ce24d1bcbe2cfb4c3a75e"
+checksum = "ad29a609b6bcd67fee905812e544992d216af9d755757c05ed2d0e15a74c6ecc"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.0.10"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "744b6f092ba29c3650faf274db506afd39944f48420f6c86b17cfe0ee1cb36bb"
+checksum = "069bdb1e05adc7a8990dce9cc75370895fbe4e3d58b9b73bf1aee56359344a55"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3246,9 +3657,9 @@ dependencies = [
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.7"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d31d11c69a6b52a174b42bdc0c30e5e11670f90788b2c471c31c1d17d449443"
+checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
 
 [[package]]
 name = "pin-utils"
@@ -3258,28 +3669,47 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "pkg-config"
-version = "0.3.19"
+version = "0.3.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1df8c4ec4b0627e53bdf214615ad287367e482558cf84b109250b37464dc03ae"
+
+[[package]]
+name = "plist"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c"
+checksum = "c61ac2afed2856590ae79d6f358a24b85ece246d2aa134741a66d589519b7503"
+dependencies = [
+ "base64 0.8.0",
+ "byteorder",
+ "chrono",
+ "xml-rs 0.7.0",
+]
 
 [[package]]
 name = "png"
-version = "0.17.5"
+version = "0.17.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc38c0ad57efb786dd57b9864e5b18bae478c00c824dc55a38bbc9da95dde3ba"
+checksum = "8f0e7f4c94ec26ff209cee506314212639d6c91b80afb82984819fafce9df01c"
 dependencies = [
  "bitflags",
  "crc32fast",
- "deflate",
- "miniz_oxide 0.5.1",
+ "flate2",
+ "miniz_oxide",
 ]
 
+[[package]]
+name = "ppv-lite86"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+
 [[package]]
 name = "proc-macro-crate"
-version = "1.0.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41fdbd1df62156fbc5945f4762632564d7d038153091c3fcf1067f6aef7cff92"
+checksum = "eda0fc3b0fb7c975631757e14d9049da17374063edb6ebbcbc54d880d4fe94e9"
 dependencies = [
+ "once_cell",
  "thiserror",
  "toml",
 ]
@@ -3316,38 +3746,37 @@ checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.36"
+version = "1.0.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+checksum = "7bd7356a8122b6c4a24a82b278680c73357984ca2fc79a0f9fa6dea7dced7c58"
 dependencies = [
- "unicode-xid",
+ "unicode-ident",
 ]
 
 [[package]]
-name = "ptr_meta"
-version = "0.1.4"
+name = "psm"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
+checksum = "5787f7cda34e3033a72192c018bc5883100330f362ef279a8cbccfce8bb4e874"
 dependencies = [
- "ptr_meta_derive",
+ "cc",
 ]
 
 [[package]]
-name = "ptr_meta_derive"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
+name = "psp-types"
+version = "0.1.0"
+source = "git+https://github.com/lapce/psp-types#b55d2c5c1f9aae89a4f369db5151fe1756d34c08"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "lsp-types",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
 name = "pulldown-cmark"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34f197a544b0c9ab3ae46c359a7ec9cbbb5c7bf97054266fecb7ead794a181d6"
+checksum = "2d9cc634bc78768157b5cbfe988ffcd1dcba95cd2b2f03a88316c08c6d00ed63"
 dependencies = [
  "bitflags",
  "getopts",
@@ -3357,33 +3786,57 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.15"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
 [[package]]
 name = "rand_core"
-version = "0.5.1"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
 
 [[package]]
 name = "rand_xoshiro"
-version = "0.4.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9fcdd2e881d02f1d9390ae47ad8e5696a9e4be7b547a1da2afbc61973217004"
+checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
 dependencies = [
  "rand_core",
 ]
 
 [[package]]
 name = "rayon"
-version = "1.5.1"
+version = "1.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
+checksum = "bd99e5772ead8baa5215278c9b15bf92087709e9c1b2d1f97cdb5a183c933a7d"
 dependencies = [
  "autocfg",
  "crossbeam-deque",
@@ -3393,14 +3846,13 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.9.1"
+version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
+checksum = "258bcdb5ac6dad48491bb2992db6b7cf74878b0384908af124823d118c99683f"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-deque",
  "crossbeam-utils",
- "lazy_static",
  "num_cpus",
 ]
 
@@ -3418,39 +3870,41 @@ checksum = "9ae028b272a6e99d9f8260ceefa3caa09300a8d6c8d2b2001316474bc52122e9"
 
 [[package]]
 name = "redox_syscall"
-version = "0.2.10"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
 dependencies = [
  "bitflags",
 ]
 
 [[package]]
 name = "redox_users"
-version = "0.4.0"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"
+checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
 dependencies = [
  "getrandom",
  "redox_syscall",
+ "thiserror",
 ]
 
 [[package]]
-name = "regalloc"
-version = "0.0.31"
+name = "regalloc2"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "571f7f397d61c4755285cd37853fe8e03271c243424a907415909379659381c5"
+checksum = "d43a209257d978ef079f3d446331d0f1794f5e0fc19b306a199983857833a779"
 dependencies = [
- "log",
- "rustc-hash",
+ "fxhash",
+ "log 0.4.17",
+ "slice-group-by",
  "smallvec",
 ]
 
 [[package]]
 name = "regex"
-version = "1.5.6"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d83f127d94bdbcda4c8cc2e50f6f84f4b611f69c902699ca385a39c3a75f9ff1"
+checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -3468,21 +3922,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49b3de9ec5dc0a3417da371aab17d729997c15010e7fd24ff707773a33bddb64"
-
-[[package]]
-name = "region"
-version = "3.0.0"
+version = "0.6.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76e189c2369884dce920945e2ddf79b3dff49e071a167dd1817fa9c4c00d512e"
-dependencies = [
- "bitflags",
- "libc",
- "mach",
- "winapi 0.3.9",
-]
+checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"
 
 [[package]]
 name = "remove_dir_all"
@@ -3493,22 +3935,13 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
-[[package]]
-name = "rend"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79af64b4b6362ffba04eef3a4e10829718a4896dac19daa741851c86781edf95"
-dependencies = [
- "bytecheck",
-]
-
 [[package]]
 name = "reqwest"
-version = "0.11.10"
+version = "0.11.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46a1f7aa4f35e5e8b4160449f51afc758f0ce6454315a9fa7d0d113e958c41eb"
+checksum = "431949c384f4e2ae07605ccaa56d1d9d2ecdb5cadd4f9577ccfab29f2e5149fc"
 dependencies = [
- "base64",
+ "base64 0.13.0",
  "bytes",
  "encoding_rs",
  "futures-core",
@@ -3520,18 +3953,19 @@ dependencies = [
  "hyper-tls",
  "ipnet",
  "js-sys",
- "lazy_static",
- "log",
+ "log 0.4.17",
  "mime",
  "native-tls",
+ "once_cell",
  "percent-encoding",
  "pin-project-lite",
- "serde 1.0.130",
+ "serde",
  "serde_json",
  "serde_urlencoded",
  "tokio",
  "tokio-native-tls",
  "tokio-socks",
+ "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
@@ -3547,50 +3981,25 @@ checksum = "2e702d1e8e00a3a0717b96244cba840f34f542d8f23097c8903266c4e2975658"
 dependencies = [
  "gif",
  "jpeg-decoder",
- "log",
+ "log 0.4.17",
  "pico-args",
  "png",
  "rgb",
  "svgfilters",
- "svgtypes 0.8.0",
+ "svgtypes 0.8.1",
  "tiny-skia",
  "usvg 0.22.0",
 ]
 
 [[package]]
 name = "rgb"
-version = "0.8.32"
+version = "0.8.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e74fdc210d8f24a7dbfedc13b04ba5764f5232754ccebfdf5fff1bad791ccbc6"
+checksum = "3603b7d71ca82644f79b5a06d1220e9a58ede60bd32255f698cb1af8838b8db3"
 dependencies = [
  "bytemuck",
 ]
 
-[[package]]
-name = "rkyv"
-version = "0.7.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "631f7d2a2854abb66724f492ce5256e79685a673dc210ac022194cedd5c914d3"
-dependencies = [
- "bytecheck",
- "hashbrown",
- "ptr_meta",
- "rend",
- "rkyv_derive",
- "seahash",
-]
-
-[[package]]
-name = "rkyv_derive"
-version = "0.7.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c067e650861a749720952aed722fb344449bc95de33e6456d426f5c7d44f71c0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "roxmltree"
 version = "0.14.1"
@@ -3600,12 +4009,6 @@ dependencies = [
  "xmlparser",
 ]
 
-[[package]]
-name = "rust-ini"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e52c148ef37f8c375d49d5a73aa70713125b7f19095948a923f80afdeb22ec2"
-
 [[package]]
 name = "rustc-demangle"
 version = "0.1.21"
@@ -3618,29 +4021,30 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
-[[package]]
-name = "rustc_version"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
-dependencies = [
- "semver 0.9.0",
-]
-
 [[package]]
 name = "rustc_version"
 version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee"
 dependencies = [
- "semver 0.11.0",
+ "semver",
 ]
 
 [[package]]
-name = "rustversion"
-version = "1.0.6"
+name = "rustix"
+version = "0.35.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2cc38e8fa666e2de3c4aba7edeb5ffc5246c1c2ed0e3d17e560aeeba736b23f"
+checksum = "af895b90e5c071badc3136fc10ff0bcfc98747eadbaf43ed8f214e07ba8f8477"
+dependencies = [
+ "bitflags",
+ "errno",
+ "io-lifetimes",
+ "itoa",
+ "libc",
+ "linux-raw-sys",
+ "once_cell",
+ "windows-sys",
+]
 
 [[package]]
 name = "rustybuzz"
@@ -3660,14 +4064,14 @@ dependencies = [
 
 [[package]]
 name = "rustybuzz"
-version = "0.5.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25ff94f20221325d000e552781713e53b0d85c1d9551b6f420d12daf5a08eace"
+checksum = "a617c811f5c9a7060fe511d35d13bf5b9f0463ce36d63ce666d05779df2b4eba"
 dependencies = [
  "bitflags",
  "bytemuck",
  "smallvec",
- "ttf-parser 0.15.0",
+ "ttf-parser 0.15.2",
  "unicode-bidi-mirroring",
  "unicode-ccc",
  "unicode-general-category 0.4.0",
@@ -3676,9 +4080,9 @@ dependencies = [
 
 [[package]]
 name = "ryu"
-version = "1.0.5"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
+checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09"
 
 [[package]]
 name = "safe_arch"
@@ -3689,6 +4093,12 @@ dependencies = [
  "bytemuck",
 ]
 
+[[package]]
+name = "safemem"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e27a8b19b835f7aea908818e871f5cc3a5a186550c30773be987e155e8163d8f"
+
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -3720,17 +4130,11 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
-[[package]]
-name = "seahash"
-version = "4.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
-
 [[package]]
 name = "security-framework"
-version = "2.4.2"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "525bc1abfda2e1998d152c45cf13e696f76d0a4972310b22fac1658b05df7c87"
+checksum = "2bc1bb97804af6631813c55739f771071e0f2ed33ee20b68c86ec505d906356c"
 dependencies = [
  "bitflags",
  "core-foundation",
@@ -3741,22 +4145,19 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.4.2"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9dd14d83160b528b7bfd66439110573efcfbe281b17fc2ca9f39f550d619c7e"
+checksum = "0160a13a177a45bfb43ce71c01580998474f556ad854dcbca936dd2841a5c556"
 dependencies = [
  "core-foundation-sys",
  "libc",
 ]
 
 [[package]]
-name = "semver"
-version = "0.9.0"
+name = "self_cell"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-dependencies = [
- "semver-parser 0.7.0",
-]
+checksum = "1ef965a420fe14fdac7dd018862966a4c14094f900e1650bbc71ddd7d580c8af"
 
 [[package]]
 name = "semver"
@@ -3764,15 +4165,9 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
 dependencies = [
- "semver-parser 0.10.2",
+ "semver-parser",
 ]
 
-[[package]]
-name = "semver-parser"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
-
 [[package]]
 name = "semver-parser"
 version = "0.10.2"
@@ -3784,45 +4179,18 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "0.8.23"
+version = "1.0.145"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dad3f759919b92c3068c696c15c3d17238234498bbdcc80f2c469606f948ac8"
-
-[[package]]
-name = "serde"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
+checksum = "728eb6351430bccb993660dfffc5a72f91ccc1295abaa8ce19b27ebe4f75568b"
 dependencies = [
  "serde_derive",
 ]
 
-[[package]]
-name = "serde-hjson"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a3a4e0ea8a88553209f6cc6cfe8724ecad22e1acf372793c27d995290fe74f8"
-dependencies = [
- "lazy_static",
- "num-traits 0.1.43",
- "regex",
- "serde 0.8.23",
-]
-
-[[package]]
-name = "serde_bytes"
-version = "0.11.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16ae07dd2f88a366f15bd0632ba725227018c69a1c8550a927324f8eb8368bb9"
-dependencies = [
- "serde 1.0.130",
-]
-
 [[package]]
 name = "serde_derive"
-version = "1.0.130"
+version = "1.0.145"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"
+checksum = "81fa1584d3d1bcacd84c277a0dfe21f5b0f6accf4a23d04d4c6d61f1af522b4c"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3831,20 +4199,20 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.67"
+version = "1.0.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7f9e390c27c3c0ce8bc5d725f6e4d30a29d26659494aa4b17535f7522c5c950"
+checksum = "6ce777b7b150d76b9cf60d28b55f5847135a003f7d7350c6be7a773508ce7d45"
 dependencies = [
- "itoa 0.4.8",
+ "itoa",
  "ryu",
- "serde 1.0.130",
+ "serde",
 ]
 
 [[package]]
 name = "serde_repr"
-version = "0.1.7"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98d0516900518c29efa217c298fa1f4e6c6ffc85ae29fd7f4ee48f176e1a9ed5"
+checksum = "1fe39d9fbb0ebf5eb2c7cb7e2a47e4f462fad1379f1166b8ae49ad9eae89a7ca"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3858,65 +4226,79 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
 dependencies = [
  "form_urlencoded",
- "itoa 1.0.2",
+ "itoa",
  "ryu",
- "serde 1.0.130",
+ "serde",
 ]
 
 [[package]]
 name = "serde_yaml"
-version = "0.8.21"
+version = "0.8.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8c608a35705a5d3cdc9fbe403147647ff34b921f8e833e49306df898f9b20af"
+checksum = "578a7433b776b56a35785ed5ce9a7e777ac0598aac5a6dd1b4b18a307c7fc71b"
 dependencies = [
- "dtoa",
  "indexmap",
- "serde 1.0.130",
+ "ryu",
+ "serde",
  "yaml-rust",
 ]
 
 [[package]]
-name = "sha1"
-version = "0.6.0"
+name = "sha2"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2579985fda508104f7587689507983eadd6a6e84dd35d6d115361f530916fa0d"
+checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800"
+dependencies = [
+ "block-buffer 0.9.0",
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "digest 0.9.0",
+ "opaque-debug",
+]
 
 [[package]]
 name = "sha2"
-version = "0.9.8"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b69f9a4c9740d74c5baa3fd2e547f9525fa8088a8a958e0ca2409a514e33f5fa"
+checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
 dependencies = [
- "block-buffer",
  "cfg-if 1.0.0",
  "cpufeatures",
- "digest",
- "opaque-debug",
+ "digest 0.10.5",
 ]
 
 [[package]]
 name = "sharded-slab"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "740223c51853f3145fe7c90360d2d4232f2b62e3449489c207eccde818979982"
+checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
 dependencies = [
  "lazy_static",
 ]
 
+[[package]]
+name = "shellexpand"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ccc8076840c4da029af4f87e4e8daeb0fca6b87bbb02e10cb60b791450e11e4"
+dependencies = [
+ "dirs",
+]
+
 [[package]]
 name = "sid"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd5ac56c121948b4879bba9e519852c211bcdd8f014efff766441deff0b91bdb"
 dependencies = [
- "num-traits 0.2.14",
+ "num-traits",
 ]
 
 [[package]]
 name = "signal-hook"
-version = "0.3.13"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "647c97df271007dcea485bb74ffdb57f2e683f1306c854f468a0c244badabf2d"
+checksum = "a253b5e89e2698464fc26b545c9edceb338e18a89effeeecfea192c3025be29d"
 dependencies = [
  "libc",
  "signal-hook-registry",
@@ -3924,9 +4306,9 @@ dependencies = [
 
 [[package]]
 name = "signal-hook-mio"
-version = "0.2.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29fd5867f1c4f2c5be079aee7a2adf1152ebb04a4bc4d341f504b7dece607ed4"
+checksum = "29ad2e15f37ec9a6cc544097b78a1ec90001e9f71b81338ca39f430adaca99af"
 dependencies = [
  "libc",
  "mio 0.6.23",
@@ -3949,7 +4331,7 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a11be7c62927d9427e9f40f3444d5499d868648e2edbc4e2116de69e7ec0e89d"
 dependencies = [
- "log",
+ "log 0.4.17",
 ]
 
 [[package]]
@@ -3976,9 +4358,12 @@ dependencies = [
 
 [[package]]
 name = "slab"
-version = "0.4.4"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c307a32c1c5c437f38c7fd45d753050587732ba8628319fbdf12a7e289ccc590"
+checksum = "4614a76b2a8be0058caa9dbbaf66d988527d86d003c11a94fbd335d7661edcef"
+dependencies = [
+ "autocfg",
+]
 
 [[package]]
 name = "sled"
@@ -3992,10 +4377,16 @@ dependencies = [
  "fs2",
  "fxhash",
  "libc",
- "log",
- "parking_lot",
+ "log 0.4.17",
+ "parking_lot 0.11.2",
 ]
 
+[[package]]
+name = "slice-group-by"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03b634d87b960ab1a38c4fe143b508576f075e7c978bfad18217645ebfdfa2ec"
+
 [[package]]
 name = "slotmap"
 version = "1.0.6"
@@ -4007,15 +4398,15 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.8.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
+checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
 
 [[package]]
 name = "socket2"
-version = "0.4.4"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66d72b759436ae32898a2af0a14218dbf55efde3feeb170eb623637db85ee1e0"
+checksum = "02e2d2db9033d13a1567121ddd7a095ee144db4e1ca1b1bda3419bc0da294ebd"
 dependencies = [
  "libc",
  "winapi 0.3.9",
@@ -4023,9 +4414,18 @@ dependencies = [
 
 [[package]]
 name = "spin"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c530c2b0d0bf8b69304b39fe2001993e267461948b890cd037d8ad4293fa1a0d"
+checksum = "7f6002a767bff9e83f8eeecf883ecb8011875a21ae8da43bffb817a57e78cc09"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "spinning"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d4f0e86297cad2658d92a707320d87bf4e6ae1050287f51d19b67ef3f153a7b"
 dependencies = [
  "lock_api",
 ]
@@ -4042,70 +4442,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
-[[package]]
-name = "standback"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e113fb6f3de07a243d434a56ec6f186dfd51cb08448239fe7bcae73f87ff28ff"
-dependencies = [
- "version_check",
-]
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "stdweb"
-version = "0.4.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d022496b16281348b52d0e30ae99e01a73d737b2f45d38fed4edf79f9325a1d5"
-dependencies = [
- "discard",
- "rustc_version 0.2.3",
- "stdweb-derive",
- "stdweb-internal-macros",
- "stdweb-internal-runtime",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "stdweb-derive"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c87a60a40fccc84bef0652345bbbbbe20a605bf5d0ce81719fc476f5c03b50ef"
-dependencies = [
- "proc-macro2",
- "quote",
- "serde 1.0.130",
- "serde_derive",
- "syn",
-]
-
-[[package]]
-name = "stdweb-internal-macros"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58fa5ff6ad0d98d1ffa8cb115892b6e69d67799f6763e162a1c9db421dc22e11"
-dependencies = [
- "base-x",
- "proc-macro2",
- "quote",
- "serde 1.0.130",
- "serde_derive",
- "serde_json",
- "sha1",
- "syn",
-]
-
-[[package]]
-name = "stdweb-internal-runtime"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "213701ba3370744dcd1a12960caa4843b3d68b4d1c0a5d575e0d65b2ee9d16c0"
-
 [[package]]
 name = "strsim"
 version = "0.10.0"
@@ -4129,12 +4465,6 @@ version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aaf86bbcfd1fa9670b7a129f64fc0c9fcbbfe4f1bc4210e9e98fe71ffc12cde2"
 
-[[package]]
-name = "strum"
-version = "0.24.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e96acfc1b70604b8b2f1ffa4c57e59176c7dbb05d556c71ecd2f5498a1dee7f8"
-
 [[package]]
 name = "strum_macros"
 version = "0.21.1"
@@ -4148,23 +4478,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "strum_macros"
-version = "0.24.0"
+name = "svgfilters"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6878079b17446e4d3eba6192bb0a2950d5b14f0ed8424b852310e5a94345d0ef"
-dependencies = [
- "heck 0.4.0",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn",
-]
-
-[[package]]
-name = "svgfilters"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "639abcebc15fdc2df179f37d6f5463d660c1c79cd552c12343a4600827a04bce"
+checksum = "639abcebc15fdc2df179f37d6f5463d660c1c79cd552c12343a4600827a04bce"
 dependencies = [
  "float-cmp 0.9.0",
  "rgb",
@@ -4182,9 +4499,9 @@ dependencies = [
 
 [[package]]
 name = "svgtypes"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dabb3eb59a457c56d5282ab4545609e2cc382b41f6af239bb8d59a7267ef94b3"
+checksum = "cc802f68b144cdf4d8ff21301f9a7863e837c627fde46537e29c05e8a18c85c1"
 dependencies = [
  "siphasher 0.3.10",
 ]
@@ -4200,13 +4517,13 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "1.0.86"
+version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
+checksum = "e90cde112c4b9690b8cbe810cba9ddd8bc1d7472e2cae317b69e9438c1cba7d2"
 dependencies = [
  "proc-macro2",
  "quote",
- "unicode-xid",
+ "unicode-ident",
 ]
 
 [[package]]
@@ -4220,18 +4537,45 @@ dependencies = [
  "heck 0.3.3",
  "itertools",
  "pkg-config",
- "strum 0.21.0",
- "strum_macros 0.21.1",
+ "strum",
+ "strum_macros",
  "thiserror",
  "toml",
  "version-compare",
 ]
 
+[[package]]
+name = "system-interface"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa85f9e64bd72b222ced152d2694fd306c0ebe43670cb9d187701874b7b89008"
+dependencies = [
+ "atty",
+ "bitflags",
+ "cap-fs-ext",
+ "cap-std",
+ "io-lifetimes",
+ "rustix",
+ "windows-sys",
+ "winx",
+]
+
+[[package]]
+name = "tar"
+version = "0.4.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b55807c0344e1e6c04d7c965f5289c39a8d94ae23ed5c0b57aabac549f871c6"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
 [[package]]
 name = "target-lexicon"
-version = "0.12.2"
+version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9bffcddbc2458fa3e6058414599e3c838a022abae82e5c67b4f7f80298d5bff"
+checksum = "c02424087780c9b71cc96799eaeddff35af2bc513278cda5c99fc1f5d026d3c1"
 
 [[package]]
 name = "tempfile"
@@ -4247,20 +4591,35 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "termcolor"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7b3e525a49ec206798b40326a44121291b530c963cfb01018f63e135bac543d"
+
 [[package]]
 name = "thiserror"
-version = "1.0.28"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "283d5230e63df9608ac7d9691adc1dfb6e701225436eb64d0b9a7f0a5a04f6ec"
+checksum = "0a99cb8c4b9a8ef0e7907cd3b617cc8dc04d571c4e73c8ae403d80ac160bb122"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.28"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa3884228611f5cd3608e2d409bf7dce832e4eb3135e3f11addbd7e41bd68e71"
+checksum = "3a891860d3c8d66fec8e73ddb3765f90082374dbaaa833407b904a94f1a7eb43"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4280,9 +4639,9 @@ dependencies = [
 
 [[package]]
 name = "thread_local"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8018d24e04c95ac8790716a5987d0fec4f8b27249ffa0f7d33f1369bdfb88cbd"
+checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
 dependencies = [
  "once_cell",
 ]
@@ -4298,9 +4657,9 @@ dependencies = [
 
 [[package]]
 name = "tiff"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cfada0986f446a770eca461e8c6566cb879682f7d687c8348aa0c857bd52286"
+checksum = "7259662e32d1e219321eb309d5f9d898b779769d81b76e762c07c8e5d38fcb65"
 dependencies = [
  "flate2",
  "jpeg-decoder",
@@ -4320,57 +4679,19 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.2.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4752a97f8eebd6854ff91f1c1824cd6160626ac4bd44287f7f4ea2035a02a242"
-dependencies = [
- "const_fn",
- "libc",
- "standback",
- "stdweb",
- "time-macros",
- "version_check",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "time"
-version = "0.3.9"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2702e08a7a860f005826c6815dcac101b19b5eb330c27fe4a5928fec1d20ddd"
+checksum = "3c3f9a28b618c3a6b9251b6908e9c99e04b9e5c02e6581ccbb67d59c34ef7f9b"
 dependencies = [
  "libc",
  "num_threads",
 ]
 
-[[package]]
-name = "time-macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "957e9c6e26f12cb6d0dd7fc776bb67a706312e7299aed74c8dd5b17ebb27e2f1"
-dependencies = [
- "proc-macro-hack",
- "time-macros-impl",
-]
-
-[[package]]
-name = "time-macros-impl"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd3c141a1b43194f3f56a1411225df8646c55781d5f26db825b3d98507eb482f"
-dependencies = [
- "proc-macro-hack",
- "proc-macro2",
- "quote",
- "standback",
- "syn",
-]
-
 [[package]]
 name = "tiny-skia"
-version = "0.6.3"
+version = "0.6.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bcfd4339bdd4545eabed74b208f2f1555f2e6540fb58135c01f46c0940aa138"
+checksum = "d049bfef0eaa2521e75d9ffb5ce86ad54480932ae19b85f78bec6f52c4d30d78"
 dependencies = [
  "arrayref",
  "arrayvec 0.5.2",
@@ -4388,9 +4709,9 @@ checksum = "29738eedb4388d9ea620eeab9384884fc3f06f586a2eddb56bedc5885126c7c1"
 
 [[package]]
 name = "tinyvec"
-version = "1.3.1"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "848a1e1181b9f6753b5e96a092749e29b11d19ede67dfbbd6c7dc7e0f49b5338"
+checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -4403,21 +4724,36 @@ checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
 
 [[package]]
 name = "tokio"
-version = "1.19.2"
+version = "1.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c51a52ed6686dd62c320f9b89299e9dfb46f730c7a48e635c19f21d116cb1439"
+checksum = "0020c875007ad96677dcc890298f4b942882c5d4eb7cc8f439fc3bf813dc9c95"
 dependencies = [
+ "autocfg",
  "bytes",
  "libc",
  "memchr",
- "mio 0.8.2",
+ "mio 0.8.4",
  "num_cpus",
  "once_cell",
+ "parking_lot 0.12.1",
  "pin-project-lite",
+ "signal-hook-registry",
  "socket2",
+ "tokio-macros",
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "tokio-macros"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9724f9a975fb987ef7a3cd9be0350edcbe130698af5b8f7a631e23d42d052484"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "tokio-native-tls"
 version = "0.3.0"
@@ -4442,9 +4778,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc463cd8deddc3770d20f9852143d50bf6094e640b485cb2e189a2099085ff45"
+checksum = "0bb2e075f03b3d66d8d8785356224ba688d2906a371015e225beeb65ca92c740"
 dependencies = [
  "bytes",
  "futures-core",
@@ -4456,28 +4792,39 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.5.8"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
+checksum = "5376256e44f2443f8896ac012507c19a012df0fe8758b55246ae51a2279db51f"
 dependencies = [
+ "combine",
  "indexmap",
- "serde 1.0.130",
+ "itertools",
+ "serde",
 ]
 
 [[package]]
 name = "tower-service"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"
+checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
 
 [[package]]
 name = "tracing"
-version = "0.1.26"
+version = "0.1.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09adeb8c97449311ccd28a427f96fb563e7fd31aabf994189879d9da2394b89d"
+checksum = "2fce9567bd60a67d08a16488756721ba392f24f29006402881e43b19aac64307"
 dependencies = [
  "cfg-if 1.0.0",
- "log",
+ "log 0.4.17",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",
@@ -4485,9 +4832,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.15"
+version = "0.1.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c42e6fa53307c8a17e4ccd4dc81cf5ec38db9209f59b222210375b54ee40d1e2"
+checksum = "11c75893af559bc8e10716548bdef5cb2b983f8e637db9d0e15126b61b484ee2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4496,63 +4843,104 @@ dependencies = [
 
 [[package]]
 name = "tracing-core"
-version = "0.1.26"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f54c8ca710e81886d498c2fd3331b56c93aa248d49de2222ad2742247c60072f"
+checksum = "5aeea4303076558a00714b823f9ad67d58a3bbda1df83d8827d21193156e22f7"
 dependencies = [
- "lazy_static",
- "valuable",
+ "once_cell",
 ]
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.2.20"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9cbe87a2fa7e35900ce5de20220a582a9483a7063811defce79d7cbd59d4cfe"
+checksum = "60db860322da191b40952ad9affe65ea23e7dd6a5c442c2c42865810c6ab8e6b"
 dependencies = [
+ "ansi_term",
  "sharded-slab",
  "thread_local",
  "tracing-core",
 ]
 
 [[package]]
-name = "tracing-subscriber"
-version = "0.3.6"
+name = "tracing-wasm"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77be66445c4eeebb934a7340f227bfe7b338173d3f8c00a60a5a58005c9faecf"
+checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07"
 dependencies = [
- "ansi_term",
- "sharded-slab",
- "thread_local",
- "tracing-core",
+ "tracing",
+ "tracing-subscriber",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "tracing-wasm"
-version = "0.2.0"
+name = "trash"
+version = "2.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae741706df70547fca8715f74a8569677666e7be3454313af70f6e158034485"
+checksum = "fe090367848cd40c4230ff3ce4e2ff6a2fd511c1e14ae047a4a4c37ef7965236"
 dependencies = [
- "tracing",
- "tracing-subscriber 0.2.20",
- "wasm-bindgen",
+ "chrono",
+ "libc",
+ "log 0.4.17",
+ "objc",
+ "once_cell",
+ "scopeguard",
+ "url",
+ "windows",
 ]
 
 [[package]]
 name = "tree-sitter"
-version = "0.20.6"
+version = "0.20.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b3b781640108d29892e8b9684642d2cda5ea05951fd58f0fea1db9edeb9b71"
+checksum = "d4423c784fe11398ca91e505cdc71356b07b1a924fc8735cfab5333afe3e18bc"
 dependencies = [
  "cc",
  "regex",
 ]
 
+[[package]]
+name = "tree-sitter-bash"
+version = "0.19.0"
+source = "git+https://github.com/tree-sitter/tree-sitter-bash?rev=4488aa41406547e478636a4fcfd24f5bbc3f2f74#4488aa41406547e478636a4fcfd24f5bbc3f2f74"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
 [[package]]
 name = "tree-sitter-c"
-version = "0.20.1"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cca211f4827d4b4dc79f388bf67b6fa3bc8a8cfa642161ef24f99f371ba34c7b"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-c-sharp"
+version = "0.20.0"
+source = "git+https://github.com/tree-sitter/tree-sitter-c-sharp?rev=5b60f99545fea00a33bbfae5be956f684c4c69e2#5b60f99545fea00a33bbfae5be956f684c4c69e2"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-clojure"
+version = "0.1.0"
+source = "git+https://github.com/abreumatheus/tree-sitter-clojure?rev=fdc969eb04fc711e38ad74afe441d74b3b5d3091#fdc969eb04fc711e38ad74afe441d74b3b5d3091"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-cmake"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bdc5574c6cbc39c409246caeb1dd4d3c4bd6d30d4e9b399776086c20365fd24"
+checksum = "ba8253ba26ab0adc2ae7cc7802d47cda9bba3fa31d07436f829a4c7f2b2442f3"
 dependencies = [
  "cc",
  "tree-sitter",
@@ -4568,10 +4956,46 @@ dependencies = [
  "tree-sitter",
 ]
 
+[[package]]
+name = "tree-sitter-css"
+version = "0.19.0"
+source = "git+https://github.com/syntacti/tree-sitter-css?rev=397aa132b9982fcdd2d473ed69343762a557f10a#397aa132b9982fcdd2d473ed69343762a557f10a"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-d"
+version = "0.3.2"
+source = "git+https://github.com/ghishadow/tree-sitter-d?rev=36603135ecb37ac6494c520efff91b875815d6f7#36603135ecb37ac6494c520efff91b875815d6f7"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-dart"
+version = "0.0.1"
+source = "git+https://github.com/syntacti/tree-sitter-dart?rev=78cad4503571d72666f78d5ba8ed6c1417653063#78cad4503571d72666f78d5ba8ed6c1417653063"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-dockerfile"
+version = "0.1.0"
+source = "git+https://github.com/panekj/tree-sitter-dockerfile?rev=c49d819e07685c90456270f1cc654d9cba640f53#c49d819e07685c90456270f1cc654d9cba640f53"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
 [[package]]
 name = "tree-sitter-elixir"
 version = "0.19.0"
-source = "git+https://github.com/elixir-lang/tree-sitter-elixir.git#60863fc6e27d60cf4b1917499ed2259f92c7800e"
+source = "git+https://github.com/elixir-lang/tree-sitter-elixir.git?rev=05e3631c6a0701c1fa518b0fee7be95a2ceef5e2#05e3631c6a0701c1fa518b0fee7be95a2ceef5e2"
 dependencies = [
  "cc",
  "tree-sitter",
@@ -4579,9 +5003,18 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-elm"
-version = "5.6.0"
+version = "5.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d4c28acbbdb8a0d72a5eb181e05d29f664e6631c3182f1e3d9974ae900addf3"
+checksum = "22b9408ad250aa27774132baf20c4f107faad16841aa45568c6900a27895093b"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-erlang"
+version = "0.0.1"
+source = "git+https://github.com/WhatsApp/tree-sitter-erlang?rev=a8b8b0e16c4f5552f5e85af3dec976a5d16af8b9#a8b8b0e16c4f5552f5e85af3dec976a5d16af8b9"
 dependencies = [
  "cc",
  "tree-sitter",
@@ -4590,7 +5023,16 @@ dependencies = [
 [[package]]
 name = "tree-sitter-glimmer"
 version = "0.0.1"
-source = "git+https://github.com/VixieTSQ/tree-sitter-glimmer#d8a41791e83d445ef52748429cea6fed974908e7"
+source = "git+https://github.com/VixieTSQ/tree-sitter-glimmer?rev=7281caca2ba114e1960c5d944a37860ef0841426#7281caca2ba114e1960c5d944a37860ef0841426"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-glsl"
+version = "0.1.3"
+source = "git+https://github.com/theHamsta/tree-sitter-glsl?rev=74329feb2605deccd32b1c644af507daa6fb82f1#74329feb2605deccd32b1c644af507daa6fb82f1"
 dependencies = [
  "cc",
  "tree-sitter",
@@ -4607,40 +5049,39 @@ dependencies = [
 ]
 
 [[package]]
-name = "tree-sitter-haskell"
-version = "0.14.0"
-source = "git+https://github.com/tree-sitter/tree-sitter-haskell#14bf3061a3fbcadab428fb5e50eb2c5b1f9be0c3"
+name = "tree-sitter-hare"
+version = "0.20.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cbd59e015721be7de5449fad7b7d5302f0f8544b1589f818d9a38afd4ff198b"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-haxe"
-version = "0.0.1"
-source = "git+https://github.com/VixieTSQ/tree-sitter-haxe#a3e23bc0f84a53371eb5d86229782ec6c21d3729"
+name = "tree-sitter-haskell"
+version = "0.14.0"
+source = "git+https://github.com/tree-sitter/tree-sitter-haskell?rev=e30bdfd53eb28c73f26a68b77d436fd2140af167#e30bdfd53eb28c73f26a68b77d436fd2140af167"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-hcl"
-version = "0.0.1"
-source = "git+https://github.com/VixieTSQ/tree-sitter-hcl#f4aa4553344e03e149ec459549a7f686d6846626"
+name = "tree-sitter-haxe"
+version = "0.2.2"
+source = "git+https://github.com/vantreeseba/tree-sitter-haxe?rev=52e3d2b9c3955aca886bccc38b496ef99b603a09#52e3d2b9c3955aca886bccc38b496ef99b603a09"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-highlight"
-version = "0.20.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "042342584c5a7a0b833d9fc4e2bdab3f9868ddc6c4b339a1e01451c6720868bc"
+name = "tree-sitter-hcl"
+version = "0.0.1"
+source = "git+https://github.com/VixieTSQ/tree-sitter-hcl?rev=f4aa4553344e03e149ec459549a7f686d6846626#f4aa4553344e03e149ec459549a7f686d6846626"
 dependencies = [
- "regex",
- "thiserror",
+ "cc",
  "tree-sitter",
 ]
 
@@ -4657,7 +5098,7 @@ dependencies = [
 [[package]]
 name = "tree-sitter-java"
 version = "0.20.0"
-source = "git+https://github.com/tree-sitter/tree-sitter-java.git#e7cb801ef57f74db5c4ebe14df74de852bb451b5"
+source = "git+https://github.com/tree-sitter/tree-sitter-java.git?rev=09d650def6cdf7f479f4b78f595e9ef5b58ce31e#09d650def6cdf7f479f4b78f595e9ef5b58ce31e"
 dependencies = [
  "cc",
  "tree-sitter",
@@ -4675,141 +5116,287 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-json"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90b04c4e1a92139535eb9fca4ec8fa9666cc96b618005d3ae35f3c957fa92f92"
+version = "0.20.0"
+source = "git+https://github.com/tree-sitter/tree-sitter-json.git?rev=11e2cc12d9b267766fb11a06e52952792fd8e3f0#11e2cc12d9b267766fb11a06e52952792fd8e3f0"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-md"
-version = "0.0.1"
-source = "git+https://github.com/MDeiml/tree-sitter-markdown.git#6d112e7a9c1694504bb78ee0b92dcd509625e0df"
+name = "tree-sitter-julia"
+version = "0.19.0"
+source = "git+https://github.com/varlad/tree-sitter-julia.git?rev=2ad4c9b79e0f213b61dbb3820754bfc6306e595a#2ad4c9b79e0f213b61dbb3820754bfc6306e595a"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-ocaml"
-version = "0.20.0"
-source = "git+https://github.com/tree-sitter/tree-sitter-ocaml#cc26b1ef111100f26a137bcbcd39fd4e35be9a59"
+name = "tree-sitter-kotlin"
+version = "0.2.11"
+source = "git+https://github.com/fwcd/tree-sitter-kotlin?rev=a4f71eb9b8c9b19ded3e0e9470be4b1b77c2b569#a4f71eb9b8c9b19ded3e0e9470be4b1b77c2b569"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-php"
-version = "0.19.1"
-source = "git+https://github.com/tree-sitter/tree-sitter-php.git#ead3e4cc5f54602a6b54826c5d6881c9a9da15af"
+name = "tree-sitter-latex"
+version = "0.2.0"
+source = "git+https://github.com/latex-lsp/tree-sitter-latex?rev=b3b2cf27f33e71438ebe46934900b1153901c6f2#b3b2cf27f33e71438ebe46934900b1153901c6f2"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-python"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83c46916553ebc2a5b23763cd2da8d2b104c515c8f828eb678d1477ccd8c379c"
+name = "tree-sitter-lua"
+version = "0.0.12"
+source = "git+https://github.com/syntacti/tree-sitter-lua?rev=a29f646c14ed800aaeef1ca58a9bacc6d92922e8#a29f646c14ed800aaeef1ca58a9bacc6d92922e8"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-ql"
-version = "0.19.0"
-source = "git+https://github.com/tree-sitter/tree-sitter-ql#b2c2364e833cc9f1afa243ac367f1475330fef63"
+name = "tree-sitter-md"
+version = "0.1.2"
+source = "git+https://github.com/MDeiml/tree-sitter-markdown.git?rev=272e080bca0efd19a06a7f4252d746417224959e#272e080bca0efd19a06a7f4252d746417224959e"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-ruby"
-version = "0.19.0"
-source = "git+https://github.com/Liberatys/tree-sitter-ruby.git?branch=chore/allow-range-of-tree-sitter#26086eeb072266abf51273af631a2cb62d0fd1e8"
+name = "tree-sitter-nix"
+version = "0.0.1"
+source = "git+https://github.com/panekj/tree-sitter-nix?rev=59fc47150ab437e8bb356c7ab21e9531e87f7cc8#59fc47150ab437e8bb356c7ab21e9531e87f7cc8"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-rust"
+name = "tree-sitter-ocaml"
 version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3df540a493d754015d22eaf57c38f58804be3713a22f6062db983ec15f85c3c9"
+source = "git+https://github.com/tree-sitter/tree-sitter-ocaml?rev=cc26b1ef111100f26a137bcbcd39fd4e35be9a59#cc26b1ef111100f26a137bcbcd39fd4e35be9a59"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-scss"
-version = "0.0.1"
-source = "git+https://github.com/VixieTSQ/tree-sitter-scss?branch=patch-1#3aac3391ede5098edbf4cc8a9f6d0cfdfe28e5dc"
+name = "tree-sitter-php"
+version = "0.19.1"
+source = "git+https://github.com/tree-sitter/tree-sitter-php.git?rev=ab2e72179ceb8bb0b249c8ac9162a148e911b3dc#ab2e72179ceb8bb0b249c8ac9162a148e911b3dc"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-swift"
-version = "0.3.0"
+name = "tree-sitter-prisma-io"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "090310d23c7a0a96cece88376ad7acf53ce47a036a64145ef2523a336c1d2051"
+checksum = "15843349be7dd0281ffb24dd9659c6695d7a3d43a75e175c6a985f8dd6089174"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-toml"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca517f578a98b23d20780247cc2688407fa81effad5b627a5a364ec3339b53e8"
+name = "tree-sitter-protobuf"
+version = "0.0.1"
+source = "git+https://github.com/yusdacra/tree-sitter-protobuf?rev=5aef38d655f76a6b0d172340eed3766c93b3124c#5aef38d655f76a6b0d172340eed3766c93b3124c"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "tree-sitter-typescript"
-version = "0.20.0"
+name = "tree-sitter-python"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8935efd97c92067c9b2b6d7acb647607590996ba80f3a7be09a197f9c1fdab73"
+checksum = "dda114f58048f5059dcf158aff691dffb8e113e6d2b50d94263fd68711975287"
 dependencies = [
  "cc",
  "tree-sitter",
 ]
 
 [[package]]
-name = "try-lock"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
+name = "tree-sitter-ql"
+version = "0.19.0"
+source = "git+https://github.com/tree-sitter/tree-sitter-ql?rev=bd087020f0d8c183080ca615d38de0ec827aeeaf#bd087020f0d8c183080ca615d38de0ec827aeeaf"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
 
 [[package]]
-name = "ttf-parser"
-version = "0.9.0"
+name = "tree-sitter-r"
+version = "0.19.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62ddb402ac6c2af6f7a2844243887631c4e94b51585b229fcfddb43958cd55ca"
-
-[[package]]
-name = "ttf-parser"
+checksum = "522c13f4cc46213148b19d4ad40a988ffabd51fd90eb7de759844fbde49bda0c"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-ruby"
+version = "0.19.0"
+source = "git+https://github.com/tree-sitter/tree-sitter-ruby.git?rev=656abef0645caea793e33c1c773570722463e1d8#656abef0645caea793e33c1c773570722463e1d8"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-rust"
+version = "0.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13470fafb7327a3acf96f5bc1013b5539a899a182f01c59b5af53f6b93195717"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-scheme"
+version = "0.2.0"
+source = "git+https://github.com/6cdh/tree-sitter-scheme.git?rev=af0fd1fa452cb2562dc7b5c8a8c55551c39273b9#af0fd1fa452cb2562dc7b5c8a8c55551c39273b9"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-scss"
+version = "0.0.1"
+source = "git+https://github.com/VixieTSQ/tree-sitter-scss?rev=3aac3391ede5098edbf4cc8a9f6d0cfdfe28e5dc#3aac3391ede5098edbf4cc8a9f6d0cfdfe28e5dc"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-sql"
+version = "0.0.2"
+source = "git+https://github.com/oknozor/tree-sitter-sql?rev=15dad0f3cae8a094a7dac17d712ea8fb25228011#15dad0f3cae8a094a7dac17d712ea8fb25228011"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-svelte"
+version = "0.10.2"
+source = "git+https://github.com/Himujjal/tree-sitter-svelte?rev=52e122ae68b316d3aa960a0a422d3645ba717f42#52e122ae68b316d3aa960a0a422d3645ba717f42"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-swift"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe0df6a792c4cd3066239195b65a322066c9ebbff58686a9de3e9ad9f25b510"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-toml"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca517f578a98b23d20780247cc2688407fa81effad5b627a5a364ec3339b53e8"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-typescript"
+version = "0.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e8ed0ecb931cdff13c6a13f45ccd615156e2779d9ffb0395864e05505e6e86d"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-vue"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fc58c2aaf6d4a5da799f45751719a6ff4b7d38a97479c6b547b442a8cbf8730"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-wgsl"
+version = "0.0.1"
+source = "git+https://github.com/szebniok/tree-sitter-wgsl?rev=272e89ef2aeac74178edb9db4a83c1ffef80a463#272e89ef2aeac74178edb9db4a83c1ffef80a463"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-xml"
+version = "0.0.1"
+source = "git+https://github.com/RenjiSann/tree-sitter-xml?rev=422528a43630db6dcc1e222d1c5ee3babd559473#422528a43630db6dcc1e222d1c5ee3babd559473"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-yaml"
+version = "0.0.1"
+source = "git+https://github.com/panekj/tree-sitter-yaml?rev=80c8d76847f03e772c5c524cf29bafb56858a8d1#80c8d76847f03e772c5c524cf29bafb56858a8d1"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-zig"
+version = "0.0.1"
+source = "git+https://github.com/maxxnino/tree-sitter-zig?rev=8d3224c3bd0890fe08358886ebf54fca2ed448a6#8d3224c3bd0890fe08358886ebf54fca2ed448a6"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
+
+[[package]]
+name = "ttf-parser"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62ddb402ac6c2af6f7a2844243887631c4e94b51585b229fcfddb43958cd55ca"
+
+[[package]]
+name = "ttf-parser"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ae2f58a822f08abdaf668897e96a5656fe72f5a9ce66422423e8849384872e6"
 
 [[package]]
 name = "ttf-parser"
-version = "0.15.0"
+version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c74c96594835e10fa545e2a51e8709f30b173a092bfd6036ef2cec53376244f3"
+checksum = "7b3e06c9b9d80ed6b745c7159c40b311ad2916abb34a49e9be2653b90db0d8dd"
 
 [[package]]
 name = "type-map"
@@ -4822,15 +5409,15 @@ dependencies = [
 
 [[package]]
 name = "typenum"
-version = "1.13.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "879f6906492a7cd215bfa4cf595b600146ccfac0c79bcbd1f3000162af5e8b06"
+checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
 
 [[package]]
 name = "ucd-trie"
-version = "0.1.3"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
+checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81"
 
 [[package]]
 name = "unic-bidi"
@@ -4912,9 +5499,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.6"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "246f4c42e67e7a4e3c6106ff716a5d067d4132a642840b242e357e468a2a0085"
+checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992"
 
 [[package]]
 name = "unicode-bidi-mirroring"
@@ -4940,26 +5527,32 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07547e3ee45e28326cc23faac56d44f58f16ab23e413db526debce3b0bfd2742"
 
+[[package]]
+name = "unicode-ident"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
+
 [[package]]
 name = "unicode-normalization"
-version = "0.1.19"
+version = "0.1.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
+checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
 dependencies = [
  "tinyvec",
 ]
 
 [[package]]
 name = "unicode-script"
-version = "0.5.3"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "098ec66172ce21cd55f8bcc786ee209dd20e04eff70acfca30cb79924d173ae9"
+checksum = "7d817255e1bed6dfd4ca47258685d14d2bdcfbc64fdc9e3819bd5848057b8ecc"
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.8.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"
+checksum = "0fdbf052a0783de01e944a6ce7a8cb939e295b1e7be835a1112c3b9a7f047a5a"
 
 [[package]]
 name = "unicode-vo"
@@ -4969,27 +5562,20 @@ checksum = "b1d386ff53b415b7fe27b50bb44679e2cc4660272694b7b6f3326d8480823a94"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.2"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
 
 [[package]]
 name = "url"
-version = "2.2.2"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
+checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
 dependencies = [
  "form_urlencoded",
  "idna",
- "matches",
  "percent-encoding",
- "serde 1.0.130",
+ "serde",
 ]
 
 [[package]]
@@ -4998,12 +5584,12 @@ version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef8352f317d8f9a918ba5154797fb2a93e2730244041cf7d5be35148266adfa5"
 dependencies = [
- "base64",
+ "base64 0.13.0",
  "data-url",
  "flate2",
  "fontdb 0.5.4",
  "kurbo",
- "log",
+ "log 0.4.17",
  "memmap2 0.2.3",
  "pico-args",
  "rctree 0.3.3",
@@ -5025,21 +5611,21 @@ version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a261d60a7215fa339482047cc3dafd4e22e2bf34396aaebef2b707355bbb39c0"
 dependencies = [
- "base64",
+ "base64 0.13.0",
  "data-url",
  "flate2",
  "float-cmp 0.9.0",
  "fontdb 0.9.1",
  "kurbo",
- "log",
+ "log 0.4.17",
  "pico-args",
  "rctree 0.4.0",
  "roxmltree",
- "rustybuzz 0.5.0",
+ "rustybuzz 0.5.1",
  "simplecss",
  "siphasher 0.3.10",
- "svgtypes 0.8.0",
- "ttf-parser 0.15.0",
+ "svgtypes 0.8.1",
+ "ttf-parser 0.15.2",
  "unicode-bidi",
  "unicode-script",
  "unicode-vo",
@@ -5054,19 +5640,13 @@ checksum = "936e4b492acfd135421d8dca4b1aa80a7bfc26e702ef3af710e0752684df5372"
 
 [[package]]
 name = "uuid"
-version = "0.8.2"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"
+checksum = "422ee0de9031b5b948b97a8fc04e3aa35230001a722ddd27943e0be31564ce4c"
 dependencies = [
  "getrandom",
 ]
 
-[[package]]
-name = "valuable"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
-
 [[package]]
 name = "vcpkg"
 version = "0.2.15"
@@ -5081,9 +5661,9 @@ checksum = "1c18c859eead79d8b95d09e4678566e8d70105c4e7b251f707a03df32442661b"
 
 [[package]]
 name = "version_check"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
 name = "vte"
@@ -5105,6 +5685,12 @@ dependencies = [
  "quote",
 ]
 
+[[package]]
+name = "waker-fn"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
+
 [[package]]
 name = "walkdir"
 version = "2.3.2"
@@ -5122,7 +5708,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
 dependencies = [
- "log",
+ "log 0.4.17",
  "try-lock",
 ]
 
@@ -5138,11 +5724,72 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
+[[package]]
+name = "wasi-cap-std-sync"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd3298c9cd5b619d74c3ef7130a370da0f677b30110a34ab15985b3b81475bc9"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "cap-fs-ext",
+ "cap-rand",
+ "cap-std",
+ "cap-time-ext",
+ "fs-set-times",
+ "io-extras",
+ "io-lifetimes",
+ "is-terminal",
+ "once_cell",
+ "rustix",
+ "system-interface",
+ "tracing",
+ "wasi-common",
+ "windows-sys",
+]
+
+[[package]]
+name = "wasi-common"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5eaf4ef6ce85c09254f2ff414e8319b023b60007f3d0eb6164b14a41c56231c"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "cap-rand",
+ "cap-std",
+ "io-extras",
+ "rustix",
+ "thiserror",
+ "tracing",
+ "wiggle",
+ "windows-sys",
+]
+
+[[package]]
+name = "wasi-experimental-http-wasmtime"
+version = "0.10.0"
+source = "git+https://github.com/lapce/wasi-experimental-http#5c6d970fe0750932f76979678384bf1c5ab5be2e"
+dependencies = [
+ "anyhow",
+ "bytes",
+ "futures",
+ "http",
+ "reqwest",
+ "thiserror",
+ "tokio",
+ "tracing",
+ "url",
+ "wasi-common",
+ "wasmtime",
+ "wasmtime-wasi",
+]
+
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.76"
+version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ce9b1b516211d33767048e5d47fa2a381ed8b76fc48d2ce4aa39877f9f183e0"
+checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
 dependencies = [
  "cfg-if 1.0.0",
  "wasm-bindgen-macro",
@@ -5150,13 +5797,13 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.76"
+version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfe8dc78e2326ba5f845f4b5bf548401604fa20b1dd1d365fb73b6c1d6364041"
+checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
 dependencies = [
  "bumpalo",
- "lazy_static",
- "log",
+ "log 0.4.17",
+ "once_cell",
  "proc-macro2",
  "quote",
  "syn",
@@ -5165,9 +5812,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.26"
+version = "0.4.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95fded345a6559c2cfee778d562300c581f7d4ff3edb9b0d230d69800d213972"
+checksum = "23639446165ca5a5de86ae1d8896b737ae80319560fbaa4c2887b7da6e7ebd7d"
 dependencies = [
  "cfg-if 1.0.0",
  "js-sys",
@@ -5177,9 +5824,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.76"
+version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44468aa53335841d9d6b6c023eaab07c0cd4bddbcfdee3e2bb1e8d2cb8069fef"
+checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -5187,9 +5834,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.76"
+version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0195807922713af1e67dc66132c7328206ed9766af3858164fb583eedc25fbad"
+checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5200,269 +5847,264 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.76"
+version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acdb075a845574a1fa5f09fd77e43f7747599301ea3417a9fbffdeedfc1f4a29"
+checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
 
 [[package]]
-name = "wasmer"
-version = "2.1.1"
+name = "wasm-encoder"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23f0188c23fc1b7de9bd7f8b834d0b1cd5edbe66e287452e8ce36d24418114f7"
+checksum = "7e7ca71c70a6de5b10968ae4d298e548366d9cd9588176e6ff8866f3c49c96ee"
 dependencies = [
- "cfg-if 1.0.0",
- "indexmap",
- "js-sys",
- "loupe",
- "more-asserts",
- "target-lexicon",
- "thiserror",
- "wasm-bindgen",
- "wasmer-compiler",
- "wasmer-compiler-cranelift",
- "wasmer-derive",
- "wasmer-engine",
- "wasmer-engine-dylib",
- "wasmer-engine-universal",
- "wasmer-types",
- "wasmer-vm",
- "wat",
- "winapi 0.3.9",
+ "leb128",
 ]
 
 [[package]]
-name = "wasmer-compiler"
-version = "2.1.1"
+name = "wasmparser"
+version = "0.89.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88c51cc589772c5f90bd329244c2416976d6cb2ee00d59429aaa8f421d9fe447"
+checksum = "ab5d3e08b13876f96dd55608d03cd4883a0545884932d5adf11925876c96daef"
 dependencies = [
- "enumset",
- "loupe",
- "rkyv",
- "serde 1.0.130",
- "serde_bytes",
- "smallvec",
- "target-lexicon",
- "thiserror",
- "wasmer-types",
- "wasmer-vm",
- "wasmparser",
+ "indexmap",
 ]
 
 [[package]]
-name = "wasmer-compiler-cranelift"
-version = "2.1.1"
+name = "wasmtime"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09691e3e323b4e1128d2127f60f9cd988b66ce49afc8184b071c2b5ab16793f2"
+checksum = "4ad5af6ba38311282f2a21670d96e78266e8c8e2f38cbcd52c254df6ccbc7731"
 dependencies = [
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-frontend",
- "gimli",
- "loupe",
- "more-asserts",
+ "anyhow",
+ "async-trait",
+ "bincode",
+ "cfg-if 1.0.0",
+ "indexmap",
+ "libc",
+ "log 0.4.17",
+ "object",
+ "once_cell",
+ "paste",
+ "psm",
  "rayon",
- "smallvec",
+ "serde",
  "target-lexicon",
- "tracing",
- "wasmer-compiler",
- "wasmer-types",
- "wasmer-vm",
+ "wasmparser",
+ "wasmtime-cache",
+ "wasmtime-cranelift",
+ "wasmtime-environ",
+ "wasmtime-fiber",
+ "wasmtime-jit",
+ "wasmtime-runtime",
+ "wat",
+ "windows-sys",
 ]
 
 [[package]]
-name = "wasmer-derive"
-version = "2.1.1"
+name = "wasmtime-asm-macros"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f5cb7b09640e09f1215da95d6fb7477d2db572f064b803ff705f39ff079cc5"
+checksum = "45de63ddfc8b9223d1adc8f7b2ee5f35d1f6d112833934ad7ea66e4f4339e597"
 dependencies = [
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn",
+ "cfg-if 1.0.0",
 ]
 
 [[package]]
-name = "wasmer-engine"
-version = "2.1.1"
+name = "wasmtime-cache"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab20311c354fe2c12bc766417e0a1a45f399c1cd8ff262127d1dc86d0588971a"
+checksum = "bcd849399d17d2270141cfe47fa0d91ee52d5f8ea9b98cf7ddde0d53e5f79882"
 dependencies = [
- "backtrace",
- "enumset",
- "lazy_static",
- "loupe",
- "memmap2 0.5.3",
- "more-asserts",
- "rustc-demangle",
- "serde 1.0.130",
- "serde_bytes",
- "target-lexicon",
- "thiserror",
- "wasmer-compiler",
- "wasmer-types",
- "wasmer-vm",
+ "anyhow",
+ "base64 0.13.0",
+ "bincode",
+ "directories-next",
+ "file-per-thread-logger",
+ "log 0.4.17",
+ "rustix",
+ "serde",
+ "sha2 0.9.9",
+ "toml",
+ "windows-sys",
+ "zstd",
 ]
 
 [[package]]
-name = "wasmer-engine-dylib"
-version = "2.1.1"
+name = "wasmtime-cranelift"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8dd5b7a74731e1dcccaf10a8ff5f72216c82f12972ce17cc81c6caa1afff75ea"
+checksum = "4bd91339b742ff20bfed4532a27b73c86b5bcbfedd6bea2dcdf2d64471e1b5c6"
 dependencies = [
- "cfg-if 1.0.0",
- "enumset",
- "leb128",
- "libloading",
- "loupe",
- "rkyv",
- "serde 1.0.130",
- "tempfile",
- "tracing",
- "wasmer-compiler",
- "wasmer-engine",
- "wasmer-object",
- "wasmer-types",
- "wasmer-vm",
- "which",
+ "anyhow",
+ "cranelift-codegen",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "cranelift-native",
+ "cranelift-wasm",
+ "gimli",
+ "log 0.4.17",
+ "object",
+ "target-lexicon",
+ "thiserror",
+ "wasmparser",
+ "wasmtime-environ",
 ]
 
 [[package]]
-name = "wasmer-engine-universal"
-version = "2.1.1"
+name = "wasmtime-environ"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfeae8d5b825ad7abcf9a34e66eb11e1507b21020efe7bbf9897e3dd8d7869e2"
+checksum = "ebb881c61f4f627b5d45c54e629724974f8a8890d455bcbe634330cc27309644"
 dependencies = [
- "cfg-if 1.0.0",
- "enumset",
- "leb128",
- "loupe",
- "region",
- "rkyv",
- "wasmer-compiler",
- "wasmer-engine",
- "wasmer-types",
- "wasmer-vm",
- "winapi 0.3.9",
+ "anyhow",
+ "cranelift-entity",
+ "gimli",
+ "indexmap",
+ "log 0.4.17",
+ "object",
+ "serde",
+ "target-lexicon",
+ "thiserror",
+ "wasmparser",
+ "wasmtime-types",
 ]
 
 [[package]]
-name = "wasmer-object"
-version = "2.1.1"
+name = "wasmtime-fiber"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d4714e4f3bdc3b2157c24284417d19cd99de036da31d00ec5664712dcb72f7"
+checksum = "7e867cf58e31bfa0ab137bd47e207d2e1e38c581d7838b2f258d47c8145db412"
 dependencies = [
- "object 0.27.1",
- "thiserror",
- "wasmer-compiler",
- "wasmer-types",
+ "cc",
+ "cfg-if 1.0.0",
+ "rustix",
+ "wasmtime-asm-macros",
+ "windows-sys",
 ]
 
 [[package]]
-name = "wasmer-types"
-version = "2.1.1"
+name = "wasmtime-jit"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "434e1c0177da0a74ecca90b2aa7d5e86198260f07e8ba83be89feb5f0a4aeead"
+checksum = "1985c628011fe26adf5e23a5301bdc79b245e0e338f14bb58b39e4e25e4d8681"
 dependencies = [
- "indexmap",
- "loupe",
- "rkyv",
- "serde 1.0.130",
+ "addr2line",
+ "anyhow",
+ "bincode",
+ "cfg-if 1.0.0",
+ "cpp_demangle",
+ "gimli",
+ "ittapi",
+ "log 0.4.17",
+ "object",
+ "rustc-demangle",
+ "rustix",
+ "serde",
+ "target-lexicon",
  "thiserror",
+ "wasmtime-environ",
+ "wasmtime-jit-debug",
+ "wasmtime-runtime",
+ "windows-sys",
 ]
 
 [[package]]
-name = "wasmer-vfs"
-version = "2.1.1"
+name = "wasmtime-jit-debug"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a3a58a3700781aa4f5344915ea082086e75ba7ebe294f60ae499614db92dd00"
+checksum = "f671b588486f5ccec8c5a3dba6b4c07eac2e66ab8c60e6f4e53717c77f709731"
 dependencies = [
- "libc",
- "thiserror",
- "tracing",
+ "object",
+ "once_cell",
+ "rustix",
 ]
 
 [[package]]
-name = "wasmer-vm"
-version = "2.1.1"
+name = "wasmtime-runtime"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc8f964ebba70d9f81340228b98a164782591f00239fc7f01e1b67afcf0e0156"
+checksum = "ee8f92ad4b61736339c29361da85769ebc200f184361959d1792832e592a1afd"
 dependencies = [
- "backtrace",
+ "anyhow",
  "cc",
  "cfg-if 1.0.0",
  "indexmap",
  "libc",
- "loupe",
+ "log 0.4.17",
+ "mach",
+ "memfd",
  "memoffset",
- "more-asserts",
- "region",
- "rkyv",
- "serde 1.0.130",
+ "paste",
+ "rand",
+ "rustix",
  "thiserror",
- "wasmer-types",
- "winapi 0.3.9",
+ "wasmtime-asm-macros",
+ "wasmtime-environ",
+ "wasmtime-fiber",
+ "wasmtime-jit-debug",
+ "windows-sys",
 ]
 
 [[package]]
-name = "wasmer-wasi"
-version = "2.1.1"
+name = "wasmtime-types"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c2b1d981ad312dac6e74a41a35b9bca41a6d1157c3e6a575fb1041e4b516610"
+checksum = "d23d61cb4c46e837b431196dd06abb11731541021916d03476a178b54dc07aeb"
 dependencies = [
- "cfg-if 1.0.0",
- "generational-arena",
- "getrandom",
- "libc",
+ "cranelift-entity",
+ "serde",
  "thiserror",
- "tracing",
- "wasm-bindgen",
- "wasmer",
- "wasmer-vfs",
- "wasmer-wasi-types",
- "winapi 0.3.9",
+ "wasmparser",
 ]
 
 [[package]]
-name = "wasmer-wasi-types"
-version = "2.1.1"
+name = "wasmtime-wasi"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7731240c0ae536623414beb73091dddf68d1a080f49086fc31ec916536b1af98"
+checksum = "e69271e6b52d59a9e1a5309fefb4c38969baff8eebc03c76293e7c7dc44e0ba1"
 dependencies = [
- "byteorder",
- "time 0.2.27",
- "wasmer-types",
+ "anyhow",
+ "wasi-cap-std-sync",
+ "wasi-common",
+ "wasmtime",
+ "wiggle",
 ]
 
 [[package]]
-name = "wasmparser"
-version = "0.78.2"
+name = "wast"
+version = "35.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52144d4c78e5cf8b055ceab8e5fa22814ce4315d6002ad32cfd914f37c12fd65"
+checksum = "2ef140f1b49946586078353a453a1d28ba90adfc54dde75710bc1931de204d68"
+dependencies = [
+ "leb128",
+]
 
 [[package]]
 name = "wast"
-version = "38.0.1"
+version = "47.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae0d7b256bef26c898fa7344a2d627e8499f5a749432ce0a05eae1a64ff0c271"
+checksum = "117ccfc4262e62a28a13f0548a147f19ffe71e8a08be802af23ae4ea0bedad73"
 dependencies = [
  "leb128",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder",
 ]
 
 [[package]]
 name = "wat"
-version = "1.0.40"
+version = "1.0.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adcfaeb27e2578d2c6271a45609f4a055e6d7ba3a12eff35b1fd5ba147bdf046"
+checksum = "7aab4e20c60429fbba9670a6cae0fff9520046ba0aa3e6d0b1cd2653bea14898"
 dependencies = [
- "wast",
+ "wast 47.0.0",
 ]
 
 [[package]]
 name = "web-sys"
-version = "0.3.53"
+version = "0.3.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "224b2f6b67919060055ef1a67807367c2066ed520c3862cc013d26cf893a783c"
+checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -5470,19 +6112,61 @@ dependencies = [
 
 [[package]]
 name = "weezl"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c97e489d8f836838d497091de568cf16b117486d529ec5579233521065bd5e4"
+checksum = "9193164d4de03a926d909d3bc7c30543cecb35400c02114792c2cae20d5e2dbb"
 
 [[package]]
 name = "which"
-version = "4.2.5"
+version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c4fb54e6113b6a8772ee41c3404fb0301ac79604489467e0a9ce1f3e97c24ae"
+checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
 dependencies = [
  "either",
- "lazy_static",
  "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "wiggle"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3cd76a4d5e4052fb377eb7629a8971ce3e4668ba397e8e4c03d86ada0c7f4f1"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "bitflags",
+ "thiserror",
+ "tracing",
+ "wasmtime",
+ "wiggle-macro",
+]
+
+[[package]]
+name = "wiggle-generate"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec1cc12e9d5af2d9488588be80b98f045a8872500bbb78c93b85a205e557f91"
+dependencies = [
+ "anyhow",
+ "heck 0.4.0",
+ "proc-macro2",
+ "quote",
+ "shellexpand",
+ "syn",
+ "witx",
+]
+
+[[package]]
+name = "wiggle-macro"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7d2f18f246c48657537c507de7c1941970b09ef2d4c6351debc739a1827ebd3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wiggle-generate",
 ]
 
 [[package]]
@@ -5528,17 +6212,30 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57b543186b344cc61c85b5aab0d2e3adf4e0f99bc076eff9aa5927bcc0b8a647"
+dependencies = [
+ "windows_aarch64_msvc 0.37.0",
+ "windows_i686_gnu 0.37.0",
+ "windows_i686_msvc 0.37.0",
+ "windows_x86_64_gnu 0.37.0",
+ "windows_x86_64_msvc 0.37.0",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
 dependencies = [
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_msvc",
+ "windows_aarch64_msvc 0.36.1",
+ "windows_i686_gnu 0.36.1",
+ "windows_i686_msvc 0.36.1",
+ "windows_x86_64_gnu 0.36.1",
+ "windows_x86_64_msvc 0.36.1",
 ]
 
 [[package]]
@@ -5547,30 +6244,60 @@ version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2623277cb2d1c216ba3b578c0f3cf9cdebeddb6e66b1b218bb33596ea7769c3a"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3925fd0b0b804730d44d4b6278c50f9699703ec49bcd628020f46f4ba07d9e1"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce907ac74fe331b524c1298683efbf598bb031bc84d5e274db2083696d07c57c"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2babfba0828f2e6b32457d5341427dcbb577ceef556273229959ac23a10af33d"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4dd6dc7df2d84cf7b33822ed5b86318fb1781948e9663bacd047fc9dd52259d"
+
 [[package]]
 name = "winreg"
 version = "0.10.1"
@@ -5589,6 +6316,17 @@ dependencies = [
  "toml",
 ]
 
+[[package]]
+name = "winx"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7b01e010390eb263a4518c8cebf86cb67469d1511c00b749a47b64c39e8054d"
+dependencies = [
+ "bitflags",
+ "io-lifetimes",
+ "windows-sys",
+]
+
 [[package]]
 name = "wio"
 version = "0.2.2"
@@ -5598,6 +6336,18 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "witx"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e366f27a5cabcddb2706a78296a40b8fcc451e1a6aba2fc1d94b4a01bdaaef4b"
+dependencies = [
+ "anyhow",
+ "log 0.4.17",
+ "thiserror",
+ "wast 35.0.2",
+]
+
 [[package]]
 name = "ws2_32-sys"
 version = "0.2.1"
@@ -5609,15 +6359,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "xi-rope"
-version = "0.3.0"
-source = "git+https://github.com/lapce/xi-editor#5578c7253ff8f644638bebace1261b6a412ce03c"
+name = "xattr"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d1526bbe5aaeb5eb06885f4d987bcdfa5e23187055de9b83fe00156a821fabc"
 dependencies = [
- "bytecount",
- "memchr",
- "regex",
- "serde 1.0.130",
- "unicode-segmentation",
+ "libc",
 ]
 
 [[package]]
@@ -5626,6 +6373,15 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a67300977d3dc3f8034dae89778f502b6ba20b269527b3223ba59c0cf393bb8a"
 
+[[package]]
+name = "xml-rs"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c1cb601d29fe2c2ac60a2b2e5e293994d87a1f6fa9687a31a15270f909be9c2"
+dependencies = [
+ "bitflags",
+]
+
 [[package]]
 name = "xml-rs"
 version = "0.8.4"
@@ -5661,9 +6417,9 @@ checksum = "c03b3e19c937b5b9bd8e52b1c88f30cce5c0d33d676cf174866175bb794ff658"
 
 [[package]]
 name = "yeslogic-fontconfig-sys"
-version = "3.0.1"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb3f5a91c31bef6650d3a1b69192b4217fd88e4cfedc8101813e4dc3394ecbb8"
+checksum = "f2bbd69036d397ebbff671b1b8e4d918610c181c5a16073b96f984a38d08c386"
 dependencies = [
  "const-cstr",
  "dlib",
@@ -5676,3 +6432,44 @@ name = "zeno"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c110ba09c9b3a43edd4803d570df0da2414fed6e822e22b976a4e3ef50860701"
+
+[[package]]
+name = "zip"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "537ce7411d25e54e8ae21a7ce0b15840e7bfcff15b51d697ec3266cc76bdf080"
+dependencies = [
+ "byteorder",
+ "crc32fast",
+ "crossbeam-utils",
+ "flate2",
+]
+
+[[package]]
+name = "zstd"
+version = "0.11.2+zstd.1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "5.0.2+zstd.1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db"
+dependencies = [
+ "libc",
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.1+zstd.1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fd07cbbc53846d9145dbffdf6dd09a7a0aa52be46741825f5c97bdd4f73f12b"
+dependencies = [
+ "cc",
+ "libc",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 41206af432..66aae91ac1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,10 +1,10 @@
 [package]
 name = "lapce"
-version = "0.1.2"
+version = "0.2.6"
 authors = ["Dongdong Zhou <dzhou121@gmail.com>"]
 edition = "2021"
-rust-version = "1.60"
-resolver = "2"
+rust-version = "1.65"
+default-run = "lapce"
 
 [dependencies]
 lapce-ui = { path = "./lapce-ui" }
@@ -21,6 +21,61 @@ path = "lapce-proxy/src/bin/lapce-proxy.rs"
 [workspace]
 members = ["lapce-ui", "lapce-proxy", "lapce-rpc", "lapce-data", "lapce-core"]
 
+[workspace.package]
+version = "0.2.6"
+edition = "2021"
+rust-version = "1.64"
+homepage = "https://lapce.dev"
+authors = ["Dongdong Zhou <dzhou121@gmail.com>"]
+
+[workspace.dependencies]
+alacritty_terminal = "0.17.0"
+anyhow = "1.0"
+chrono = "0.4"
+clap = { version = "3.2.17", features = ["derive"] }
+crossbeam-channel = "0.5.0"
+directories = "4.0.1"
+flate2 = "1.0"
+hashbrown = { version = "0.12.3", features = ["serde"] }
+im = { version = "15.0.0", features = ["serde"] }
+include_dir = "0.6.2"
+indexmap = { version = "1.9", features = ["serde"] }
+interprocess = "1.1.1"
+itertools = "0.10.1"
+log = "0.4"
+notify = { version = "5.0.0", features = ["serde"] }
+once_cell = "1.17"
+parking_lot = { version = "0.11.0", features = ["deadlock_detection"] }
+rayon = "1.5.1"
+regex = "1.7.0"
+reqwest = { version = "0.11", features = ["blocking", "json", "socks"] }
+serde = "1.0"
+serde_json = "1.0"
+smallvec = "1.10.0"
+strum = "0.21.0" # follow same version as system-deps in lockfile
+strum_macros = "0.21.1" # ditto
+tar = "0.4"
+thiserror = "1.0"
+toml_edit = { version = "0.14.4", features = ["easy"] }
+
+lsp-types = { version = "0.93", features = ["proposed"] }
+psp-types = { git = "https://github.com/lapce/psp-types" }
+
+
+lapce-xi-rope = { version = "0.3.1", features = ["serde"] }
+
+lapce-core = { path = "./lapce-core" }
+lapce-rpc = { path = "./lapce-rpc" }
+lapce-data = { path = "./lapce-data" }
+lapce-proxy = { path = "./lapce-proxy" }
+
+[workspace.dependencies.druid]
+git = "https://github.com/lapce/druid"
+branch = "shell_opengl"
+# path = "../../druid/druid"
+features = ["svg", "im", "serde"]
+
+
 [profile.release-lto]
 inherits = "release"
 lto = true
diff --git a/Makefile b/Makefile
index c470a454e7..d852cd8195 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,7 @@
 TARGET = lapce
 
+CODESIGN_IDENTITY = FAC8FBEA99169DC1980731029648F110628D6A32
+
 ASSETS_DIR = extra
 RELEASE_DIR = target/release-lto
 
@@ -31,7 +33,7 @@ $(TARGET)-universal:
 	MACOSX_DEPLOYMENT_TARGET="10.11" cargo build --profile release-lto --target=x86_64-apple-darwin
 	MACOSX_DEPLOYMENT_TARGET="10.11" cargo build --profile release-lto --target=aarch64-apple-darwin
 	@lipo target/{x86_64,aarch64}-apple-darwin/release-lto/$(TARGET) -create -output $(APP_BINARY)
-	/usr/bin/codesign -vvv --deep --entitlements $(ASSETS_DIR)/entitlements.plist --strict --options=runtime --force -s FAC8FBEA99169DC1980731029648F110628D6A32 $(APP_BINARY)
+	/usr/bin/codesign -vvv --deep --entitlements $(ASSETS_DIR)/entitlements.plist --strict --options=runtime --force -s $(CODESIGN_IDENTITY) $(APP_BINARY)
 
 app: $(APP_NAME)-native ## Create a Lapce.app
 app-universal: $(APP_NAME)-universal ## Create a universal Lapce.app
@@ -44,7 +46,7 @@ $(APP_NAME)-%: $(TARGET)-%
 	@echo "Created '$(APP_NAME)' in '$(APP_DIR)'"
 	xattr -c $(APP_DIR)/$(APP_NAME)/Contents/Info.plist
 	xattr -c $(APP_DIR)/$(APP_NAME)/Contents/Resources/lapce.icns
-	/usr/bin/codesign -vvv --deep  --entitlements $(ASSETS_DIR)/entitlements.plist --strict --options=runtime --force -s FAC8FBEA99169DC1980731029648F110628D6A32 $(APP_DIR)/$(APP_NAME)
+	/usr/bin/codesign -vvv --deep  --entitlements $(ASSETS_DIR)/entitlements.plist --strict --options=runtime --force -s $(CODESIGN_IDENTITY) $(APP_DIR)/$(APP_NAME)
 
 dmg: $(DMG_NAME)-native ## Create a Lapce.dmg
 dmg-universal: $(DMG_NAME)-universal ## Create a universal Lapce.dmg
@@ -57,7 +59,7 @@ $(DMG_NAME)-%: $(APP_NAME)-%
 		-srcfolder $(APP_DIR) \
 		-ov -format UDZO
 	@echo "Packed '$(APP_NAME)' in '$(APP_DIR)'"
-	/usr/bin/codesign -vvv --deep  --entitlements $(ASSETS_DIR)/entitlements.plist --strict --options=runtime --force -s FAC8FBEA99169DC1980731029648F110628D6A32 $(DMG_DIR)/$(DMG_NAME)
+	/usr/bin/codesign -vvv --deep  --entitlements $(ASSETS_DIR)/entitlements.plist --strict --options=runtime --force -s $(CODESIGN_IDENTITY) $(DMG_DIR)/$(DMG_NAME)
 
 install: $(INSTALL)-native ## Mount disk image
 install-universal: $(INSTALL)-native ## Mount universal disk image
diff --git a/README.md b/README.md
index e14f926589..50158ad606 100644
--- a/README.md
+++ b/README.md
@@ -24,7 +24,11 @@
 <br/>
 
 
+<<<<<<< HEAD
 Lapceは純粋なRustで書かれており、UIは [Druid](https://github.com/linebender/druid) (これもRustで作成されています) のUIを使用して純粋なRustで記述されています。 [Rope Science](https://xi-editor.io/docs/rope_science_00.html) の [Xi-Editor](https://github.com/xi-editor/xi-editor) を使って設計されているので、計算が非常に速いです。レンダリングには [OpenGL](https://www.opengl.org/) を利用しています。Lapce の機能についての詳細は [Lapceのウェブサイト](https://lapce.dev) から、ユーザードキュメントは [GitBook](https://docs.lapce.dev/) から閲覧が可能です。
+=======
+Lapce (IPA: /læps/) is written in pure Rust with a UI in [Druid](https://github.com/linebender/druid) (which is also written in Rust). It is designed with [Rope Science](https://xi-editor.io/docs/rope_science_00.html) from the [Xi-Editor](https://github.com/xi-editor/xi-editor) which makes for lightning-fast computation, and leverages [OpenGL](https://www.opengl.org/) for rendering. More information about the features of Lapce can be found on the [main website](https://lapce.dev) and user documentation can be found on [GitBook](https://docs.lapce.dev/).
+>>>>>>> 9845c1a0b3fbfd6afdc0fb1504d3be78764e0c7b
 
 ![](https://github.com/lapce/lapce/blob/master/extra/images/screenshot.png?raw=true)
 
@@ -36,44 +40,14 @@ Lapceは純粋なRustで書かれており、UIは [Druid](https://github.com/li
 * Plugins can be written in programming languages that can compile to the [WASI](https://wasi.dev/) format (C, Rust, [AssemblyScript](https://www.assemblyscript.org/))
 * Built-in terminal, so you can execute commands in your workspace, without leaving Lapce.
 
-## Contributing
-
-Guidelines for contributing to Lapce can be found in [`CONTRIBUTING.md`](CONTRIBUTING.md).
-
-## Building from source
-
-It is easy to build Lapce from source on a GNU/Linux distribution. Cargo handles the build process, all you need to do, is ensure the correct dependencies are installed.
-
-1. Install the Rust compiler and Cargo using [`rustup.rs`](https://rustup.rs/). If you already have the toolchain, ensure you are using version 1.60 or higher.
+## Installation
 
-2. Install dependencies for your operating system:
+You can find pre-built releases for Windows, Linux and macOS [here](https://github.com/lapce/lapce/releases), or [installing with a package manager](docs/installing-with-package-manager.md).
+If you'd like to compile from source, you can find the [guide](docs/building-from-source.md).
 
-#### Ubuntu
-```sh
-sudo apt install cmake pkg-config libfontconfig-dev libgtk-3-dev
-```
-#### Fedora
-```sh
-sudo dnf install gcc-c++ perl-FindBin perl-File-Compare gtk3-devel
-```
-
-3. Clone this repository (this command will clone to your home directory):
-```sh
-git clone https://github.com/lapce/lapce.git ~/lapce
-```
-
-4. `cd` into the repository, and run the build command with the release flag
-```sh
-cd ~/lapce
-```
-
-```sh
-cargo build --release
-```
-
-> If you use a different distribution, and are having trouble finding appropriate dependencies, let us know in an issue!
+## Contributing
 
-Once Lapce is compiled, the executable will be available in `target/release/lapce`.
+Guidelines for contributing to Lapce can be found in [`CONTRIBUTING.md`](CONTRIBUTING.md).
 
 ## Feedback & Contact
 
@@ -85,4 +59,4 @@ There is also a [Matrix Space](https://matrix.to/#/#lapce-editor:matrix.org), wh
 
 ## License
 
-Lapce is released under the Apache License Version 2, which is an open source license. You may contribute to this project, or use the code as you please as long as you adhere to its conditions. You can find a copy of the license text within `LICENSE`.
+Lapce is released under the Apache License Version 2, which is an open source license. You may contribute to this project, or use the code as you please as long as you adhere to its conditions. You can find a copy of the license text here: [`LICENSE`](LICENSE).
diff --git a/defaults/dark-theme.toml b/defaults/dark-theme.toml
index 11ab1b0df0..111ec8c266 100644
--- a/defaults/dark-theme.toml
+++ b/defaults/dark-theme.toml
@@ -1,4 +1,6 @@
-[theme]
+#:schema ../extra/schemas/color-theme.json
+
+[color-theme]
 name = "Lapce Dark"
 
 [ui]
@@ -11,20 +13,20 @@ activity-width = 50
 scroll-width = 10
 drop-shadow-width = 0
 
-[theme.base]
-white = "#ABB2BF"
+[color-theme.base]
 black = "#282C34"
-grey = "#3E4451"
 blue = "#61AFEF"
-red = "#E06C75"
-yellow = "#E5C07B"
-orange = "#D19A66"
-green = "#98C379"
-purple = "#C678DD"
 cyan = "#56B6C2"
+green = "#98C379"
+grey = "#3E4451"
 magenta = "#C678DD"
+orange = "#D19A66"
+purple = "#C678DD"
+red = "#E06C75"
+white = "#ABB2BF"
+yellow = "#E5C07B"
 
-[theme.syntax]
+[color-theme.syntax]
 "comment" = "#5C6370"
 "constant" = "$yellow"
 "type" = "$yellow"
@@ -45,22 +47,53 @@ magenta = "#C678DD"
 "property" = "$red"
 "enumMember" = "$red"
 "enum-member" = "$red"
-"variable.other.member" = "$red"
 "string" = "$green"
 "type.builtin" = "$cyan"
 "builtinType" = "$cyan"
 "escape" = "$cyan"
+"string.escape" = "$cyan"
 "embedded" = "$cyan"
+"punctuation.delimiter" = "$yellow"
+"text.title" = "$orange"
+"text.uri" = "$cyan"
+"text.reference" = "$yellow"
+"variable" = "$red"
+"variable.other.member" = "$green"
+"tag" = "$blue"
 
-[theme.ui]
-"lapce.active_tab" = "$black"
-"lapce.inactive_tab" = "$grey"
+[color-theme.ui]
 "lapce.error" = "$red"
 "lapce.warn" = "$yellow"
 "lapce.dropdown_shadow" = "#000000"
 "lapce.border" = "#000000"
 "lapce.scroll_bar" = "$grey"
 
+"lapce.button.primary.background" = "#50a14f"
+"lapce.button.primary.foreground" = "$black"
+
+# tab
+"lapce.tab.active.background" = "$black"
+"lapce.tab.active.foreground" = "$white"
+"lapce.tab.active.underline" = "#528BFF"
+
+"lapce.tab.inactive.background" = "#21252b"
+"lapce.tab.inactive.foreground" = "$white"
+"lapce.tab.inactive.underline" = "#528BFF77"
+
+"lapce.tab.separator" = ""
+
+"lapce.icon.active" = "$white"
+"lapce.icon.inactive" = "#5C6370"
+
+"lapce.remote.icon" = "$black"
+"lapce.remote.local" = "#4078F2"
+"lapce.remote.connected" = "#50A14F"
+"lapce.remote.connecting" = "#C18401"
+"lapce.remote.disconnected" = "#E45649"
+
+"lapce.plugin.name" = "#DDDDDD"
+"lapce.plugin.description" = "$white"
+"lapce.plugin.author" = "#B0B0B0"
 
 "editor.background" = "$black"
 "editor.foreground" = "$white"
@@ -69,14 +102,31 @@ magenta = "#C678DD"
 "editor.caret" = "#528BFF"
 "editor.selection" = "$grey"
 "editor.current_line" = "#2C313C"
-"editor.link" = "$cyan"
+"editor.link" = "$blue"
+"editor.visible_whitespace" = "$grey"
+"editor.indent_guide" = "$grey"
+"editor.drag_drop_background" = "#79c1fc55"
+"editor.drag_drop_tab_background" = "#0b0e1455"
+"editor.sticky_header_background" = "$black"
+
+"inlay_hint.foreground" = "$white"
+"inlay_hint.background" = "#528abF37"
+
+"error_lens.error.foreground" = "$red"
+"error_lens.error.background" = "#E06C7520"
+"error_lens.warning.foreground" = "$yellow"
+"error_lens.warning.background" = "#E5C07B20"
+"error_lens.other.foreground" = "#5C6370"
+"error_lens.other.background" = "#5C637020"
 
 "source_control.added" = "#50A14F32"
 "source_control.removed" = "#FF526632"
 "source_control.modified" = "#0184BC32"
 
 "palette.background" = "#21252B"
-"palette.current" = "#2C313A"
+"palette.foreground" = "$white"
+"palette.current.background" = "#2C313A"
+"palette.current.foreground" = "$white"
 
 "completion.background" = "#21252B"
 "completion.current" = "#2C313A"
@@ -87,14 +137,25 @@ magenta = "#C678DD"
 "activity.current" = "$black"
 
 "panel.background" = "#21252B"
-"panel.current" = "#2C313A"
-"panel.hovered" = "#343A45"
+"panel.foreground" = "$white"
+"panel.foreground.dim" = "#5C6370"
+"panel.current.background" = "#2C313A"
+"panel.current.foreground" = "$white"
+"panel.current.foreground.dim" = "#5C6370"
+"panel.hovered.background" = "#343A45"
+"panel.hovered.foreground" = "$white"
+"panel.hovered.foreground.dim" = "#5C6370"
 
 "status.background" = "#21252B"
-"status.modal.normal" = "$blue"
-"status.modal.insert" = "$red"
-"status.modal.visual" = "$yellow"
-"status.modal.terminal" = "$purple"
+"status.foreground" = "$white"
+"status.modal.normal.background" = "$blue"
+"status.modal.normal.foreground" = "$black"
+"status.modal.insert.background" = "$red"
+"status.modal.insert.foreground" = "$black"
+"status.modal.visual.background" = "$yellow"
+"status.modal.visual.foreground" = "$black"
+"status.modal.terminal.background" = "$purple"
+"status.modal.terminal.foreground" = "$black"
 
 "markdown.blockquote" = "#898989"
 
diff --git a/defaults/icon-theme.toml b/defaults/icon-theme.toml
new file mode 100644
index 0000000000..a9a246377b
--- /dev/null
+++ b/defaults/icon-theme.toml
@@ -0,0 +1,12 @@
+#:schema ../extra/schemas/icon-theme.json
+
+[icon-theme]
+name = "Lapce Codicons"
+
+[icon-theme.ui]
+
+[icon-theme.foldername]
+
+[icon-theme.filename]
+
+[icon-theme.extension]
diff --git a/defaults/keymaps-common.toml b/defaults/keymaps-common.toml
index af917082a3..f480b787c0 100644
--- a/defaults/keymaps-common.toml
+++ b/defaults/keymaps-common.toml
@@ -4,6 +4,10 @@
 key = "F1"
 command = "palette.command"
 
+# [[keymaps]]
+# key = "ctrl+q"
+# command = "quit"
+
 # --------------------------------- Basic editing ---------------------------------------
 
 [[keymaps]]
@@ -26,6 +30,11 @@ key = "backspace"
 command = "delete_backward"
 mode = "i"
 
+[[keymaps]]
+key = "shift+backspace"
+command = "delete_backward"
+mode = "i"
+
 [[keymaps]]
 key = "Home"
 command = "line_start_non_blank"
@@ -55,16 +64,35 @@ command = "scroll_down"
 # ------------------------------------ Multi cursor -------------------------------------
 
 [[keymaps]]
-key = "alt+I"
+key = "alt+shift+i"
 command = "insert_cursor_end_of_line"
 mode = "i"
 
+# ----------------------------------- Editor Management -------------------------------
+
+[[keymaps]]
+key = "ctrl+tab"
+command = "next_editor_tab"
+
+[[keymaps]]
+key = "ctrl+shift+tab"
+command = "previous_editor_tab"
+
 # --------------------------------- Rich Language Editing ----------------------------
 
+[[keymaps]]
+key = "F2"
+command = "rename_symbol"
+
 [[keymaps]]
 key = "F12"
 command = "goto_definition"
 
+[[keymaps]]
+key = "g f"
+command = "show_code_actions"
+mode = "n"
+
 # ------------------------------------ Navigation -------------------------------------
 
 [[keymaps]]
@@ -108,7 +136,15 @@ mode = "i"
 [[keymaps]]
 key = "esc"
 command = "clear_search"
-when = "search_focus"
+when = "search_active || search_focus"
+
+[[keymaps]]
+key = "ctrl+shift+up"
+command = "select_next_syntax_item"
+
+[[keymaps]]
+key = "ctrl+shift+down"
+command = "select_previous_syntax_item"
 
 [[keymaps]]
 key = "ctrl+m"
@@ -135,6 +171,11 @@ key = "up"
 command = "list.previous"
 when = "list_focus"
 
+[[keymaps]]
+key = "PageUp"
+command = "list.previous_page"
+when = "list_focus"
+
 [[keymaps]]
 key = "ctrl+n"
 command = "list.next"
@@ -145,6 +186,11 @@ key = "down"
 command = "list.next"
 when = "list_focus"
 
+[[keymaps]]
+key = "PageDown"
+command = "list.next_page"
+when = "list_focus"
+
 [[keymaps]]
 key = "o"
 command = "list.expand"
@@ -222,6 +268,12 @@ command = "global_search_refresh"
 when = "global_search_focus"
 mode = "i"
 
+[[keymaps]]
+key = "enter"
+command = "confirm_rename"
+when = "rename_focus"
+mode = "i"
+
 [[keymaps]]
 key = "tab"
 command = "insert_tab"
@@ -234,19 +286,35 @@ command = "insert_new_line"
 when = "!list_focus"
 mode = "i"
 
+[[keymaps]]
+key = "alt+shift+up"
+command = "duplicate_line_up"
+mode = "i"
+
+[[keymaps]]
+key = "alt+shift+down"
+command = "duplicate_line_down"
+mode = "i"
+
 # ------------------------------------ Modal -----------------------------------------
 
 [[keymaps]]
 key = "esc"
 command = "normal_mode"
 mode = "niv"
-when = "!search_focus && !modal_focus"
+when = "!search_focus && !modal_focus && !search_active"
+
+[[keymaps]]
+key = "ctrl+c"
+command = "normal_mode"
+mode = "niv"
+when = "!search_focus && !modal_focus && !search_active"
 
 [[keymaps]]
 key = "ctrl+["
 command = "normal_mode"
 mode = "niv"
-when = "!search_focus"
+when = "!search_focus && !search_active"
 
 [[keymaps]]
 key = ":"
@@ -254,7 +322,7 @@ command = "palette.command"
 mode = "n"
 
 [[keymaps]]
-key = "G"
+key = "shift+g"
 command = "go_to_line_default_last"
 mode = "nv"
 
@@ -289,7 +357,7 @@ command = "append"
 mode = "n"
 
 [[keymaps]]
-key = "A"
+key = "shift+a"
 command = "append_end_of_line"
 mode = "n"
 
@@ -328,13 +396,23 @@ key = "g d"
 command = "goto_definition"
 mode = "n"
 
+[[keymaps]]
+key = "g h"
+command = "show_hover"
+mode = "n"
+
 [[keymaps]]
 key = "p"
 command = "paste"
 mode = "nv"
 
 [[keymaps]]
-key = "J"
+key = "shift+p"
+command = "paste_before"
+mode = "nv"
+
+[[keymaps]]
+key = "shift+j"
 command = "join_lines"
 mode = "n"
 
@@ -359,7 +437,32 @@ command = "delete_forward_and_insert"
 mode = "nv"
 
 [[keymaps]]
-key = "I"
+key = "c"
+command = "delete_forward_and_insert"
+mode = "v"
+
+[[keymaps]]
+key = "shift+s"
+command = "delete_line_and_insert"
+mode = "n"
+
+[[keymaps]]
+key = "c c"
+command = "delete_line_and_insert"
+mode = "n"
+
+[[keymaps]]
+key = "c w"
+command = "delete_word_and_insert"
+mode = "n"
+
+[[keymaps]]
+key = "c e"
+command = "delete_word_and_insert"
+mode = "n"
+
+[[keymaps]]
+key = "shift+i"
 command = "insert_first_non_blank"
 mode = "nv"
 
@@ -399,7 +502,7 @@ command = "word_backward"
 mode = "nv"
 
 [[keymaps]]
-key = "O"
+key = "shift+o"
 command = "new_line_above"
 mode = "nv"
 
@@ -449,7 +552,7 @@ command = "inline_find_right"
 mode = "nv"
 
 [[keymaps]]
-key = "F"
+key = "shift+f"
 command = "inline_find_left"
 mode = "nv"
 
@@ -489,7 +592,7 @@ command = "search_forward"
 mode = "nv"
 
 [[keymaps]]
-key = "N"
+key = "shift+n"
 command = "search_backward"
 mode = "nv"
 
@@ -524,7 +627,7 @@ command = "toggle_visual_mode"
 mode = "nv"
 
 [[keymaps]]
-key = "V"
+key = "shift+v"
 command = "toggle_linewise_visual_mode"
 mode = "nv"
 
@@ -587,3 +690,8 @@ mode = "v"
 key = "<"
 command = "outdent_line"
 mode = "v"
+
+[[keymaps]]
+key = "shift+c"
+command = "delete_to_end_and_insert"
+mode = "n"
diff --git a/defaults/keymaps-macos.toml b/defaults/keymaps-macos.toml
index 1e3a59cfbe..7b562557b3 100644
--- a/defaults/keymaps-macos.toml
+++ b/defaults/keymaps-macos.toml
@@ -1,3 +1,9 @@
+# --------------------------------- Window ---------------------------------------------
+
+[[keymaps]]
+command = "window_close"
+key = "Meta+Shift+W"
+
 # --------------------------------- General --------------------------------------------
 
 [[keymaps]]
@@ -5,7 +11,7 @@ key = "meta+p"
 command = "palette"
 
 [[keymaps]]
-key = "meta+P"
+key = "meta+shift+p"
 command = "palette.command"
 
 [[keymaps]]
@@ -21,6 +27,10 @@ command = "open_settings"
 key = "meta+k meta+s"
 command = "open_keyboard_shortcuts"
 
+# [[keymaps]]
+# key = "meta+q"
+# command = "quit"
+
 # --------------------------------- Basic editing ---------------------------------------
 
 [[keymaps]]
@@ -28,7 +38,11 @@ key = "meta+z"
 command = "undo"
 
 [[keymaps]]
-key = "meta+Z"
+key = "meta+shift+z"
+command = "redo"
+
+[[keymaps]]
+key = "meta+y"
 command = "redo"
 
 [[keymaps]]
@@ -67,51 +81,71 @@ key = "meta+right"
 command = "line_end"
 mode = "i"
 
-[[keymaps]]
-key = "alt+backspace"
-command = "delete_word_backward"
+[[keymaps]]
+key = "ctrl+a"
+command = "line_start_non_blank"
+mode = "i"
+
+[[keymaps]]
+key = "ctrl+e"
+command = "line_end"
+mode = "i"
+
+[[keymaps]]
+key = "meta+shift+k"
+command = "delete_line"
+mode = "i"
+
+[[keymaps]]
+key = "alt+backspace"
+command = "delete_word_backward"
+mode = "i"
+
+[[keymaps]]
+key = "meta+backspace"
+command = "delete_to_beginning_of_line"
 mode = "i"
 
-[[keymaps]]
-key = "meta+backspace"
-command = "delete_to_beginning_of_line"
+[[keymaps]]
+key = "ctrl+k"
+command = "delete_to_end_of_line"
 mode = "i"
 
-[[keymaps]]
-key = "alt+delete"
-command = "delete_word_forward"
+[[keymaps]]
+key = "alt+delete"
+command = "delete_word_forward"
 mode = "i"
 
-[[keymaps]]
-key = "meta+|"
-command = "match_pairs"
+[[keymaps]]
+key = "meta+|"
+command = "match_pairs"
 mode = "i"
 
-[[keymaps]]
-key = "meta+/"
-command = "toggle_line_comment"
+[[keymaps]]
+key = "meta+/"
+command = "toggle_line_comment"
 
-[[keymaps]]
-key = "meta+]"
-command = "indent_line"
+[[keymaps]]
+key = "meta+]"
+command = "indent_line"
 
-[[keymaps]]
-key = "meta+["
-command = "outdent_line"
+[[keymaps]]
+key = "meta+["
+command = "outdent_line"
 
-[[keymaps]]
-key = "meta+a"
-command = "select_all"
+[[keymaps]]
+key = "meta+a"
+command = "select_all"
 
-[[keymaps]]
+[[keymaps]]
 key = "meta+enter"
 command = "new_line_below"
-mode = "i"
+mode = "i"
 
-[[keymaps]]
+[[keymaps]]
 key = "meta+shift+enter"
 command = "new_line_above"
-mode = "i"
+mode = "i"
 
 # ------------------------------------ Multi cursor -------------------------------------
 
@@ -131,7 +165,7 @@ command = "select_current_line"
 mode = "i"
 
 [[keymaps]]
-key = "meta+L"
+key = "meta+shift+l"
 command = "select_all_current"
 mode = "i"
 
@@ -190,6 +224,11 @@ key = "meta+i"
 command = "get_completion"
 mode = "i"
 
+[[keymaps]]
+key = "ctrl+shift+space"
+command = "get_signature"
+mode = "i"
+
 [[keymaps]]
 key = "meta+."
 command = "show_code_actions"
@@ -197,19 +236,19 @@ command = "show_code_actions"
 # --------------------------------- Display -------------------------------------------
 
 [[keymaps]]
-key = "meta+E"
+key = "meta+shift+e"
 command = "toggle_file_explorer_focus"
 
 [[keymaps]]
-key = "meta+F"
+key = "meta+shift+f"
 command = "toggle_search_focus"
 
 [[keymaps]]
-key = "meta+X"
+key = "meta+shift+x"
 command = "toggle_plugin_focus"
 
 [[keymaps]]
-key = "meta+M"
+key = "meta+shift+m"
 command = "toggle_problem_focus"
 
 # ------------------------------------ Navigation -------------------------------------
@@ -223,9 +262,13 @@ key = "meta+down"
 command = "document_end"
 
 [[keymaps]]
-key = "meta+O"
+key = "meta+shift+o"
 command = "palette.symbol"
 
+[[keymaps]]
+key = "meta+t"
+command = "palette.workspace_symbol"
+
 [[keymaps]]
 key = "ctrl+g"
 command = "palette.line"
diff --git a/defaults/keymaps-nonmacos.toml b/defaults/keymaps-nonmacos.toml
index a291b90ffd..b89b3389e1 100644
--- a/defaults/keymaps-nonmacos.toml
+++ b/defaults/keymaps-nonmacos.toml
@@ -1,3 +1,9 @@
+# --------------------------------- Window ---------------------------------------------
+
+[[keymaps]]
+command = "close_window"
+key = "Alt+F4"
+
 # --------------------------------- General --------------------------------------------
 
 [[keymaps]]
@@ -5,7 +11,7 @@ key = "ctrl+p"
 command = "palette"
 
 [[keymaps]]
-key = "Ctrl+P"
+key = "ctrl+shift+p"
 command = "palette.command"
 
 [[keymaps]]
@@ -21,6 +27,18 @@ command = "open_settings"
 key = "ctrl+k ctrl+s"
 command = "open_keyboard_shortcuts"
 
+# --------------------------------- Terminal copy/paste ---------------------------------
+
+[[keymaps]]
+key = "ctrl+shift+c"
+command = "clipboard_copy"
+mode = "t"
+
+[[keymaps]]
+key = "ctrl+shift+v"
+command = "clipboard_paste"
+mode = "t"
+
 # --------------------------------- Basic editing ---------------------------------------
 
 [[keymaps]]
@@ -29,7 +47,13 @@ command = "undo"
 mode = "i"
 
 [[keymaps]]
-key = "ctrl+Z"
+key = "ctrl+shift+z"
+command = "redo"
+mode = "i"
+
+
+[[keymaps]]
+key = "ctrl+y"
 command = "redo"
 mode = "i"
 
@@ -38,16 +62,31 @@ key = "ctrl+x"
 command = "clipboard_cut"
 mode = "i"
 
+[[keymaps]]
+key = "shift+Delete"
+command = "clipboard_cut"
+mode = "i"
+
 [[keymaps]]
 key = "ctrl+c"
 command = "clipboard_copy"
 mode = "i"
 
+[[keymaps]]
+key = "ctrl+insert"
+command = "clipboard_copy"
+mode = "i"
+
 [[keymaps]]
 key = "ctrl+v"
 command = "clipboard_paste"
 mode = "i"
 
+[[keymaps]]
+key = "shift+insert"
+command = "clipboard_paste"
+mode = "i"
+
 [[keymaps]]
 key = "ctrl+f"
 command = "search"
@@ -62,46 +101,51 @@ key = "ctrl+left"
 command = "word_backward"
 mode = "i"
 
-[[keymaps]]
-key = "ctrl+backspace"
-command = "delete_word_backward"
+[[keymaps]]
+key = "ctrl+backspace"
+command = "delete_word_backward"
 mode = "i"
 
-[[keymaps]]
-key = "ctrl+delete"
-command = "delete_word_forward"
+[[keymaps]]
+key = "ctrl+delete"
+command = "delete_word_forward"
 mode = "i"
 
-[[keymaps]]
-key = "ctrl+|"
-command = "match_pairs"
+[[keymaps]]
+key = "shift+delete"
+command = "delete_line"
 mode = "i"
 
-[[keymaps]]
-key = "ctrl+/"
-command = "toggle_line_comment"
+[[keymaps]]
+key = "ctrl+|"
+command = "match_pairs"
+mode = "i"
 
-[[keymaps]]
-key = "ctrl+]"
-command = "indent_line"
+[[keymaps]]
+key = "ctrl+/"
+command = "toggle_line_comment"
 
-[[keymaps]]
-key = "ctrl+["
-command = "outdent_line"
+[[keymaps]]
+key = "ctrl+]"
+command = "indent_line"
 
-[[keymaps]]
-key = "ctrl+a"
-command = "select_all"
+[[keymaps]]
+key = "ctrl+["
+command = "outdent_line"
 
-[[keymaps]]
+[[keymaps]]
+key = "ctrl+a"
+command = "select_all"
+
+[[keymaps]]
 key = "ctrl+enter"
 command = "new_line_below"
-mode = "i"
+mode = "i"
 
-[[keymaps]]
+[[keymaps]]
 key = "ctrl+shift+enter"
 command = "new_line_above"
-mode = "i"
+mode = "i"
 
 # ------------------------------------ Multi cursor -------------------------------------
 
@@ -121,7 +165,7 @@ command = "select_current_line"
 mode = "i"
 
 [[keymaps]]
-key = "ctrl+L"
+key = "ctrl+shift+l"
 command = "select_all_current"
 mode = "i"
 
@@ -185,6 +229,11 @@ key = "ctrl+i"
 command = "get_completion"
 mode = "i"
 
+[[keymaps]]
+key = "ctrl+shift+space"
+command = "get_signature"
+mode = "i"
+
 [[keymaps]]
 key = "ctrl+."
 command = "show_code_actions"
@@ -192,19 +241,19 @@ command = "show_code_actions"
 # --------------------------------- Display -------------------------------------------
 
 [[keymaps]]
-key = "ctrl+E"
+key = "ctrl+shift+e"
 command = "toggle_file_explorer_focus"
 
 [[keymaps]]
-key = "ctrl+F"
+key = "ctrl+shift+f"
 command = "toggle_search_focus"
 
 [[keymaps]]
-key = "ctrl+X"
+key = "ctrl+shift+x"
 command = "toggle_plugin_focus"
 
 [[keymaps]]
-key = "ctrl+M"
+key = "ctrl+shift+m"
 command = "toggle_problem_focus"
 
 # ------------------------------------ Navigation -------------------------------------
@@ -218,9 +267,13 @@ key = "Ctrl+End"
 command = "document_end"
 
 [[keymaps]]
-key = "ctrl+O"
+key = "ctrl+shift+o"
 command = "palette.symbol"
 
+[[keymaps]]
+key = "ctrl+t"
+command = "palette.workspace_symbol"
+
 [[keymaps]]
 key = "ctrl+g"
 command = "palette.line"
diff --git a/defaults/light-theme.toml b/defaults/light-theme.toml
index 3d5520f71a..c5196e2acf 100644
--- a/defaults/light-theme.toml
+++ b/defaults/light-theme.toml
@@ -1,4 +1,6 @@
-[theme]
+#:schema ../extra/schemas/color-theme.json
+
+[color-theme]
 name = "Lapce Light"
 
 [ui]
@@ -11,22 +13,21 @@ activity-width = 50
 scroll-width = 10
 drop-shadow-width = 0
 
-[theme.base]
-white = "#FAFAFA"
+[color-theme.base]
 black = "#383A42"
-grey = "#E5E5E6"
-light_grey = "#F2F2F2"
 blue = "#4078F2"
-red = "#E45649"
-yellow = "#C18401"
-green = "#50A14F"
-purple = "#A626A4"
 cyan = "#0184BC"
+green = "#50A14F"
+grey = "#E5E5E6"
 magenta = "#A626A4"
+orange = "#D19A66"
+purple = "#A626A4"
+red = "#E45649"
+white = "#FAFAFA"
+yellow = "#C18401"
 
-[theme.syntax]
+[color-theme.syntax]
 "comment" = "#A0A1A7"
-
 "constant" = "$yellow"
 "type" = "$yellow"
 "typeAlias" = "$yellow"
@@ -49,24 +50,57 @@ magenta = "#A626A4"
 "property" = "$red"
 "enumMember" = "$red"
 "enum-member" = "$red"
-"variable.other.member" = "$red"
 
 "string" = "$green"
+"string.escape" = "$cyan"
 
 "type.builtin" = "$cyan"
 "builtinType" = "$cyan"
 "escape" = "$cyan"
 "embedded" = "$cyan"
 
-[theme.ui]
-"lapce.active_tab" = "$white"
-"lapce.inactive_tab" = "$grey"
+"punctuation.delimiter" = "$yellow"
+"text.title" = "$orange"
+"text.uri" = "$cyan"
+"text.reference" = "$yellow"
+"variable" = "$red"
+"variable.other.member" = "$green"
+"tag" = "$blue"
+
+[color-theme.ui]
 "lapce.error" = "#E51400"
 "lapce.warn" = "#E9A700"
 "lapce.dropdown_shadow" = "#B4B4B4"
 "lapce.border" = "#B4B4B4"
 "lapce.scroll_bar" = "#B4B4B4"
 
+"lapce.button.primary.background" = "#50a14f"
+"lapce.button.primary.foreground" = "$white"
+
+# tab
+"lapce.tab.active.background" = "$white"
+"lapce.tab.active.foreground" = "$black"
+"lapce.tab.active.underline" = "#528BFF"
+
+"lapce.tab.inactive.background" = "#EAEAEB"
+"lapce.tab.inactive.foreground" = "$black"
+"lapce.tab.inactive.underline" = "#528BFF77"
+
+"lapce.tab.separator" = "#B4B4B4"
+
+"lapce.icon.active" = "$black"
+"lapce.icon.inactive" = "#A0A1A7"
+
+"lapce.remote.icon" = "$white"
+"lapce.remote.local" = "#4078F2"
+"lapce.remote.connected" = "#50A14F"
+"lapce.remote.connecting" = "#C18401"
+"lapce.remote.disconnected" = "#E45649"
+
+"lapce.plugin.name" = "#444444"
+"lapce.plugin.description" = "$black"
+"lapce.plugin.author" = "#707070"
+
 "terminal.cursor" = "$black"
 "terminal.foreground" = "$black"
 "terminal.background" = "$white"
@@ -94,14 +128,31 @@ magenta = "#A626A4"
 "editor.caret" = "#526FFF"
 "editor.selection" = "$grey"
 "editor.current_line" = "#F2F2F2"
-"editor.link" = "$cyan"
+"editor.link" = "$blue"
+"editor.visible_whitespace" = "$grey"
+"editor.indent_guide" = "$grey"
+"editor.drag_drop_background" = "#79c1fc33"
+"editor.drag_drop_tab_background" = "#0b0e1433"
+"editor.sticky_header_background" = "$white"
+
+"inlay_hint.foreground" = "$black"
+"inlay_hint.background" = "#528bFF55"
+
+"error_lens.error.foreground" = "$red"
+"error_lens.error.background" = "#E4564920"
+"error_lens.warning.foreground" = "$yellow"
+"error_lens.warning.background" = "#C1840120"
+"error_lens.other.foreground" = "#A0A1A7"
+"error_lens.other.background" = "#A0A1A720"
 
 "source_control.added" = "#50A14F32"
 "source_control.removed" = "#FF526632"
 "source_control.modified" = "#0184BC32"
 
 "palette.background" = "#EAEAEB"
-"palette.current" = "#DBDBDC"
+"palette.foreground" = "$black"
+"palette.current.background" = "#DBDBDC"
+"palette.current.foreground" = "$black"
 
 "completion.background" = "#EAEAEB"
 "completion.current" = "#DBDBDC"
@@ -112,13 +163,24 @@ magenta = "#A626A4"
 "activity.current" = "$white"
 
 "panel.background" = "#EAEAEB"
-"panel.current" = "#DBDBDC"
-"panel.hovered" = "#E4E4E6"
+"panel.foreground" = "$black"
+"panel.foreground.dim" = "#A0A1A7"
+"panel.current.background" = "#DBDBDC"
+"panel.current.foreground" = "$black"
+"panel.current.foreground.dim" = "#A0A1A7"
+"panel.hovered.background" = "#E4E4E6"
+"panel.hovered.foreground" = "$black"
+"panel.hovered.foreground.dim" = "#A0A1A7"
 
 "status.background" = "#EAEAEB"
-"status.modal.normal" = "$blue"
-"status.modal.insert" = "$red"
-"status.modal.visual" = "$yellow"
-"status.modal.terminal" = "$purple"
+"status.foreground" = "$black"
+"status.modal.normal.background" = "$blue"
+"status.modal.normal.foreground" = "$white"
+"status.modal.insert.background" = "$red"
+"status.modal.insert.foreground" = "$white"
+"status.modal.visual.background" = "$yellow"
+"status.modal.visual.foreground" = "$white"
+"status.modal.terminal.background" = "$purple"
+"status.modal.terminal.foreground" = "$white"
 
 "markdown.blockquote" = "#686868"
diff --git a/defaults/settings.toml b/defaults/settings.toml
index cd1e772f63..611335419d 100644
--- a/defaults/settings.toml
+++ b/defaults/settings.toml
@@ -1,19 +1,53 @@
-[lapce]
+#:schema ../extra/schemas/settings.json
+
+[core]
 modal = false
 color-theme = "Lapce Dark"
-icon-theme = ""
+icon-theme = "Lapce Codicons"
+custom-titlebar = true
 
 [editor]
 font-family = "Cascadia Code"
 font-size = 13
 code-lens-font-size = 2
-line-height = 25
+line-height = 1.5
 tab-width = 4
 show-tab = true
+show-bread-crumbs = true
 scroll-beyond-last-line = true
-hover-delay = 300             # ms
+cursor-surrounding-lines = 1
+sticky-header = true
+completion-show-documentation = true
+show-signature = true
+signature-label-code-block = true
+auto-closing-matching-pairs = true
+hover-delay = 300                       # ms
 modal-mode-relative-line-numbers = true
-format-on-save = true
+format-on-save = false
+highlight-matching-brackets = true
+highlight-scope-lines = false
+autosave-interval = 0
+format-on-autosave = true
+enable-inlay-hints = true
+inlay-hint-font-family = ""
+inlay-hint-font-size = 0
+enable-error-lens = true
+error-lens-end-of-line = true
+error-lens-font-family = ""
+error-lens-font-size = 0
+enable-completion-lens = false
+completion-lens-font-family = ""
+completion-lens-font-size = 0
+blink-interval = 500                    # ms
+multicursor-case-sensitive = true
+multicursor-whole-words = true
+render-whitespace = "none"
+show-indent-guide = true
+atomic-soft-tabs = false
+double-click = "single"
+move-focus-while-search = true
+diff-context-lines=3
+scroll-speed-modifier=1
 
 [terminal]
 font-family = ""
@@ -24,17 +58,22 @@ shell = ""
 [ui]
 font-family = ""
 font-size = 13
+icon-size = 0
 header-height = 35
 status-height = 25
 tab-min-width = 100
-activity-width = 50
 scroll-width = 10
 drop-shadow-width = 0
+preview-editor-width = 0
+hover-font-family = ""
+hover-font-size = 0
+trim-search-results-whitespace = true
+list-line-height = 25
 
-[theme]
+[color-theme]
 name = ""
 
-[theme.base]
+[color-theme.base]
 white = "#ABB2BF"
 black = "#282C34"
 grey = "#3E4451"
@@ -47,7 +86,7 @@ purple = "#C678DD"
 cyan = "#56B6C2"
 magenta = "#C678DD"
 
-[theme.syntax]
+[color-theme.syntax]
 "comment" = "#5C6370"
 "constant" = "$yellow"
 "type" = "$yellow"
@@ -63,6 +102,7 @@ magenta = "#C678DD"
 "method" = "$blue"
 "function.method" = "$blue"
 "keyword" = "$purple"
+"keyword.control" = "$purple"
 "selfKeyword" = "$purple"
 "field" = "$red"
 "property" = "$red"
@@ -74,16 +114,42 @@ magenta = "#C678DD"
 "builtinType" = "$cyan"
 "escape" = "$cyan"
 "embedded" = "$cyan"
+"symbol" = "$yellow"
 
-[theme.ui]
-"lapce.active_tab" = "$black"
-"lapce.inactive_tab" = "$grey"
+[color-theme.ui]
 "lapce.error" = "$red"
 "lapce.warn" = "$yellow"
 "lapce.dropdown_shadow" = "#000000"
 "lapce.border" = "#000000"
 "lapce.scroll_bar" = "$grey"
 
+"lapce.button.primary.background" = "#50a14f"
+"lapce.button.primary.foreground" = "$black"
+
+# tab
+"lapce.tab.active.background" = "$black"
+"lapce.tab.active.foreground" = "$white"
+"lapce.tab.active.underline" = "#528BFF"
+
+"lapce.tab.inactive.background" = "#21252b"
+"lapce.tab.inactive.foreground" = "$white"
+"lapce.tab.inactive.underline" = "#528BFF77"
+
+"lapce.tab.separator" = "#000000"
+
+"lapce.icon.active" = "$white"
+"lapce.icon.inactive" = "#5C6370"
+
+"lapce.remote.icon" = "$black"
+"lapce.remote.local" = "#4078F2"
+"lapce.remote.connected" = "#50A14F"
+"lapce.remote.connecting" = "#C18401"
+"lapce.remote.disconnected" = "#E45649"
+
+"lapce.plugin.name" = "#DDDDDD"
+"lapce.plugin.description" = "$white"
+"lapce.plugin.author" = "#B0B0B0"
+
 "editor.background" = "$black"
 "editor.foreground" = "$white"
 "editor.dim" = "#5C6370"
@@ -91,14 +157,33 @@ magenta = "#C678DD"
 "editor.caret" = "#528bFF"
 "editor.selection" = "$grey"
 "editor.current_line" = "#2C313C"
-"editor.link" = "$cyan"
+"editor.link" = "$blue"
+"editor.visible_whitespace" = "#5C6370"
+"editor.indent_guide" = "$grey"
+"editor.drag_drop_background" = "#79c1fc55"
+"editor.drag_drop_tab_background" = "#0b0e1455"
+"editor.sticky_header_background" = "$black"
+
+"inlay_hint.foreground" = "$white"
+"inlay_hint.background" = "#528bFF88"
+
+"error_lens.error.foreground" = "$red"
+"error_lens.error.background" = "#E06C7520"
+"error_lens.warning.foreground" = "$yellow"
+"error_lens.warning.background" = "#E5C07B20"
+"error_lens.other.foreground" = "#5C6370"
+"error_lens.other.background" = "#5C637020"
+
+"completion_lens.foreground" = "#5C6370"
 
 "source_control.added" = "#50A14F32"
 "source_control.removed" = "#FF526632"
 "source_control.modified" = "#0184BC32"
 
 "palette.background" = "#21252B"
-"palette.current" = "#2C313A"
+"palette.foreground" = "$white"
+"palette.current.background" = "#2C313A"
+"palette.current.foreground" = "$white"
 
 "completion.background" = "#21252B"
 "completion.current" = "#2C313A"
@@ -109,14 +194,25 @@ magenta = "#C678DD"
 "activity.current" = "$black"
 
 "panel.background" = "#21252B"
-"panel.current" = "#2C313A"
-"panel.hovered" = "#343A45"
+"panel.foreground" = "$white"
+"panel.foreground.dim" = "#5C6370"
+"panel.current.background" = "#2C313A"
+"panel.current.foreground" = "$white"
+"panel.current.foreground.dim" = "#5C6370"
+"panel.hovered.background" = "#343A45"
+"panel.hovered.foreground" = "$white"
+"panel.hovered.foreground.dim" = "#5C6370"
 
 "status.background" = "#21252B"
-"status.modal.normal" = "$blue"
-"status.modal.insert" = "$red"
-"status.modal.visual" = "$yellow"
-"status.modal.terminal" = "$purple"
+"status.foreground" = "$white"
+"status.modal.normal.background" = "$blue"
+"status.modal.normal.foreground" = "$black"
+"status.modal.insert.background" = "$red"
+"status.modal.insert.foreground" = "$black"
+"status.modal.visual.background" = "$yellow"
+"status.modal.visual.foreground" = "$black"
+"status.modal.terminal.background" = "$purple"
+"status.modal.terminal.foreground" = "$black"
 
 "markdown.blockquote" = "#898989"
 
@@ -139,3 +235,122 @@ magenta = "#C678DD"
 "terminal.bright_cyan" = "$cyan"
 "terminal.bright_magenta" = "$magenta"
 "terminal.bright_black" = "#545862"
+
+[icon-theme]
+name = ""
+
+[icon-theme.ui]
+"logo" = "lapce_logo.svg"
+"link" = "link.svg"
+"error" = "error.svg"
+"add" = "add.svg"
+"close" = "close.svg"
+"remote" = "lapce_remote.svg"
+"unsaved" = "circle-filled.svg"
+"warning" = "warning.svg"
+"problem" = "problem.svg"
+"settings" = "settings-gear.svg"
+"terminal" = "terminal.svg"
+"lightbulb" = "lightbulb.svg"
+"extensions" = "extensions.svg"
+"breadcrumb_separator" = "chevron-right.svg"
+
+"window.close" = "chrome-close.svg"
+"window.restore" = "chrome-restore.svg"
+"window.maximize" = "chrome-maximize.svg"
+"window.minimize" = "chrome-minimize.svg"
+
+"file" = "file.svg"
+"file_explorer" = "files.svg"
+"file_picker_up" = "arrow-up.svg"
+
+"image_loading" = "refresh.svg"
+"image_error" = "error.svg"
+
+"scm.icon" = "source-control.svg"
+"scm.diff.modified" = "diff-modified.svg"
+"scm.diff.added" = "diff-added.svg"
+"scm.diff.removed" = "diff-removed.svg"
+"scm.diff.renamed" = "diff-renamed.svg"
+"scm.change.add" = "add.svg"
+"scm.change.remove" = "remove.svg"
+
+"palette.menu" = "chevron-down.svg"
+
+"dropdown.arrow" = "chevron-down.svg"
+
+"location.forward" = "arrow-right.svg"
+"location.backward" = "arrow-left.svg"
+
+"item.opened" = "chevron-down.svg"
+"item.closed" = "chevron-right.svg"
+
+"directory.closed" = "folder.svg"
+"directory.opened" = "folder-opened.svg"
+
+"panel.restore" = "chevron-down.svg"
+"panel.maximise" = "chevron-right.svg"
+
+"split.horizontal" = "split-horizontal.svg"
+
+"tab.previous" = "chevron-left.svg"
+"tab.next" = "chevron-right.svg"
+
+"sidebar.left.on" = "layout-sidebar-left.svg"
+"sidebar.left.off" = "layout-sidebar-left-off.svg"
+"sidebar.right.on" = "layout-sidebar-right.svg"
+"sidebar.right.off" = "layout-sidebar-right-off.svg"
+
+"layout.panel.on" = "layout-panel.svg"
+"layout.panel.off" = "layout-panel-off.svg"
+
+"search.icon" = "search.svg"
+"search.clear" = "close.svg"
+"search.forward" = "arrow-down.svg"
+"search.backward" = "arrow-up.svg"
+"search.case_sensitive" = "case-sensitive.svg"
+
+"symbol_kind.array" = "symbol-array.svg"
+"symbol_kind.boolean" = "symbol-boolean.svg"
+"symbol_kind.class" = "symbol-class.svg"
+"symbol_kind.constant" = "symbol-constant.svg"
+"symbol_kind.enum_member" = "symbol-enum-member.svg"
+"symbol_kind.enum" = "symbol-enum.svg"
+"symbol_kind.event" = "symbol-event.svg"
+"symbol_kind.field" = "symbol-field.svg"
+"symbol_kind.file" = "symbol-file.svg"
+"symbol_kind.function" = "symbol-method.svg"
+"symbol_kind.interface" = "symbol-interface.svg"
+"symbol_kind.key" = "symbol-key.svg"
+"symbol_kind.method" = "symbol-method.svg"
+"symbol_kind.namespace" = "symbol-namespace.svg"
+"symbol_kind.number" = "symbol-numeric.svg"
+"symbol_kind.object" = "symbol-namespace.svg"
+"symbol_kind.operator" = "symbol-operator.svg"
+"symbol_kind.property" = "symbol-property.svg"
+"symbol_kind.string" = "symbol-string.svg"
+"symbol_kind.struct" = "symbol-structure.svg"
+"symbol_kind.type_parameter" = "symbol-parameter.svg"
+"symbol_kind.variable" = "symbol-variable.svg"
+
+"completion_item_kind.class" = "symbol-class.svg"
+"completion_item_kind.constant" = "symbol-constant.svg"
+"completion_item_kind.enum_member" = "symbol-enum-member.svg"
+"completion_item_kind.enum" = "symbol-enum.svg"
+"completion_item_kind.field" = "symbol-field.svg"
+"completion_item_kind.function" = "symbol-method.svg"
+"completion_item_kind.interface" = "symbol-interface.svg"
+"completion_item_kind.keyword" = "symbol-keyword.svg"
+"completion_item_kind.method" = "symbol-method.svg"
+"completion_item_kind.module" = "symbol-namespace.svg"
+"completion_item_kind.property" = "symbol-property.svg"
+"completion_item_kind.snippet" = "symbol-snippet.svg"
+"completion_item_kind.string" = "symbol-string.svg"
+"completion_item_kind.struct" = "symbol-structure.svg"
+"completion_item_kind.variable" = "symbol-variable.svg"
+
+[icon-theme.foldername]
+
+[icon-theme.filename]
+
+[icon-theme.extension]
diff --git a/docs/building-from-source.md b/docs/building-from-source.md
new file mode 100644
index 0000000000..72e5aa7ce0
--- /dev/null
+++ b/docs/building-from-source.md
@@ -0,0 +1,34 @@
+## Building from source
+
+It is easy to build Lapce from source on a GNU/Linux distribution. Cargo handles the build process, all you need to do, is ensure the correct dependencies are installed.
+
+1. Install the Rust compiler and Cargo using [`rustup.rs`](https://rustup.rs/). If you already have the toolchain, ensure you are using version 1.64 or higher.
+
+2. Install dependencies for your operating system:
+
+#### Ubuntu
+```sh
+sudo apt install cmake pkg-config libfontconfig-dev libgtk-3-dev g++
+```
+#### Fedora
+```sh
+sudo dnf install gcc-c++ perl-FindBin perl-File-Compare gtk3-devel
+```
+
+3. Clone this repository (this command will clone to your home directory):
+```sh
+git clone https://github.com/lapce/lapce.git ~/lapce
+```
+
+4. `cd` into the repository, and run the build command with the release flag
+```sh
+cd ~/lapce
+```
+
+```sh
+cargo build --release
+```
+
+> If you use a different distribution, and are having trouble finding appropriate dependencies, let us know in an issue!
+
+Once Lapce is compiled, the executable will be available in `target/release/lapce`.
diff --git a/docs/installing-with-package-manager.md b/docs/installing-with-package-manager.md
new file mode 100644
index 0000000000..1f82b3afb5
--- /dev/null
+++ b/docs/installing-with-package-manager.md
@@ -0,0 +1,43 @@
+## Installation With Package Manager
+
+### Arch Linux
+
+There is an community package that can be installed with `pacman`:
+
+```bash
+sudo pacman -Syu lapce
+```
+
+### Fedora
+```bash
+sudo dnf copr enable titaniumtown/lapce
+sudo dnf install lapce
+```
+
+### Flatpak
+
+Lapce is available as a flatpak [here](https://flathub.org/apps/details/dev.lapce.lapce)
+
+```bash
+flatpak install flathub dev.lapce.lapce
+```
+
+### Homebrew
+
+```bash
+brew install lapce
+```
+
+### Scoop
+
+```bash
+scoop install lapce
+```
+
+### winget
+
+You can find the packages [here](https://github.com/microsoft/winget-pkgs/tree/master/manifests/l/Lapce/Lapce):
+
+```bash
+winget install lapce
+```
diff --git a/docs/new-contributor-guide-developer.md b/docs/new-contributor-guide-developer.md
index 46d536e499..59c3d9a34b 100644
--- a/docs/new-contributor-guide-developer.md
+++ b/docs/new-contributor-guide-developer.md
@@ -4,7 +4,7 @@ This document contains some useful resources for anyone wishing to contribute to
 
 ## Quick Start
 
-1. Get an overview of the architecture from [`docs/why-lapce.md`](why-lapce.md).
+1. Get an overview of the architecture from [`docs/why-lapce.md`](why-lapce.md) and [Architecture](https://docs.lapce.dev/development/architecture).
 
 2. Explore the rope data structure, a key part of Lapce's architecture. The crate used is [xi_rope](https://crates.io/crates/xi-rope).
 
@@ -16,8 +16,8 @@ This document contains some useful resources for anyone wishing to contribute to
 
 ## Resources
 
-The [Wikipedia article on ropes](https://citeseer.ist.psu.edu/viewdoc/download?doi=10.1.1.14.9450&rep=rep1&type=pdf) provides an overview of the data structure.
+The [Wikipedia article on ropes](https://en.wikipedia.org/wiki/Rope_(data_structure)) provides an overview of the data structure.
 
-For some context, also see [Ropes: an Alternative to Strings](https://citeseer.ist.psu.edu/viewdoc/download?doi=10.1.1.14.9450&rep=rep1&type=pdf) by Boehm, Atkinson, and Plass.
+For some context, also see [Ropes: an Alternative to Strings](https://www.cs.tufts.edu/comp/150FP/archive/hans-boehm/ropes.pdf) by Boehm, Atkinson, and Plass.
 
 
diff --git a/docs/why-lapce.md b/docs/why-lapce.md
index 17a4dd345b..8ecfa5c6b6 100644
--- a/docs/why-lapce.md
+++ b/docs/why-lapce.md
@@ -1,23 +1,23 @@
-I'm a Vim fan. After years of using it, I started to customize it like everybody else. I thought I had something that worked quite well until I hit one problem. My linter sometimes took seconds to check the code, and it would freeze Vim because Vim didn't have asynchronous support. I looked around; I found NeoVim and problem solved. Happy days.
-
-But there was always this one thing I couldn't solve. I want to make Vim pretty. I tried all kinds of themes. Tried all kinds of status bar plugins with icons in it. File explorers with file icons in them. But no, I also wanted a 1px vertical split bar, not the thick colored one or the dashed line drawn with pipe characters. After hours and hours of search, it occurred to me that it's impossible to do. Again NeoVim was the savior. It introduced external UI. The idea was that NeoVim splits the UI and the backend. The backend emits events to the UI, and the UI draws them. I couldn't wait to try it out with writing a UI in Electron, with the hope that I could solve my vertical split bar dream. But I didn't because it emits the drawing events treating it as a whole canvas, and I don't get the boundary of each splits. I started to hack NeoVim code. I made it to emit split sizes and positions, and I finally can draw the bars in the UI. With joy, I also looked at emits the command modes to the UI, so I could put the command in the middle of the window. And then echo messages, status line, etc. I pushed a PR for the hacky solution(https://github.com/neovim/neovim/pull/5686). Then I hit performance issues in Electron because Javascript was not fast enough to deserialize the drawing events from NeoVim. So I wrote another UI in Go with Qt binding(https://github.com/dzhou121/gonvim).
-
-I wanted to external more and more components in NeoVim, but I found it harder and harder, and I spotted Xi-Editor. I started to write a UI for it straightaway. Creating a code editor with Vim editing experience was the plan. There were things missing that I had to add in Xi. And working on it was so much easier because Xi was built to be the UI/backend architecture without the heritage(burden) of (Neo)Vim.
-
-Then one day, I experienced VSCode's remote development feature, and it felt so "local". I wanted to add the feature to my code editor. Then I realized that it can't be done with NeoVim or Xi's UI/backend architecture. The reason was that (Neo)Vim/Xi backends are the editing engine, so when you put the backend to a remote machine, every keyboard input needs to be sent to it, and the backend emits the drawing events to you, which will include the network latency in everything you type. That wouldn't work. The editing logic must be tightly bound with the UI to give the best editing experience.
-
-So the new architecture I came up with was like this:
-
-    UI
-Reads file from Proxy<br>
-Handle keyboard/mouse events and do the edits on the file buffer<br>
-Send the file editing delta to the proxy to keep the file in sync<br>
-
-	 Proxy
-Receive save event from UI and flush the file buffer to disk<br>
-proxy the events between UI and the plugins<br>
-
-	Plugin
-Communicate with UI through proxy<br>
-
-UI sits locally. Proxy and Plugin will be in the remote box when doing remote development. With this architecture, I can make sure the editing experience is always the best, with other considerations like syntax highlighting being done in a different thread, so nothing blocks the main thread at any time. I finally had a lightning-fast and powerful code editor. (which can be beautiful as well)
+I'm a Vim fan. After years of using it, I started to customize it like everybody else. I thought I had something that worked quite well until I hit one problem. My linter sometimes took seconds to check the code, and it would freeze Vim because Vim didn't have asynchronous support. I looked around; I found NeoVim and problem solved. Happy days.
+
+But there was always this one thing I couldn't solve. I want to make Vim pretty. I tried all kinds of themes. Tried all kinds of status bar plugins with icons in it. File explorers with file icons in them. But no, I also wanted a 1px vertical split bar, not the thick colored one or the dashed line drawn with pipe characters. After hours and hours of search, it occurred to me that it's impossible to do. Again NeoVim was the savior. It introduced external UI. The idea was that NeoVim splits the UI and the backend. The backend emits events to the UI, and the UI draws them. I couldn't wait to try it out with writing a UI in Electron, with the hope that I could solve my vertical split bar dream. But I didn't because it emits the drawing events treating it as a whole canvas, and I don't get the boundary of each splits. I started to hack NeoVim code. I made it to emit split sizes and positions, and I finally can draw the bars in the UI. With joy, I also looked at emits the command modes to the UI, so I could put the command in the middle of the window. And then echo messages, status line, etc. I pushed a PR for the hacky solution(https://github.com/neovim/neovim/pull/5686). Then I hit performance issues in Electron because Javascript was not fast enough to deserialize the drawing events from NeoVim. So I wrote another UI in Go with Qt binding(https://github.com/dzhou121/gonvim).
+
+I wanted to external more and more components in NeoVim, but I found it harder and harder, and I spotted Xi-Editor. I started to write a UI for it straightaway. Creating a code editor with Vim editing experience was the plan. There were things missing that I had to add in Xi. And working on it was so much easier because Xi was built to be the UI/backend architecture without the heritage(burden) of (Neo)Vim.
+
+Then one day, I experienced VSCode's remote development feature, and it felt so "local". I wanted to add the feature to my code editor. Then I realized that it can't be done with NeoVim or Xi's UI/backend architecture. The reason was that (Neo)Vim/Xi backends are the editing engine, so when you put the backend to a remote machine, every keyboard input needs to be sent to it, and the backend emits the drawing events to you, which will include the network latency in everything you type. That wouldn't work. The editing logic must be tightly bound with the UI to give the best editing experience.
+
+So the new architecture I came up with was like this:
+
+    UI
+Reads file from Proxy<br>
+Handle keyboard/mouse events and do the edits on the file buffer<br>
+Send the file editing delta to the proxy to keep the file in sync<br>
+
+	 Proxy
+Receive save event from UI and flush the file buffer to disk<br>
+proxy the events between UI and the plugins<br>
+
+	Plugin
+Communicate with UI through proxy<br>
+
+UI sits locally. Proxy and Plugin will be in the remote box when doing remote development. With this architecture, I can make sure the editing experience is always the best, with other considerations like syntax highlighting being done in a different thread, so nothing blocks the main thread at any time. I finally had a lightning-fast and powerful code editor. (which can be beautiful as well)
diff --git a/extra/images/logo.png b/extra/images/logo.png
index d52ace007c..73c0b50e33 100644
Binary files a/extra/images/logo.png and b/extra/images/logo.png differ
diff --git a/extra/images/logo_app.svg b/extra/images/logo_app.svg
new file mode 100644
index 0000000000..4865afe4ff
--- /dev/null
+++ b/extra/images/logo_app.svg
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg viewBox="0 0 500 500" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient gradientUnits="userSpaceOnUse" x1="250" y1="60.691" x2="250" y2="439.31" id="gradient-1" gradientTransform="matrix(0.62884, 0.62884, -0.62884, 0.62884, 301.693542, -118.848228)">
+      <stop offset="0" style="stop-color: rgb(2, 6, 21);"/>
+      <stop offset="1" style="stop-color: rgb(18, 25, 53);"/>
+    </linearGradient>
+    <linearGradient gradientUnits="userSpaceOnUse" x1="10802.515" y1="7688.36" x2="10802.515" y2="13911.66" id="gradient-2" gradientTransform="matrix(-0.028, -0.028, 0.028, -0.028, 233.907039, 905.05849)">
+      <stop offset="0" style="stop-color: rgb(0, 62, 149);"/>
+      <stop offset="1" style="stop-color: rgb(70, 172, 255);"/>
+    </linearGradient>
+    <linearGradient gradientUnits="userSpaceOnUse" x1="10800.265" y1="7696.154" x2="10800.265" y2="13903.866" id="gradient-3" gradientTransform="matrix(0.044238, 0, 0, -0.044238, -212.162399, 727.776001)">
+      <stop offset="0" style="stop-color: rgb(0, 62, 149);"/>
+      <stop offset="1" style="stop-color: rgba(0, 0, 0, 1)"/>
+    </linearGradient>
+  </defs>
+  <g style="" transform="matrix(1.205162, 0, 0, 1.205162, -51.290611, -51.290611)">
+    <rect x="60.691" y="60.691" width="378.619" height="378.619" rx="40" ry="40" style="stroke: rgb(0, 0, 0); stroke-width: 0px; fill: url(#gradient-1);"/>
+    <path d="M 171.945 127.03 L 146.511 112.346 L 146.511 112.729 C 146.511 204.245 146.511 295.758 146.511 387.272 L 146.511 387.655 L 146.843 387.463 C 171.219 373.391 195.594 359.317 219.97 345.243 L 220.08 345.18 L 220.08 315.683 L 172.056 343.411 L 172.056 343.257 C 172.056 271.245 172.057 199.414 172.056 127.221 L 172.056 127.094 L 171.945 127.03 Z M 220.329 184.461 C 258.277 206.37 295.767 228.015 333.714 249.924 L 333.846 250.001 L 333.714 250.077 C 303.976 267.246 274.704 284.147 244.967 301.316 L 244.856 301.379 L 244.856 330.876 L 245.188 330.684 C 283.291 308.684 321.398 286.685 359.5 264.685 L 384.738 250.116 L 384.937 250.001 L 359.5 235.317 C 313.028 208.486 266.559 181.655 220.085 154.824 L 219.969 154.758 L 194.536 140.074 L 194.536 140.457 C 194.536 193.902 194.536 247.346 194.536 300.792 L 194.536 301.175 L 220.086 286.424 L 220.196 286.36 L 220.196 184.384 L 220.329 184.461 Z M 244.856 272.123 L 284.445 249.266 L 244.856 226.406 L 244.856 272.123 Z" style="fill-opacity: 1; fill-rule: evenodd; stroke-width: 0px; fill: url(#gradient-2);" id="path14"/>
+    <path d="M 171.846 127.202 L 146.711 112.69 L 146.711 112.729 C 146.711 204.245 146.71 295.758 146.71 387.272 L 146.71 387.31 L 146.743 387.291 C 171.119 373.218 195.495 359.145 219.87 345.071 L 219.881 345.065 L 219.881 345.065 L 219.881 345.065 L 219.881 316.028 L 171.857 343.755 L 171.857 343.602 C 171.857 271.475 171.857 199.414 171.857 127.221 L 171.857 127.209 L 171.846 127.202 Z M 171.79 127.221 L 171.812 127.234 L 171.812 127.285 C 171.813 199.457 171.812 271.602 171.812 343.794 L 171.812 343.832 L 219.837 316.105 L 219.837 345.039 L 219.793 345.065 C 195.436 359.128 171.23 373.103 146.887 387.157 L 146.754 387.233 L 146.754 387.08 C 146.754 295.63 146.755 204.372 146.755 112.92 L 146.755 112.767 L 171.768 127.209 L 171.79 127.221 Z M 220.13 184.116 C 258.178 206.084 296.065 227.956 334.112 249.924 L 334.244 250.001 L 334.112 250.077 C 304.397 267.234 274.803 284.32 245.066 301.488 L 245.055 301.494 L 245.055 330.531 L 245.088 330.512 C 283.191 308.512 321.298 286.512 359.401 264.512 L 384.539 250.001 L 359.401 235.489 C 312.928 208.658 266.46 181.828 219.986 154.997 L 219.87 154.931 L 194.735 140.419 L 194.735 140.457 C 194.735 193.902 194.735 247.346 194.735 300.792 L 194.735 300.83 L 219.986 286.251 L 219.997 286.245 L 219.997 286.252 L 220.014 286.235 L 219.997 286.245 L 219.997 286.245 L 219.997 184.04 L 220.13 184.116 Z M 219.953 286.194 L 219.953 286.219 L 219.931 286.232 L 194.78 300.753 L 194.78 300.6 C 194.78 247.219 194.779 194.029 194.779 140.649 L 194.779 140.496 L 219.848 154.969 L 219.964 155.035 C 266.438 181.866 312.906 208.697 359.378 235.527 L 384.451 250.001 L 359.378 264.474 C 321.276 286.474 283.279 308.41 245.232 330.378 L 245.1 330.454 L 245.1 301.545 L 245.1 301.52 L 245.122 301.507 L 245.144 301.494 C 274.862 284.337 304.563 267.189 334.3 250.02 L 334.333 250.001 L 334.3 249.982 C 296.197 227.982 258.09 205.982 219.986 183.982 L 219.953 183.963 L 219.953 286.194 Z M 284.047 249.266 L 245.055 226.75 L 245.055 271.778 L 284.047 249.266 Z M 245.1 226.827 L 283.959 249.266 L 245.1 271.701 L 245.1 226.827 Z" style="stroke-width: 0px; fill: url(#gradient-3);"/>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/extra/images/logo_app_light.svg b/extra/images/logo_app_light.svg
new file mode 100644
index 0000000000..d5106d0778
--- /dev/null
+++ b/extra/images/logo_app_light.svg
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg viewBox="0 0 500 500" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient gradientUnits="userSpaceOnUse" x1="250" y1="60.691" x2="250" y2="439.31" id="gradient-1" gradientTransform="matrix(0.912777, 0.912777, -0.912777, 0.912777, 250.049508, -206.672811)" spreadMethod="pad">
+      <stop offset="0" style="stop-color: rgb(168, 204, 255);"/>
+      <stop offset="1" style="stop-color: rgb(250, 250, 250);"/>
+    </linearGradient>
+    <linearGradient gradientUnits="userSpaceOnUse" x1="10802.515" y1="7688.36" x2="10802.515" y2="13911.66" id="gradient-2" gradientTransform="matrix(-0.028, -0.028, 0.028, -0.028, 233.907039, 905.05849)">
+      <stop offset="0" style="stop-color: rgb(0, 62, 149);"/>
+      <stop offset="1" style="stop-color: rgb(70, 172, 255);"/>
+    </linearGradient>
+  </defs>
+  <g style="" transform="matrix(1.205162, 0, 0, 1.205162, -51.290611, -51.290611)">
+    <rect x="60.691" y="60.691" width="378.619" height="378.619" rx="40" ry="40" style="stroke: rgb(0, 0, 0); stroke-width: 0px; fill: url(#gradient-1); fill-rule: nonzero;"/>
+    <path d="M 171.945 127.03 L 146.511 112.346 L 146.511 112.729 C 146.511 204.245 146.511 295.758 146.511 387.272 L 146.511 387.655 L 146.843 387.463 C 171.219 373.391 195.594 359.317 219.97 345.243 L 220.08 345.18 L 220.08 315.683 L 172.056 343.411 L 172.056 343.257 C 172.056 271.245 172.057 199.414 172.056 127.221 L 172.056 127.094 L 171.945 127.03 Z M 220.329 184.461 C 258.277 206.37 295.767 228.015 333.714 249.924 L 333.846 250.001 L 333.714 250.077 C 303.976 267.246 274.704 284.147 244.967 301.316 L 244.856 301.379 L 244.856 330.876 L 245.188 330.684 C 283.291 308.684 321.398 286.685 359.5 264.685 L 384.738 250.116 L 384.937 250.001 L 359.5 235.317 C 313.028 208.486 266.559 181.655 220.085 154.824 L 219.969 154.758 L 194.536 140.074 L 194.536 140.457 C 194.536 193.902 194.536 247.346 194.536 300.792 L 194.536 301.175 L 220.086 286.424 L 220.196 286.36 L 220.196 184.384 L 220.329 184.461 Z M 244.856 272.123 L 284.445 249.266 L 244.856 226.406 L 244.856 272.123 Z" style="fill-opacity: 1; fill-rule: evenodd; stroke-width: 0px; fill: url(#gradient-2);" id="path14"/>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/extra/images/logo_color.svg b/extra/images/logo_color.svg
new file mode 100644
index 0000000000..3a781785b1
--- /dev/null
+++ b/extra/images/logo_color.svg
@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="2880" height="2880" viewBox="0 0 2880 2880">
+  <defs id="defs6">
+    <radialGradient id="RadialGradient1">
+      <stop offset="0%" stop-color="#3da4eb"/>
+      <stop offset="100%" stop-color="#196eae"/>
+    </radialGradient>
+  </defs>
+  <g id="g10" transform="matrix(4.511777, 0, 0, -4.511777, -3433.283203, 6312.723633)" style="filter:none">
+    <g id="g12" transform="scale(0.1)">
+      <path d="m 8680.16,13575.4 -567.42,327.6 c 0,-2068.7 -0.01,-4137.33 -0.01,-6205.98 551.01,318.11 1102.02,636.24 1653.02,954.37 V 9306.6 L 8680.16,8679.83 c 0,1631.87 0.02,3263.67 0,4895.57 z M 9768.37,9981 v 2310.9 c 861.33,-497.3 1722.73,-994.6 2584.03,-1491.9 -672.2,-388.1 -1344.4,-776.2 -2016.6,-1164.29 V 8980.5 c 861.3,497.3 1722.7,994.6 2584,1491.9 l 567.5,327.6 -567.5,327.6 c -1050.5,606.5 -2100.9,1213 -3151.43,1819.5 l -2.62,1.5 -567.43,327.6 c 0,-1208.1 0.01,-2416.2 0.01,-3624.32 z m 1447.33,835.6 -879.9,508.1 v -1016.1 z" style="fill:url(#RadialGradient1);fill-opacity:1;fill-rule:evenodd;stroke:none" id="path14"/>
+    </g>
+  </g>
+</svg>
diff --git a/extra/images/screenshot.png b/extra/images/screenshot.png
index 1ccce3d5e6..9d44b90f71 100644
Binary files a/extra/images/screenshot.png and b/extra/images/screenshot.png differ
diff --git a/extra/images/volt.png b/extra/images/volt.png
new file mode 100644
index 0000000000..4bcfe9b294
Binary files /dev/null and b/extra/images/volt.png differ
diff --git a/extra/linux/dev.lapce.lapce.desktop b/extra/linux/dev.lapce.lapce.desktop
index 83f9c5cc1f..f4aee65474 100644
--- a/extra/linux/dev.lapce.lapce.desktop
+++ b/extra/linux/dev.lapce.lapce.desktop
@@ -5,7 +5,15 @@ Type=Application
 Name=Lapce
 Comment=Lightning-fast and powerful code editor written in Rust
 Categories=Development;IDE;
+GenericName=Code Editor
 
 Icon=dev.lapce.lapce
 Exec=lapce
 Terminal=false
+MimeType=text/plain;inode/directory;
+Actions=new-window;
+
+[Desktop Action new-window]
+Name=New Window
+Exec=lapce --new %F
+Icon=dev.lapce.lapce
diff --git a/extra/linux/dev.lapce.lapce.metainfo.xml b/extra/linux/dev.lapce.lapce.metainfo.xml
index 429c2ae698..791c4a23d9 100644
--- a/extra/linux/dev.lapce.lapce.metainfo.xml
+++ b/extra/linux/dev.lapce.lapce.metainfo.xml
@@ -30,6 +30,6 @@
         </screenshot>
     </screenshots>
     <releases>
-        <release version="0.1.2" date="2022-05-19"/>
+        <release version="0.2.6" date="2022-10-12"/>
     </releases>
 </component>
diff --git a/extra/macos/Lapce.app/Contents/Info.plist b/extra/macos/Lapce.app/Contents/Info.plist
index 86f6dd6695..6fa8fa641b 100644
--- a/extra/macos/Lapce.app/Contents/Info.plist
+++ b/extra/macos/Lapce.app/Contents/Info.plist
@@ -15,7 +15,7 @@
   <key>CFBundlePackageType</key>
   <string>APPL</string>
   <key>CFBundleShortVersionString</key>
-  <string>0.10.0-dev</string>
+  <string>0.2.6</string>
   <key>CFBundleSupportedPlatforms</key>
   <array>
     <string>MacOSX</string>
diff --git a/extra/macos/Lapce.app/Contents/Resources/lapce.icns b/extra/macos/Lapce.app/Contents/Resources/lapce.icns
index d6a237c844..691e4b1eee 100644
Binary files a/extra/macos/Lapce.app/Contents/Resources/lapce.icns and b/extra/macos/Lapce.app/Contents/Resources/lapce.icns differ
diff --git a/extra/proxy.ps1 b/extra/proxy.ps1
new file mode 100644
index 0000000000..42bc12ef05
--- /dev/null
+++ b/extra/proxy.ps1
@@ -0,0 +1,47 @@
+[CmdletBinding()]
+param(
+    [string]$version,
+    [string]$directory
+)
+
+$proxy = (Join-Path $directory 'lapce.exe')
+
+$LapceProcesses = (Get-Process -Name 'lapce' -EA SilentlyContinue).Count
+if ($LapceProcesses -ne 0) {
+    Write-Host 'Proxy currently in use. Aborting installation'
+    exit
+}
+
+if (Test-Path $proxy) {
+    Write-Host 'Proxy already installed'
+    exit
+}
+
+switch ($env:PROCESSOR_ARCHITECTURE) {
+    # Only x86_64 is supported currently
+    'AMD64' {
+        $arch = 'x86_64'
+    }
+}
+
+$url = "https://github.com/lapce/lapce/releases/download/${version}/lapce-proxy-windows-${arch}.gz"
+$gzip = Join-Path "${env:TMP}" "lapce-proxy-windows-${arch}.gz"
+
+$webclient = [System.Net.WebClient]::new()
+$webclient.DownloadFile($url, $gzip)
+$webclient.Dispose()
+
+[System.IO.Directory]::CreateDirectory($directory)
+
+$archive = [System.IO.File]::Open($gzip, [System.IO.FileMode]::Open)
+$proxy_file = [System.IO.File]::Create($proxy)
+$compressor = [System.IO.Compression.GZipStream]::new($archive, [System.IO.Compression.CompressionMode]::Decompress)
+$compressor.CopyTo($proxy_file)
+Start-Sleep -Seconds 3
+$compressor.close()
+$proxy_file.close()
+$archive.close()
+
+[System.IO.File]::Delete($gzip)
+
+Write-Host 'lapce-proxy installed'
\ No newline at end of file
diff --git a/extra/proxy.sh b/extra/proxy.sh
new file mode 100644
index 0000000000..87e727e62d
--- /dev/null
+++ b/extra/proxy.sh
@@ -0,0 +1,92 @@
+#!/bin/sh
+set -eux
+
+# This script is written to be as POSIX as possible
+# so it works fine for all Unix-like operating systems
+
+test_cmd() {
+  command -v "$1" >/dev/null
+}
+
+tmp_dir='/tmp'
+# proxy version
+lapce_new_ver="${1}"
+# proxy directory
+# eval to resolve '~' into proper user dir
+eval lapce_dir="'${2}'"
+
+if [ -e "${lapce_dir}/lapce" ]; then
+  chmod +x "${lapce_dir}/lapce"
+
+  lapce_installed_ver=$("${lapce_dir}/lapce" --version | cut -d'v' -f2)
+
+  printf '[DEBUG]: Current proxy version: %s\n' "${lapce_installed_ver}"
+  printf '[DEBUG]: New proxy version: %s\n' "${lapce_new_ver}"
+  if [ "${lapce_installed_ver}" = "${lapce_new_ver}" ]; then
+    printf 'Proxy already exists\n'
+    exit 0
+  else
+    printf 'Proxy outdated. Replacing proxy\n'
+    rm "${lapce_dir}/lapce"
+  fi
+fi
+
+for _cmd in tar gzip uname; do
+  if ! test_cmd "${_cmd}"; then
+    printf 'Missing required command: %s\n' "${_cmd}"
+    exit 1
+  fi
+done
+
+# Currently only linux/darwin are supported
+case $(uname -s) in
+  Linux) os_name=linux ;;
+  Darwin) os_name=darwin ;;
+  *)
+    printf '[ERROR] unsupported os'
+  ;;
+esac
+
+# Currently only amd64/arm64 are supported
+case $(uname -m) in
+  x86_64|amd64|x64) arch_name=x86_64 ;;
+  arm64|aarch64) arch_name=aarch64 ;;
+  # riscv64) arch_name=riscv64 ;;
+  *)
+    printf '[ERROR] unsupported arch'
+  ;;
+esac
+
+printf 'Switching to "%s"\n' "${tmp_dir}"
+cd "${tmp_dir}"
+
+lapce_download_url="https://github.com/lapce/lapce/releases/download/${lapce_new_ver}/lapce-proxy-${os_name}-${arch_name}.gz"
+
+if test_cmd 'curl'; then
+  # How old curl has these options? we'll find out
+  printf 'Downloading using curl\n'
+  curl --proto '=https' --tlsv1.2 -LfS -O "${lapce_download_url}"
+  # curl --proto '=https' --tlsv1.2 -LZfS -o "${tmp_dir}/lapce-proxy-${os_name}-${arch_name}.gz" "${lapce_download_url}"
+elif test_cmd 'wget'; then
+  printf 'Downloading using wget\n'
+  wget "${lapce_download_url}"
+else
+  printf 'curl/wget not found, failed to download proxy\n'
+  exit 1
+fi
+
+printf 'Creating "%s"\n' "${lapce_dir}"
+mkdir -p "${lapce_dir}"
+
+printf 'Decompressing gzip\n'
+gzip -d "${tmp_dir}/lapce-proxy-${os_name}-${arch_name}.gz"
+
+printf 'Moving proxy to our dir\n'
+mv -v "${tmp_dir}/lapce-proxy-${os_name}-${arch_name}" "${lapce_dir}/lapce"
+
+printf 'Making it executable\n'
+chmod +x "${lapce_dir}/lapce"
+
+printf 'lapce-proxy installed\n'
+
+exit 0
diff --git a/extra/schemas/color-theme.json b/extra/schemas/color-theme.json
new file mode 100644
index 0000000000..55ca4caed0
--- /dev/null
+++ b/extra/schemas/color-theme.json
@@ -0,0 +1,223 @@
+{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$ref": "#/definitions/ColorTheme",
+    "definitions": {
+        "ColorTheme": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "color-theme": {
+                    "$ref": "#/definitions/ColorThemeClass"
+                },
+                "ui": {
+                    "$ref": "#/definitions/UI"
+                }
+            },
+            "required": [],
+            "title": "ColorTheme"
+        },
+        "ColorThemeClass": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "base": {
+                    "$ref": "#/definitions/Base"
+                },
+                "syntax": {
+                    "$ref": "#/definitions/Syntax"
+                },
+                "ui": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": [],
+            "title": "ColorThemeClass"
+        },
+        "Base": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "white": {
+                    "type": "string"
+                },
+                "black": {
+                    "type": "string"
+                },
+                "grey": {
+                    "type": "string"
+                },
+                "blue": {
+                    "type": "string"
+                },
+                "red": {
+                    "type": "string"
+                },
+                "yellow": {
+                    "type": "string"
+                },
+                "orange": {
+                    "type": "string"
+                },
+                "green": {
+                    "type": "string"
+                },
+                "purple": {
+                    "type": "string"
+                },
+                "cyan": {
+                    "type": "string"
+                },
+                "magenta": {
+                    "type": "string"
+                }
+            },
+            "required": [],
+            "title": "Base"
+        },
+        "Syntax": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "comment": {
+                    "type": "string"
+                },
+                "constant": {
+                    "type": "string"
+                },
+                "type": {
+                    "type": "string"
+                },
+                "typeAlias": {
+                    "type": "string"
+                },
+                "number": {
+                    "type": "string"
+                },
+                "enum": {
+                    "type": "string"
+                },
+                "struct": {
+                    "type": "string"
+                },
+                "structure": {
+                    "type": "string"
+                },
+                "interface": {
+                    "type": "string"
+                },
+                "attribute": {
+                    "type": "string"
+                },
+                "constructor": {
+                    "type": "string"
+                },
+                "function": {
+                    "type": "string"
+                },
+                "method": {
+                    "type": "string"
+                },
+                "function.method": {
+                    "type": "string"
+                },
+                "keyword": {
+                    "type": "string"
+                },
+                "selfKeyword": {
+                    "type": "string"
+                },
+                "field": {
+                    "type": "string"
+                },
+                "property": {
+                    "type": "string"
+                },
+                "enumMember": {
+                    "type": "string"
+                },
+                "enum-member": {
+                    "type": "string"
+                },
+                "string": {
+                    "type": "string"
+                },
+                "type.builtin": {
+                    "type": "string"
+                },
+                "builtinType": {
+                    "type": "string"
+                },
+                "escape": {
+                    "type": "string"
+                },
+                "string.escape": {
+                    "type": "string"
+                },
+                "embedded": {
+                    "type": "string"
+                },
+                "punctuation.delimiter": {
+                    "type": "string"
+                },
+                "text.title": {
+                    "type": "string"
+                },
+                "text.uri": {
+                    "type": "string"
+                },
+                "text.reference": {
+                    "type": "string"
+                },
+                "variable": {
+                    "type": "string"
+                },
+                "variable.other.member": {
+                    "type": "string"
+                },
+                "tag": {
+                    "type": "string"
+                }
+            },
+            "required": [],
+            "title": "Syntax"
+        },
+        "UI": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "font-family": {
+                    "type": "string"
+                },
+                "font-size": {
+                    "type": "integer"
+                },
+                "header-height": {
+                    "type": "integer"
+                },
+                "status-height": {
+                    "type": "integer"
+                },
+                "tab-min-width": {
+                    "type": "integer"
+                },
+                "activity-width": {
+                    "type": "integer"
+                },
+                "scroll-width": {
+                    "type": "integer"
+                },
+                "drop-shadow-width": {
+                    "type": "integer"
+                }
+            },
+            "required": [],
+            "title": "UI"
+        }
+    }
+}
diff --git a/extra/schemas/icon-theme.json b/extra/schemas/icon-theme.json
new file mode 100644
index 0000000000..9bcc116dfd
--- /dev/null
+++ b/extra/schemas/icon-theme.json
@@ -0,0 +1,60 @@
+{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$ref": "#/definitions/IconTheme",
+    "definitions": {
+        "IconTheme": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "icon-theme": {
+                    "$ref": "#/definitions/IconThemeClass"
+                }
+            },
+            "required": [],
+            "title": "IconTheme"
+        },
+        "IconThemeClass": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "ui": {
+                    "$ref": "#/definitions/IconMapping"
+                },
+                "foldername": {
+                    "$ref": "#/definitions/IconMapping"
+                },
+                "filename": {
+                    "$ref": "#/definitions/IconMapping"
+                },
+                "extension": {
+                    "$ref": "#/definitions/IconMapping"
+                }
+            },
+            "required": [],
+            "title": "IconThemeClass"
+        },
+        "IconMapping": {
+            "type": "object",
+            "additionalProperties": false,
+            "patternProperties": {
+                "*" : {
+                    "type": "string"
+                }
+            },
+            "title": "IconMapping"
+        },
+        "Extension": {
+            "type": "object",
+            "additionalProperties": false,
+            "patternProperties": {
+                "[a-zA-Z0-9]" : {
+                    "type": "string"
+                }
+            },
+            "title": "IconMapping"
+        }
+    }
+}
diff --git a/extra/schemas/settings.json b/extra/schemas/settings.json
new file mode 100644
index 0000000000..184b756817
--- /dev/null
+++ b/extra/schemas/settings.json
@@ -0,0 +1,347 @@
+{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$ref": "#/definitions/Settings",
+    "definitions": {
+        "Settings": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "core": {
+                    "$ref": "#/definitions/Core"
+                },
+                "editor": {
+                    "$ref": "#/definitions/Editor"
+                },
+                "terminal": {
+                    "$ref": "#/definitions/Terminal"
+                },
+                "ui": {
+                    "$ref": "#/definitions/UI"
+                },
+                "color-theme": {
+                    "$ref": "file://./color-theme.json"
+                },
+                "icon-theme": {
+                    "$schema": "file://./icon-theme.json"
+                }
+            },
+            "required": [],
+            "title": "Settings"
+        },
+        "Base": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "white": {
+                    "type": "string"
+                },
+                "black": {
+                    "type": "string"
+                },
+                "grey": {
+                    "type": "string"
+                },
+                "blue": {
+                    "type": "string"
+                },
+                "red": {
+                    "type": "string"
+                },
+                "yellow": {
+                    "type": "string"
+                },
+                "orange": {
+                    "type": "string"
+                },
+                "green": {
+                    "type": "string"
+                },
+                "purple": {
+                    "type": "string"
+                },
+                "cyan": {
+                    "type": "string"
+                },
+                "magenta": {
+                    "type": "string"
+                }
+            },
+            "required": [],
+            "title": "Base"
+        },
+        "Syntax": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "comment": {
+                    "type": "string"
+                },
+                "constant": {
+                    "type": "string"
+                },
+                "type": {
+                    "type": "string"
+                },
+                "typeAlias": {
+                    "type": "string"
+                },
+                "number": {
+                    "type": "string"
+                },
+                "enum": {
+                    "type": "string"
+                },
+                "struct": {
+                    "type": "string"
+                },
+                "structure": {
+                    "type": "string"
+                },
+                "interface": {
+                    "type": "string"
+                },
+                "attribute": {
+                    "type": "string"
+                },
+                "constructor": {
+                    "type": "string"
+                },
+                "function": {
+                    "type": "string"
+                },
+                "method": {
+                    "type": "string"
+                },
+                "function.method": {
+                    "type": "string"
+                },
+                "keyword": {
+                    "type": "string"
+                },
+                "keyword.control": {
+                    "type": "string"
+                },
+                "selfKeyword": {
+                    "type": "string"
+                },
+                "field": {
+                    "type": "string"
+                },
+                "property": {
+                    "type": "string"
+                },
+                "enumMember": {
+                    "type": "string"
+                },
+                "enum-member": {
+                    "type": "string"
+                },
+                "variable.other.member": {
+                    "type": "string"
+                },
+                "string": {
+                    "type": "string"
+                },
+                "type.builtin": {
+                    "type": "string"
+                },
+                "builtinType": {
+                    "type": "string"
+                },
+                "escape": {
+                    "type": "string"
+                },
+                "embedded": {
+                    "type": "string"
+                },
+                "symbol": {
+                    "type": "string"
+                }
+            },
+            "required": [],
+            "title": "Syntax"
+        },
+        "Core": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "modal": {
+                    "type": "boolean"
+                },
+                "color-theme": {
+                    "type": "string"
+                },
+                "icon-theme": {
+                    "type": "string"
+                },
+                "custom-titlebar": {
+                    "type": "boolean"
+                }
+            },
+            "required": [],
+            "title": "Core"
+        },
+        "Editor": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "font-family": {
+                    "type": "string"
+                },
+                "font-size": {
+                    "type": "integer"
+                },
+                "code-lens-font-size": {
+                    "type": "integer"
+                },
+                "line-height": {
+                    "type": "number"
+                },
+                "tab-width": {
+                    "type": "integer"
+                },
+                "show-tab": {
+                    "type": "boolean"
+                },
+                "show-bread-crumbs": {
+                    "type": "boolean"
+                },
+                "scroll-beyond-last-line": {
+                    "type": "boolean"
+                },
+                "cursor-surrounding-lines": {
+                    "type": "integer"
+                },
+                "sticky-header": {
+                    "type": "boolean"
+                },
+                "completion-show-documentation": {
+                    "type": "boolean"
+                },
+                "auto-closing-matching-pairs": {
+                    "type": "boolean"
+                },
+                "hover-delay": {
+                    "type": "integer"
+                },
+                "modal-mode-relative-line-numbers": {
+                    "type": "boolean"
+                },
+                "format-on-save": {
+                    "type": "boolean"
+                },
+                "highlight-matching-brackets": {
+                    "type": "boolean"
+                },
+                "autosave-interval": {
+                    "type": "integer"
+                },
+                "enable-inlay-hints": {
+                    "type": "boolean"
+                },
+                "inlay-hint-font-family": {
+                    "type": "string"
+                },
+                "inlay-hint-font-size": {
+                    "type": "integer"
+                },
+                "enable-error-lens": {
+                    "type": "boolean"
+                },
+                "error-lens-end-of-line": {
+                    "type": "boolean"
+                },
+                "error-lens-font-family": {
+                    "type": "string"
+                },
+                "error-lens-font-size": {
+                    "type": "integer"
+                },
+                "blink-interval": {
+                    "type": "integer"
+                },
+                "multicursor-case-sensitive": {
+                    "type": "boolean"
+                },
+                "multicursor-whole-words": {
+                    "type": "boolean"
+                },
+                "render-whitespace": {
+                    "type": "string"
+                },
+                "show-indent-guide": {
+                    "type": "boolean"
+                },
+                "atomic-soft-tabs": {
+                    "type": "boolean"
+                }
+            },
+            "required": [],
+            "title": "Editor"
+        },
+        "Terminal": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "font-family": {
+                    "type": "string"
+                },
+                "font-size": {
+                    "type": "integer"
+                },
+                "line-height": {
+                    "type": "integer"
+                },
+                "shell": {
+                    "type": "string"
+                }
+            },
+            "required": [],
+            "title": "Terminal"
+        },
+        "UI": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "font-family": {
+                    "type": "string"
+                },
+                "font-size": {
+                    "type": "integer"
+                },
+                "icon-size": {
+                    "type": "integer"
+                },
+                "header-height": {
+                    "type": "integer"
+                },
+                "status-height": {
+                    "type": "integer"
+                },
+                "tab-min-width": {
+                    "type": "integer"
+                },
+                "scroll-width": {
+                    "type": "integer"
+                },
+                "drop-shadow-width": {
+                    "type": "integer"
+                },
+                "preview-editor-width": {
+                    "type": "integer"
+                },
+                "hover-font-family": {
+                    "type": "string"
+                },
+                "hover-font-size": {
+                    "type": "integer"
+                },
+                "trim-search-results-whitespace": {
+                    "type": "boolean"
+                }
+            },
+            "required": [],
+            "title": "UI"
+        }
+    }
+}
diff --git a/extra/windows/lapce.ico b/extra/windows/lapce.ico
index 6c4bb0b21d..c78b16b406 100644
Binary files a/extra/windows/lapce.ico and b/extra/windows/lapce.ico differ
diff --git a/extra/windows/wix/lapce.wxs b/extra/windows/wix/lapce.wxs
index 0f83e41a47..1ca22ba4ff 100644
--- a/extra/windows/wix/lapce.wxs
+++ b/extra/windows/wix/lapce.wxs
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="windows-1252"?>
 <Wix xmlns="http://schemas.microsoft.com/wix/2006/wi" xmlns:util="http://schemas.microsoft.com/wix/UtilExtension">
-    <Product Name="Lapce" Id="*" UpgradeCode="9c09a374-1135-4782-959f-2dec376a1dfa" Language="1033" Codepage="1252" Version="0.1.2" Manufacturer="Lapce">
+    <Product Name="Lapce" Id="*" UpgradeCode="9c09a374-1135-4782-959f-2dec376a1dfa" Language="1033" Codepage="1252" Version="0.2.6" Manufacturer="Lapce">
         <Package InstallerVersion="200" Compressed="yes" InstallScope="perMachine"/>
         <MajorUpgrade AllowSameVersionUpgrades="yes" DowngradeErrorMessage="A newer version of [ProductName] is already installed."/>
         <Icon Id="lapce.exe" SourceFile=".\extra\windows\lapce.ico"/>
@@ -53,7 +53,7 @@
             <!-- Add context menu -->
             <Component Id="ContextMenu" Guid="22ad399b-1d77-416c-ae33-57e8f8511177">
                 <RegistryKey Root="HKCU" Key="Software\Classes\Directory\Background\shell\Open Lapce here\command">
-                    <RegistryValue Type="string" Value="[LapceProgramFiles]lapce.exe --working-directory &quot;%V&quot;" KeyPath="yes"/>
+                    <RegistryValue Type="string" Value="[LapceProgramFiles]lapce.exe &quot;%V&quot;" KeyPath="yes"/>
                 </RegistryKey>
                 <RegistryKey Root="HKCU" Key="Software\Classes\Directory\Background\shell\Open Lapce here">
                     <RegistryValue Type="string" Name="Icon" Value="[LapceProgramFiles]lapce.exe"/>
diff --git a/icons/arrow-down.svg b/icons/arrow-down.svg
deleted file mode 100644
index 3b9527c06b..0000000000
--- a/icons/arrow-down.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M3.14667 9.00001L8.14665 14L8.85376 14L13.8538 9.00001L13.1467 8.2929L9.00021 12.4393L9.00022 2.00001L8.00022 2.00001L8.00022 12.4393L3.85378 8.2929L3.14667 9.00001Z" fill="#424242"/>
-</svg>
diff --git a/icons/arrow-up.svg b/icons/arrow-up.svg
deleted file mode 100644
index 4ed3c5166b..0000000000
--- a/icons/arrow-up.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M13.8538 6.99999L8.85384 2H8.14673L3.14673 6.99999L3.85384 7.7071L8.00027 3.56066V14H9.00027V3.56066L13.1467 7.7071L13.8538 6.99999Z" fill="#424242"/>
-</svg>
diff --git a/icons/chevron-down.svg b/icons/chevron-down.svg
deleted file mode 100644
index 252d40eb81..0000000000
--- a/icons/chevron-down.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M7.97637 10.0719L12.3337 5.7146L12.9524 6.33332L8.28573 11L7.66701 11L3.00034 6.33332L3.61906 5.7146L7.97637 10.0719Z" fill="#424242"/>
-</svg>
diff --git a/icons/chevron-up.svg b/icons/chevron-up.svg
deleted file mode 100644
index 19a7f69813..0000000000
--- a/icons/chevron-up.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M8.02412 5.92809L3.66681 10.2854L3.0481 9.66668L7.71476 5.00001L8.33348 5.00001L13.0001 9.66668L12.3814 10.2854L8.02412 5.92809Z" fill="#424242"/>
-</svg>
diff --git a/icons/close.svg b/icons/close.svg
deleted file mode 100644
index 5a087a380b..0000000000
--- a/icons/close.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M8.00028 8.70711L11.6467 12.3536L12.3538 11.6465L8.70739 8.00001L12.3538 4.35356L11.6467 3.64645L8.00028 7.2929L4.35384 3.64645L3.64673 4.35356L7.29317 8.00001L3.64673 11.6465L4.35384 12.3536L8.00028 8.70711Z" fill="#424242"/>
-</svg>
diff --git a/icons/codicons/LICENSE b/icons/codicons/LICENSE
new file mode 100644
index 0000000000..a2c95fc155
--- /dev/null
+++ b/icons/codicons/LICENSE
@@ -0,0 +1,395 @@
+Attribution 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+	wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More_considerations
+     for the public: 
+	wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.
\ No newline at end of file
diff --git a/icons/codicons/README.md b/icons/codicons/README.md
new file mode 100644
index 0000000000..0b0eca8053
--- /dev/null
+++ b/icons/codicons/README.md
@@ -0,0 +1,3 @@
+# vscode-codicons
+
+Source: [https://github.com/microsoft/vscode-codicons](https://github.com/microsoft/vscode-codicons)
diff --git a/icons/codicons/add.svg b/icons/codicons/add.svg
new file mode 100644
index 0000000000..aed9bc6919
--- /dev/null
+++ b/icons/codicons/add.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M14 7v1H8v6H7V8H1V7h6V1h1v6h6z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/arrow-both.svg b/icons/codicons/arrow-both.svg
new file mode 100644
index 0000000000..c0fa479da4
--- /dev/null
+++ b/icons/codicons/arrow-both.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M3 9l2.146 2.146-.707.708-3-3v-.708l3-3 .707.708L3 8h10l-2.146-2.146.707-.708 3 3v.708l-3 3-.707-.707L13 9H3z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/arrow-down.svg b/icons/codicons/arrow-down.svg
new file mode 100644
index 0000000000..1c9268b3f3
--- /dev/null
+++ b/icons/codicons/arrow-down.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M3.147 9l5 5h.707l5-5-.707-.707L9 12.439V2H8v10.44L3.854 8.292 3.147 9z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/arrow-left.svg b/icons/codicons/arrow-left.svg
new file mode 100644
index 0000000000..6e658755aa
--- /dev/null
+++ b/icons/codicons/arrow-left.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M7 3.093l-5 5V8.8l5 5 .707-.707-4.146-4.147H14v-1H3.56L7.708 3.8 7 3.093z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/arrow-right.svg b/icons/codicons/arrow-right.svg
new file mode 100644
index 0000000000..f61ddd1754
--- /dev/null
+++ b/icons/codicons/arrow-right.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M9 13.887l5-5V8.18l-5-5-.707.707 4.146 4.147H2v1h10.44L8.292 13.18l.707.707z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/arrow-swap.svg b/icons/codicons/arrow-swap.svg
new file mode 100644
index 0000000000..6496412119
--- /dev/null
+++ b/icons/codicons/arrow-swap.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M4.207 15.061L1 11.854v-.707L4.207 7.94l.707.707-2.353 2.354H15v1H2.56l2.354 2.353-.707.707zm7.586-7L15 4.854v-.707L11.793.94l-.707.707L13.439 4H1v1h12.44l-2.354 2.354.707.707z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/arrow-up.svg b/icons/codicons/arrow-up.svg
new file mode 100644
index 0000000000..81a022073e
--- /dev/null
+++ b/icons/codicons/arrow-up.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M13.854 7l-5-5h-.707l-5 5 .707.707L8 3.561V14h1V3.56l4.146 4.147.708-.707z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/blank.svg b/icons/codicons/blank.svg
new file mode 100644
index 0000000000..7aacd329fc
--- /dev/null
+++ b/icons/codicons/blank.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"/>
\ No newline at end of file
diff --git a/icons/codicons/case-sensitive.svg b/icons/codicons/case-sensitive.svg
new file mode 100644
index 0000000000..9faa9b7c41
--- /dev/null
+++ b/icons/codicons/case-sensitive.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M8.85352 11.7021H7.85449L7.03809 9.54297H3.77246L3.00439 11.7021H2L4.9541 4H5.88867L8.85352 11.7021ZM6.74268 8.73193L5.53418 5.4502C5.49479 5.34277 5.4554 5.1709 5.41602 4.93457H5.39453C5.35872 5.15299 5.31755 5.32487 5.271 5.4502L4.07324 8.73193H6.74268Z"/><path d="M13.756 11.7021H12.8752V10.8428H12.8537C12.4706 11.5016 11.9066 11.8311 11.1618 11.8311C10.6139 11.8311 10.1843 11.686 9.87273 11.396C9.56479 11.106 9.41082 10.721 9.41082 10.2412C9.41082 9.21354 10.016 8.61556 11.2262 8.44727L12.8752 8.21631C12.8752 7.28174 12.4974 6.81445 11.7419 6.81445C11.0794 6.81445 10.4815 7.04004 9.94793 7.49121V6.58887C10.4886 6.24512 11.1117 6.07324 11.8171 6.07324C13.1097 6.07324 13.756 6.75716 13.756 8.125V11.7021ZM12.8752 8.91992L11.5485 9.10254C11.1403 9.15983 10.8324 9.26188 10.6247 9.40869C10.417 9.55192 10.3132 9.80794 10.3132 10.1768C10.3132 10.4453 10.4081 10.6655 10.5978 10.8374C10.7912 11.0057 11.0472 11.0898 11.3659 11.0898C11.8027 11.0898 12.1626 10.9377 12.4455 10.6333C12.7319 10.3254 12.8752 9.93685 12.8752 9.46777V8.91992Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/chevron-down.svg b/icons/codicons/chevron-down.svg
new file mode 100644
index 0000000000..59a4873495
--- /dev/null
+++ b/icons/codicons/chevron-down.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M7.976 10.072l4.357-4.357.62.618L8.284 11h-.618L3 6.333l.619-.618 4.357 4.357z"/></svg>
\ No newline at end of file
diff --git a/icons/chevron-left.svg b/icons/codicons/chevron-left.svg
similarity index 100%
rename from icons/chevron-left.svg
rename to icons/codicons/chevron-left.svg
diff --git a/icons/chevron-right.svg b/icons/codicons/chevron-right.svg
similarity index 100%
rename from icons/chevron-right.svg
rename to icons/codicons/chevron-right.svg
diff --git a/icons/codicons/chevron-up.svg b/icons/codicons/chevron-up.svg
new file mode 100644
index 0000000000..f103cfdd1f
--- /dev/null
+++ b/icons/codicons/chevron-up.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M8.024 5.928l-4.357 4.357-.62-.618L7.716 5h.618L13 9.667l-.619.618-4.357-4.357z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/chrome-close.svg b/icons/codicons/chrome-close.svg
new file mode 100644
index 0000000000..6b9a55a41e
--- /dev/null
+++ b/icons/codicons/chrome-close.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M7.116 8l-4.558 4.558.884.884L8 8.884l4.558 4.558.884-.884L8.884 8l4.558-4.558-.884-.884L8 7.116 3.442 2.558l-.884.884L7.116 8z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/chrome-maximize.svg b/icons/codicons/chrome-maximize.svg
new file mode 100644
index 0000000000..7627e7fab4
--- /dev/null
+++ b/icons/codicons/chrome-maximize.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M3 3v10h10V3H3zm9 9H4V4h8v8z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/chrome-minimize.svg b/icons/codicons/chrome-minimize.svg
new file mode 100644
index 0000000000..abcc15bf99
--- /dev/null
+++ b/icons/codicons/chrome-minimize.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M14 8v1H3V8h11z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/chrome-restore.svg b/icons/codicons/chrome-restore.svg
new file mode 100644
index 0000000000..1537b4a808
--- /dev/null
+++ b/icons/codicons/chrome-restore.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M3 5v9h9V5H3zm8 8H4V6h7v7z"/><path fill-rule="evenodd" clip-rule="evenodd" d="M5 5h1V4h7v7h-1v1h2V3H5v2z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/circle-filled.svg b/icons/codicons/circle-filled.svg
new file mode 100644
index 0000000000..955f153996
--- /dev/null
+++ b/icons/codicons/circle-filled.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M8 4c.367 0 .721.048 1.063.145a3.943 3.943 0 0 1 1.762 1.031 3.944 3.944 0 0 1 1.03 1.762c.097.34.145.695.145 1.062 0 .367-.048.721-.145 1.063a3.94 3.94 0 0 1-1.03 1.765 4.017 4.017 0 0 1-1.762 1.031C8.72 11.953 8.367 12 8 12s-.721-.047-1.063-.14a4.056 4.056 0 0 1-1.765-1.032A4.055 4.055 0 0 1 4.14 9.062 3.992 3.992 0 0 1 4 8c0-.367.047-.721.14-1.063a4.02 4.02 0 0 1 .407-.953A4.089 4.089 0 0 1 5.98 4.546a3.94 3.94 0 0 1 .957-.401A3.89 3.89 0 0 1 8 4z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/close.svg b/icons/codicons/close.svg
new file mode 100644
index 0000000000..a63b1e0fbc
--- /dev/null
+++ b/icons/codicons/close.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M8 8.707l3.646 3.647.708-.707L8.707 8l3.647-3.646-.707-.708L8 7.293 4.354 3.646l-.707.708L7.293 8l-3.646 3.646.707.708L8 8.707z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/diff-added.svg b/icons/codicons/diff-added.svg
new file mode 100644
index 0000000000..9eca31e537
--- /dev/null
+++ b/icons/codicons/diff-added.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 1h12l.5.5v12l-.5.5h-12l-.5-.5v-12l.5-.5zM2 13h11V2H2v11z"/><path fill-rule="evenodd" clip-rule="evenodd" d="M8 4H7v3H4v1h3v3h1V8h3V7H8V4z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/diff-ignored.svg b/icons/codicons/diff-ignored.svg
new file mode 100644
index 0000000000..bbbedece23
--- /dev/null
+++ b/icons/codicons/diff-ignored.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 1h13l.5.5v13l-.5.5h-13l-.5-.5v-13l.5-.5zM2 14h12V2H2v12zm8-10h2v2l-6 6H4v-2l6-6z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/diff-modified.svg b/icons/codicons/diff-modified.svg
new file mode 100644
index 0000000000..cae06cbf75
--- /dev/null
+++ b/icons/codicons/diff-modified.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 1h13l.5.5v13l-.5.5h-13l-.5-.5v-13l.5-.5zM2 2v12h12V2H2zm6 9a3 3 0 1 0 0-6 3 3 0 0 0 0 6z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/diff-removed.svg b/icons/codicons/diff-removed.svg
new file mode 100644
index 0000000000..2da06cd8b6
--- /dev/null
+++ b/icons/codicons/diff-removed.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M10 7v1H5V7h5z"/><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 1h12l.5.5v12l-.5.5h-12l-.5-.5v-12l.5-.5zM2 13h11V2H2v11z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/diff-renamed.svg b/icons/codicons/diff-renamed.svg
new file mode 100644
index 0000000000..f86550664e
--- /dev/null
+++ b/icons/codicons/diff-renamed.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 1h13l.5.5v13l-.5.5h-13l-.5-.5v-13l.5-.5zM2 14h12V2H2v12zm2-5h3v3l5-4-5-4v3H4v2z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/diff.svg b/icons/codicons/diff.svg
new file mode 100644
index 0000000000..4af4ba742d
--- /dev/null
+++ b/icons/codicons/diff.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M2 3.5l.5-.5h5l.5.5v9l-.5.5h-5l-.5-.5v-9zM3 12h4V6H3v6zm0-7h4V4H3v1zm6.5-2h5l.5.5v9l-.5.5h-5l-.5-.5v-9l.5-.5zm.5 9h4v-2h-4v2zm0-4h4V4h-4v4z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/discard.svg b/icons/codicons/discard.svg
new file mode 100644
index 0000000000..a22942fe6c
--- /dev/null
+++ b/icons/codicons/discard.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M3.5 2v3.5L4 6h3.5V5H4.979l.941-.941a3.552 3.552 0 1 1 5.023 5.023L5.746 14.28l.72.72 5.198-5.198A4.57 4.57 0 0 0 5.2 3.339l-.7.7V2h-1z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/edit.svg b/icons/codicons/edit.svg
new file mode 100644
index 0000000000..552fbf976b
--- /dev/null
+++ b/icons/codicons/edit.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M13.23 1h-1.46L3.52 9.25l-.16.22L1 13.59 2.41 15l4.12-2.36.22-.16L15 4.23V2.77L13.23 1zM2.41 13.59l1.51-3 1.45 1.45-2.96 1.55zm3.83-2.06L4.47 9.76l8-8 1.77 1.77-8 8z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/error.svg b/icons/codicons/error.svg
new file mode 100644
index 0000000000..4cfb5bbfab
--- /dev/null
+++ b/icons/codicons/error.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M8.6 1c1.6.1 3.1.9 4.2 2 1.3 1.4 2 3.1 2 5.1 0 1.6-.6 3.1-1.6 4.4-1 1.2-2.4 2.1-4 2.4-1.6.3-3.2.1-4.6-.7-1.4-.8-2.5-2-3.1-3.5C.9 9.2.8 7.5 1.3 6c.5-1.6 1.4-2.9 2.8-3.8C5.4 1.3 7 .9 8.6 1zm.5 12.9c1.3-.3 2.5-1 3.4-2.1.8-1.1 1.3-2.4 1.2-3.8 0-1.6-.6-3.2-1.7-4.3-1-1-2.2-1.6-3.6-1.7-1.3-.1-2.7.2-3.8 1-1.1.8-1.9 1.9-2.3 3.3-.4 1.3-.4 2.7.2 4 .6 1.3 1.5 2.3 2.7 3 1.2.7 2.6.9 3.9.6zM7.9 7.5L10.3 5l.7.7-2.4 2.5 2.4 2.5-.7.7-2.4-2.5-2.4 2.5-.7-.7 2.4-2.5-2.4-2.5.7-.7 2.4 2.5z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/extensions.svg b/icons/codicons/extensions.svg
new file mode 100644
index 0000000000..bbdf50fa9d
--- /dev/null
+++ b/icons/codicons/extensions.svg
@@ -0,0 +1 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M13.5 1.5L15 0h7.5L24 1.5V9l-1.5 1.5H15L13.5 9V1.5zm1.5 0V9h7.5V1.5H15zM0 15V6l1.5-1.5H9L10.5 6v7.5H18l1.5 1.5v7.5L18 24H1.5L0 22.5V15zm9-1.5V6H1.5v7.5H9zM9 15H1.5v7.5H9V15zm1.5 7.5H18V15h-7.5v7.5z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/file-binary.svg b/icons/codicons/file-binary.svg
new file mode 100644
index 0000000000..18bafdacec
--- /dev/null
+++ b/icons/codicons/file-binary.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.57 1.14l3.28 3.3.15.36v9.7l-.5.5h-11l-.5-.5v-13l.5-.5h7.72l.35.14zM3 2v12h10V5l-3-3H3zm1.46 4.052c0 1.287.458 1.93 1.374 1.93.457 0 .807-.173 1.05-.52.246-.348.368-.847.368-1.499C7.252 4.654 6.805 4 5.91 4c-.471 0-.831.175-1.08.526-.247.35-.37.858-.37 1.526zm.862-.022c0-.922.183-1.383.55-1.383.344 0 .516.448.516 1.343s-.176 1.343-.527 1.343c-.36 0-.54-.434-.54-1.303zm3.187 1.886h2.435v-.672h-.792V4l-1.665.336v.687l.82-.177v2.398h-.798v.672zm-1.337 5H4.736v-.672h.798V9.846l-.82.177v-.687L6.38 9v3.244h.792v.671zm1.035-1.931c0 1.287.458 1.93 1.375 1.93.457 0 .807-.173 1.05-.52.245-.348.368-.847.368-1.499 0-1.309-.448-1.963-1.343-1.963-.47 0-.83.175-1.08.526-.246.35-.37.858-.37 1.526zm.862-.022c0-.922.184-1.383.55-1.383.344 0 .516.448.516 1.343s-.175 1.343-.526 1.343c-.36 0-.54-.434-.54-1.303z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/file-code.svg b/icons/codicons/file-code.svg
new file mode 100644
index 0000000000..f6d50e43d4
--- /dev/null
+++ b/icons/codicons/file-code.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.57 1.14l3.28 3.3.15.36v9.7l-.5.5h-11l-.5-.5v-13l.5-.5h7.72l.35.14zM10 5h3l-3-3v3zM3 2v12h10V6H9.5L9 5.5V2H3zm2.062 7.533l1.817-1.828L6.17 7 4 9.179v.707l2.171 2.174.707-.707-1.816-1.82zM8.8 7.714l.7-.709 2.189 2.175v.709L9.5 12.062l-.705-.709 1.831-1.82L8.8 7.714z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/file-media.svg b/icons/codicons/file-media.svg
new file mode 100644
index 0000000000..0667efb05e
--- /dev/null
+++ b/icons/codicons/file-media.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M2 2h6v3.5l.5.5H12v1h1V4.8l-.15-.36-3.28-3.3L9.22 1H1.5l-.5.5v13l.5.5H5v-1H2V2zm7 0l3 3H9V2zm5.5 6h-8l-.5.5v6l.5.5h8l.5-.5v-6l-.5-.5zM14 9v4l-1.63-1.6h-.71l-1.16 1.17-2.13-2.13h-.71L7 11.1V9h7zm-2.8 4.27l.81-.81L13.55 14h-1.62l-.73-.73zM7 14v-1.49l1-1L10.52 14H7zm5.5-3.5a.5.5 0 1 0 0-1 .5.5 0 0 0 0 1z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/file-pdf.svg b/icons/codicons/file-pdf.svg
new file mode 100644
index 0000000000..b1dc9d50a9
--- /dev/null
+++ b/icons/codicons/file-pdf.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M13.85 4.44l-3.28-3.3-.35-.14H2.5l-.5.5V7h1V2h6v3.5l.5.5H13v1h1V4.8l-.15-.36zM10 5V2l3 3h-3zM2.5 8l-.5.5v6l.5.5h11l.5-.5v-6l-.5-.5h-11zM13 13v1H3V9h10v4zm-8-1h-.32v1H4v-3h1.06c.75 0 1.13.36 1.13 1a.94.94 0 0 1-.32.72A1.33 1.33 0 0 1 5 12zm-.06-1.45h-.26v.93h.26c.36 0 .54-.16.54-.47 0-.31-.18-.46-.54-.46zM9 12.58a1.48 1.48 0 0 0 .44-1.12c0-1-.53-1.46-1.6-1.46H6.78v3h1.06A1.6 1.6 0 0 0 9 12.58zm-1.55-.13v-1.9h.33a.94.94 0 0 1 .7.25.91.91 0 0 1 .25.67 1 1 0 0 1-.25.72.94.94 0 0 1-.69.26h-.34zm4.45-.61h-.97V13h-.68v-3h1.74v.55h-1.06v.74h.97v.55z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/file-submodule.svg b/icons/codicons/file-submodule.svg
new file mode 100644
index 0000000000..08261dfbdc
--- /dev/null
+++ b/icons/codicons/file-submodule.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M2 11h1V6.99H2V11zm1-5.01V5.5l.5-.5h4.43l.43.25.43.75h5.71l.5.5v8l-.5.5h-11l-.5-.5V12H1.5l-.5-.5v-9l.5-.5h4.42l.44.25.43.75h5.71l.5.5V6l-1-.03V4H6.5l-.43-.25L5.64 3H2v2.99h1zm5.07.76L7.64 6H4v3h3.15l.41-.74L8 8h6V7H8.5l-.43-.25zM7.45 10H4v4h10V9H8.3l-.41.74-.44.26z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/file-symlink-directory.svg b/icons/codicons/file-symlink-directory.svg
new file mode 100644
index 0000000000..77aac76da7
--- /dev/null
+++ b/icons/codicons/file-symlink-directory.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M7.71 3h6.79l.51.5v10l-.5.5h-13l-.5-.5v-11l.5-.5h5l.35.15.85.85zm6.28 10v-1.51l.01-4v-1.5H7.7l-.86.86-.35.15H2v6h11.99zm-6.5-8h6.5l.01-.99H7.5l-.36-.15-.85-.85H2v3h4.28l.86-.86.35-.15zm2.29 4.07L8.42 7.7l.74-.69 2.22 2.22v.71l-2.29 2.21-.7-.72 1.4-1.35H8.42a2 2 0 0 0-1.35.61A1.8 1.8 0 0 0 6.54 12h-1a2.76 2.76 0 0 1 .81-2 3 3 0 0 1 2-.93h1.43z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/file-symlink-file.svg b/icons/codicons/file-symlink-file.svg
new file mode 100644
index 0000000000..5cb31f51da
--- /dev/null
+++ b/icons/codicons/file-symlink-file.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.57 1.14l3.28 3.3.15.36v9.7l-.5.5H10v-1h3V6H9.5L9 5.5V2H3v4H2V1.5l.5-.5h7.72l.35.14zM10 5h3l-3-3v3zM8.5 7h-7l-.5.5v7l.5.5h7l.5-.5v-7L8.5 7zM8 14H2V8h6v6zM7 9.5v3H6v-1.793l-2.646 2.647-.708-.708L5.293 10H3.53V9H6.5l.5.5z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/file-zip.svg b/icons/codicons/file-zip.svg
new file mode 100644
index 0000000000..95da24528c
--- /dev/null
+++ b/icons/codicons/file-zip.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M2.5 1h11l.5.5v5l-.15.35-.85.86v6.79l-.5.5h-10l-.5-.5v-13l.5-.5zM6 2H5v2h1V2zm0 12h4V7.68l-.85-.85L9 6.47V2H7v2.5l-.5.5H6v1H5V5h-.5L4 4.5V2H3v12h2v-1h1v1zm0-2v1h1v-1H6zm0-1v1H5v-1h1zm0-1h1v1H6v-1zm0-1v1H5V9h1zm0-1h1v1H6V8zm0-1v1H5V7h1zm0 0h1V6H6v1zm6.15.15l.85-.86V2h-3v4.27l.85.85.15.35V14h1V7.5l.15-.35z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/file.svg b/icons/codicons/file.svg
new file mode 100644
index 0000000000..18ce72c80d
--- /dev/null
+++ b/icons/codicons/file.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M13.71 4.29l-3-3L10 1H4L3 2v12l1 1h9l1-1V5l-.29-.71zM13 14H4V2h5v4h4v8zm-3-9V2l3 3h-3z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/files.svg b/icons/codicons/files.svg
new file mode 100644
index 0000000000..8671a7b93f
--- /dev/null
+++ b/icons/codicons/files.svg
@@ -0,0 +1 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M17.5 0h-9L7 1.5V6H2.5L1 7.5v15.07L2.5 24h12.07L16 22.57V18h4.7l1.3-1.43V4.5L17.5 0zm0 2.12l2.38 2.38H17.5V2.12zm-3 20.38h-12v-15H7v9.07L8.5 18h6v4.5zm6-6h-12v-15H16V6h4.5v10.5z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/folder-active.svg b/icons/codicons/folder-active.svg
new file mode 100644
index 0000000000..d50cabfe08
--- /dev/null
+++ b/icons/codicons/folder-active.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M7.71 3h6.79l.51.5v4.507A4.997 4.997 0 0 0 14 7.416V5.99H7.69l-.86.86-.35.15H1.99v6H7.1c.07.348.177.682.316 1H1.51l-.5-.5v-11l.5-.5h5l.35.15.85.85zm-.22 2h6.5l.01-.99H7.5l-.36-.15-.85-.85H2v3h4.28l.86-.86.35-.15z"/><path fill-rule="evenodd" clip-rule="evenodd" d="M9.778 8.674a4 4 0 1 1 4.444 6.652 4 4 0 0 1-4.444-6.652zm2.13 4.99l2.387-3.182-.8-.6-2.077 2.769-1.301-1.041-.625.78 1.704 1.364.713-.09z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/folder-library.svg b/icons/codicons/folder-library.svg
new file mode 100644
index 0000000000..b5a25acaea
--- /dev/null
+++ b/icons/codicons/folder-library.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M7.70996 3H14.5L15.01 3.5V7H14V5.98999H7.68994L6.82996 6.84998L6.47998 7H1.98999V7.48999V11.49V13H7V14H1.51001L1.01001 13.5V6.5V2.5L1.51001 2H6.51001L6.85999 2.15002L7.70996 3ZM7.48999 5H13.99L14 4.01001H7.5L7.14001 3.85999L6.29004 3.01001H2V6.01001H6.28003L7.14001 5.15002L7.48999 5Z"/><rect x="8" y="8" width="1" height="6"/><rect x="10" y="8" width="1" height="6"/><rect x="12.0041" y="8.35193" width="1" height="6" transform="rotate(-20 12.0041 8.35193)"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/folder-opened.svg b/icons/codicons/folder-opened.svg
new file mode 100644
index 0000000000..52eb52c934
--- /dev/null
+++ b/icons/codicons/folder-opened.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M1.5 14h11l.48-.37 2.63-7-.48-.63H14V3.5l-.5-.5H7.71l-.86-.85L6.5 2h-5l-.5.5v11l.5.5zM2 3h4.29l.86.85.35.15H13v2H8.5l-.35.15-.86.85H3.5l-.47.34-1 3.08L2 3zm10.13 10H2.19l1.67-5H7.5l.35-.15.86-.85h5.79l-2.37 6z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/folder.svg b/icons/codicons/folder.svg
new file mode 100644
index 0000000000..2940f745a0
--- /dev/null
+++ b/icons/codicons/folder.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M14.5 3H7.71l-.85-.85L6.51 2h-5l-.5.5v11l.5.5h13l.5-.5v-10L14.5 3zm-.51 8.49V13h-12V7h4.49l.35-.15.86-.86H14v1.5l-.01 4zm0-6.49h-6.5l-.35.15-.86.86H2v-3h4.29l.85.85.36.15H14l-.01.99z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/gear.svg b/icons/codicons/gear.svg
new file mode 100644
index 0000000000..8ee3ec48ab
--- /dev/null
+++ b/icons/codicons/gear.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M9.1 4.4L8.6 2H7.4l-.5 2.4-.7.3-2-1.3-.9.8 1.3 2-.2.7-2.4.5v1.2l2.4.5.3.8-1.3 2 .8.8 2-1.3.8.3.4 2.3h1.2l.5-2.4.8-.3 2 1.3.8-.8-1.3-2 .3-.8 2.3-.4V7.4l-2.4-.5-.3-.8 1.3-2-.8-.8-2 1.3-.7-.2zM9.4 1l.5 2.4L12 2.1l2 2-1.4 2.1 2.4.4v2.8l-2.4.5L14 12l-2 2-2.1-1.4-.5 2.4H6.6l-.5-2.4L4 13.9l-2-2 1.4-2.1L1 9.4V6.6l2.4-.5L2.1 4l2-2 2.1 1.4.4-2.4h2.8zm.6 7c0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2 2 .9 2 2zM8 9c.6 0 1-.4 1-1s-.4-1-1-1-1 .4-1 1 .4 1 1 1z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/git-commit.svg b/icons/codicons/git-commit.svg
new file mode 100644
index 0000000000..9c11c79b37
--- /dev/null
+++ b/icons/codicons/git-commit.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M7.5 0H8.5V4.03095C10.4732 4.277 12 5.96019 12 8C12 10.0398 10.4732 11.723 8.5 11.9691V16H7.5V11.9691C5.52684 11.723 4 10.0398 4 8C4 5.96019 5.52684 4.277 7.5 4.03095V0ZM8 10.6C9.43594 10.6 10.6 9.43594 10.6 8C10.6 6.56406 9.43594 5.4 8 5.4C6.56406 5.4 5.4 6.56406 5.4 8C5.4 9.43594 6.56406 10.6 8 10.6Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/git-compare.svg b/icons/codicons/git-compare.svg
new file mode 100644
index 0000000000..e08789ce45
--- /dev/null
+++ b/icons/codicons/git-compare.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M7.389 12.99l-1.27-1.27.67-.7 2.13 2.13v.7l-2.13 2.13-.71-.71L7.349 14h-1.85a2.49 2.49 0 0 1-2.5-2.5V5.95a2.59 2.59 0 0 1-1.27-.68 2.52 2.52 0 0 1-.54-2.73A2.5 2.5 0 0 1 3.499 1a2.45 2.45 0 0 1 1 .19 2.48 2.48 0 0 1 1.35 1.35c.133.317.197.658.19 1a2.5 2.5 0 0 1-2 2.45v5.5a1.5 1.5 0 0 0 1.5 1.5h1.85zm-4.68-8.25a1.5 1.5 0 0 0 2.08-2.08 1.55 1.55 0 0 0-.68-.56 1.49 1.49 0 0 0-.86-.08 1.49 1.49 0 0 0-1.18 1.18 1.49 1.49 0 0 0 .08.86c.117.277.311.513.56.68zm10.33 6.3c.48.098.922.335 1.27.68a2.51 2.51 0 0 1 .31 3.159 2.5 2.5 0 1 1-3.47-3.468c.269-.182.571-.308.89-.37V5.49a1.5 1.5 0 0 0-1.5-1.5h-1.85l1.27 1.27-.71.71-2.13-2.13v-.7l2.13-2.13.71.71-1.27 1.27h1.85a2.49 2.49 0 0 1 2.5 2.5v5.55zm-.351 3.943a1.5 1.5 0 0 0 1.1-2.322 1.55 1.55 0 0 0-.68-.56 1.49 1.49 0 0 0-.859-.08 1.49 1.49 0 0 0-1.18 1.18 1.49 1.49 0 0 0 .08.86 1.5 1.5 0 0 0 1.539.922z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/git-merge.svg b/icons/codicons/git-merge.svg
new file mode 100644
index 0000000000..92ea23132c
--- /dev/null
+++ b/icons/codicons/git-merge.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M13.273 7.73a2.51 2.51 0 0 0-3.159-.31 2.5 2.5 0 0 0-.921 1.12 2.23 2.23 0 0 0-.13.44 4.52 4.52 0 0 1-4-4 2.23 2.23 0 0 0 .44-.13 2.5 2.5 0 0 0 1.54-2.31 2.45 2.45 0 0 0-.19-1A2.48 2.48 0 0 0 5.503.19a2.45 2.45 0 0 0-1-.19 2.5 2.5 0 0 0-2.31 1.54 2.52 2.52 0 0 0 .54 2.73c.35.343.79.579 1.27.68v5.1a2.411 2.411 0 0 0-.89.37 2.5 2.5 0 1 0 3.47 3.468 2.5 2.5 0 0 0 .42-1.387 2.45 2.45 0 0 0-.19-1 2.48 2.48 0 0 0-1.81-1.49v-2.4a5.52 5.52 0 0 0 2 1.73 5.65 5.65 0 0 0 2.09.6 2.5 2.5 0 0 0 4.95-.49 2.51 2.51 0 0 0-.77-1.72zm-8.2 3.38c.276.117.512.312.68.56a1.5 1.5 0 0 1-2.08 2.08 1.55 1.55 0 0 1-.56-.68 1.49 1.49 0 0 1-.08-.86 1.49 1.49 0 0 1 1.18-1.18 1.49 1.49 0 0 1 .86.08zM4.503 4a1.5 1.5 0 0 1-1.39-.93 1.49 1.49 0 0 1-.08-.86 1.49 1.49 0 0 1 1.18-1.18 1.49 1.49 0 0 1 .86.08A1.5 1.5 0 0 1 4.503 4zm8.06 6.56a1.5 1.5 0 0 1-2.45-.49 1.49 1.49 0 0 1-.08-.86 1.49 1.49 0 0 1 1.18-1.18 1.49 1.49 0 0 1 .86.08 1.499 1.499 0 0 1 .49 2.45z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/go-to-file.svg b/icons/codicons/go-to-file.svg
new file mode 100644
index 0000000000..4c688f2fce
--- /dev/null
+++ b/icons/codicons/go-to-file.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M6 5.914l2.06-2.06v-.708L5.915 1l-.707.707.043.043.25.25 1 1h-3a2.5 2.5 0 0 0 0 5H4V7h-.5a1.5 1.5 0 1 1 0-3h3L5.207 5.293 5.914 6 6 5.914zM11 2H8.328l-1-1H12l.71.29 3 3L16 5v9l-1 1H6l-1-1V6.5l1 .847V14h9V6h-4V2zm1 0v3h3l-3-3z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/group-by-ref-type.svg b/icons/codicons/group-by-ref-type.svg
new file mode 100644
index 0000000000..4c688a0b02
--- /dev/null
+++ b/icons/codicons/group-by-ref-type.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 1h2v1H2v12h1.5v1h-2l-.5-.5v-13l.5-.5zm6 6h-2L5 6.5v-2l.5-.5h2l.5.5v2l-.5.5zM6 6h1V5H6v1zm7.5 1h-3l-.5-.5v-3l.5-.5h3l.5.5v3l-.5.5zM11 6h2V4h-2v2zm-3.5 6h-2l-.5-.5v-2l.5-.5h2l.5.5v2l-.5.5zM6 11h1v-1H6v1zm7.5 2h-3l-.5-.5v-3l.5-.5h3l.5.5v3l-.5.5zM11 12h2v-2h-2v2zm-1-2H8v1h2v-1zm0-5H8v1h2V5z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/history.svg b/icons/codicons/history.svg
new file mode 100644
index 0000000000..53d41f7c7b
--- /dev/null
+++ b/icons/codicons/history.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M13.507 12.324a7 7 0 0 0 .065-8.56A7 7 0 0 0 2 4.393V2H1v3.5l.5.5H5V5H2.811a6.008 6.008 0 1 1-.135 5.77l-.887.462a7 7 0 0 0 11.718 1.092zm-3.361-.97l.708-.707L8 7.792V4H7v4l.146.354 3 3z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/info.svg b/icons/codicons/info.svg
new file mode 100644
index 0000000000..fff5a9fbcf
--- /dev/null
+++ b/icons/codicons/info.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M8.568 1.031A6.8 6.8 0 0 1 12.76 3.05a7.06 7.06 0 0 1 .46 9.39 6.85 6.85 0 0 1-8.58 1.74 7 7 0 0 1-3.12-3.5 7.12 7.12 0 0 1-.23-4.71 7 7 0 0 1 2.77-3.79 6.8 6.8 0 0 1 4.508-1.149zM9.04 13.88a5.89 5.89 0 0 0 3.41-2.07 6.07 6.07 0 0 0-.4-8.06 5.82 5.82 0 0 0-7.43-.74 6.06 6.06 0 0 0 .5 10.29 5.81 5.81 0 0 0 3.92.58zM7.375 6h1.25V5h-1.25v1zm1.25 1v4h-1.25V7h1.25z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/inspect.svg b/icons/codicons/inspect.svg
new file mode 100644
index 0000000000..2de8bfb0c3
--- /dev/null
+++ b/icons/codicons/inspect.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M1 3l1-1h12l1 1v6h-1V3H2v8h5v1H2l-1-1V3zm14.707 9.707L9 6v9.414l2.707-2.707h4zM10 13V8.414l3.293 3.293h-2L10 13z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/issues.svg b/icons/codicons/issues.svg
new file mode 100644
index 0000000000..666a3baac7
--- /dev/null
+++ b/icons/codicons/issues.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M7.50002 1C6.21445 1 4.95774 1.38123 3.88882 2.09546C2.8199 2.80969 1.98674 3.82485 1.49478 5.01257C1.00281 6.20029 0.874098 7.50719 1.1249 8.76807C1.37571 10.0289 1.99479 11.1872 2.90383 12.0962C3.81287 13.0052 4.97108 13.6243 6.23196 13.8751C7.49283 14.1259 8.79973 13.9972 9.98745 13.5052C11.1752 13.0133 12.1903 12.1801 12.9046 11.1112C13.6188 10.0423 14 8.78558 14 7.5C14 5.77609 13.3152 4.1228 12.0962 2.90381C10.8772 1.68482 9.22393 1 7.50002 1ZM7.50002 13C6.41223 13 5.34883 12.6775 4.44436 12.0731C3.53989 11.4688 2.83501 10.6097 2.41873 9.60474C2.00244 8.59974 1.89352 7.4939 2.10574 6.427C2.31796 5.36011 2.8418 4.38015 3.61099 3.61096C4.38018 2.84177 5.36013 2.31793 6.42703 2.10571C7.49392 1.89349 8.59977 2.00242 9.60476 2.4187C10.6098 2.83498 11.4688 3.53987 12.0731 4.44434C12.6775 5.34881 13 6.4122 13 7.5C13 8.95869 12.4205 10.3576 11.3891 11.389C10.3576 12.4205 8.95871 13 7.50002 13Z"/><circle cx="7.50002" cy="7.5" r="1"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/json.svg b/icons/codicons/json.svg
new file mode 100644
index 0000000000..ff10d4b248
--- /dev/null
+++ b/icons/codicons/json.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M6 2.984V2h-.09c-.313 0-.616.062-.909.185a2.33 2.33 0 0 0-.775.53 2.23 2.23 0 0 0-.493.753v.001a3.542 3.542 0 0 0-.198.83v.002a6.08 6.08 0 0 0-.024.863c.012.29.018.58.018.869 0 .203-.04.393-.117.572v.001a1.504 1.504 0 0 1-.765.787 1.376 1.376 0 0 1-.558.115H2v.984h.09c.195 0 .38.04.556.121l.001.001c.178.078.329.184.455.318l.002.002c.13.13.233.285.307.465l.001.002c.078.18.117.368.117.566 0 .29-.006.58-.018.869-.012.296-.004.585.024.87v.001c.033.283.099.558.197.824v.001c.106.273.271.524.494.753.223.23.482.407.775.53.293.123.596.185.91.185H6v-.984h-.09c-.2 0-.387-.038-.563-.115a1.613 1.613 0 0 1-.457-.32 1.659 1.659 0 0 1-.309-.467c-.074-.18-.11-.37-.11-.573 0-.228.003-.453.011-.672.008-.228.008-.45 0-.665a4.639 4.639 0 0 0-.055-.64 2.682 2.682 0 0 0-.168-.609A2.284 2.284 0 0 0 3.522 8a2.284 2.284 0 0 0 .738-.955c.08-.192.135-.393.168-.602.033-.21.051-.423.055-.64.008-.22.008-.442 0-.666-.008-.224-.012-.45-.012-.678a1.47 1.47 0 0 1 .877-1.354 1.33 1.33 0 0 1 .563-.121H6zm4 10.032V14h.09c.313 0 .616-.062.909-.185.293-.123.552-.3.775-.53.223-.23.388-.48.493-.753v-.001c.1-.266.165-.543.198-.83v-.002c.028-.28.036-.567.024-.863-.012-.29-.018-.58-.018-.869 0-.203.04-.393.117-.572v-.001a1.502 1.502 0 0 1 .765-.787 1.38 1.38 0 0 1 .558-.115H14v-.984h-.09c-.196 0-.381-.04-.557-.121l-.001-.001a1.376 1.376 0 0 1-.455-.318l-.002-.002a1.415 1.415 0 0 1-.307-.465v-.002a1.405 1.405 0 0 1-.118-.566c0-.29.006-.58.018-.869a6.174 6.174 0 0 0-.024-.87v-.001a3.537 3.537 0 0 0-.197-.824v-.001a2.23 2.23 0 0 0-.494-.753 2.331 2.331 0 0 0-.775-.53 2.325 2.325 0 0 0-.91-.185H10v.984h.09c.2 0 .387.038.562.115.174.082.326.188.457.32.127.134.23.29.309.467.074.18.11.37.11.573 0 .228-.003.452-.011.672-.008.228-.008.45 0 .665.004.222.022.435.055.64.033.214.089.416.168.609a2.285 2.285 0 0 0 .738.955 2.285 2.285 0 0 0-.738.955 2.689 2.689 0 0 0-.168.602c-.033.21-.051.423-.055.64a9.15 9.15 0 0 0 0 .666c.008.224.012.45.012.678a1.471 1.471 0 0 1-.877 1.354 1.33 1.33 0 0 1-.563.121H10z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/key.svg b/icons/codicons/key.svg
new file mode 100644
index 0000000000..a8de84794a
--- /dev/null
+++ b/icons/codicons/key.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M11.351 1.091a4.528 4.528 0 0 1 3.44 3.16c.215.724.247 1.49.093 2.23a4.583 4.583 0 0 1-4.437 3.6c-.438 0-.874-.063-1.293-.19l-.8.938-.379.175H7v1.5l-.5.5H5v1.5l-.5.5h-3l-.5-.5v-2.307l.146-.353L6.12 6.87a4.464 4.464 0 0 1-.2-1.405 4.528 4.528 0 0 1 5.431-4.375zm1.318 7.2a3.568 3.568 0 0 0 1.239-2.005l.004.005A3.543 3.543 0 0 0 9.72 2.08a3.576 3.576 0 0 0-2.8 3.4c-.01.456.07.908.239 1.33l-.11.543L2 12.404v1.6h2v-1.5l.5-.5H6v-1.5l.5-.5h1.245l.876-1.016.561-.14a3.47 3.47 0 0 0 1.269.238 3.568 3.568 0 0 0 2.218-.795zm-.838-2.732a1 1 0 1 0-1.662-1.11 1 1 0 0 0 1.662 1.11z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-activitybar-left.svg b/icons/codicons/layout-activitybar-left.svg
new file mode 100644
index 0000000000..87378a21e9
--- /dev/null
+++ b/icons/codicons/layout-activitybar-left.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M2 1L1 2V14L2 15H14L15 14V2L14 1H2ZM14 14H4V2H14V14Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-activitybar-right.svg b/icons/codicons/layout-activitybar-right.svg
new file mode 100644
index 0000000000..43a89406a0
--- /dev/null
+++ b/icons/codicons/layout-activitybar-right.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M2 1L1 2V14L2 15H14L15 14V2L14 1H2ZM2 14V2H12V14H2Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-centered.svg b/icons/codicons/layout-centered.svg
new file mode 100644
index 0000000000..9865f136bd
--- /dev/null
+++ b/icons/codicons/layout-centered.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M2 1L1 2V14L2 15H14L15 14V2L14 1H2ZM2 14V2H6V14H2ZM10 14V2H14V14H10Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-menubar.svg b/icons/codicons/layout-menubar.svg
new file mode 100644
index 0000000000..98666ab70a
--- /dev/null
+++ b/icons/codicons/layout-menubar.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M6 3H3V4H6V3Z"/><path d="M3 5H6V6H3V5Z"/><path d="M6 7H3V8H6V7Z"/><path d="M2 1L1 2V14L2 15H14L15 14V2L14 1H2ZM2 14V2H14V14H2Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-panel-center.svg b/icons/codicons/layout-panel-center.svg
new file mode 100644
index 0000000000..d720c12053
--- /dev/null
+++ b/icons/codicons/layout-panel-center.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M2 1L1 2V14L2 15H14L15 14V2L14 1H2ZM2 14V2H4V14H2ZM5 10V2H11V10H5ZM12 2H14V14H12V2Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-panel-justify.svg b/icons/codicons/layout-panel-justify.svg
new file mode 100644
index 0000000000..67a749c395
--- /dev/null
+++ b/icons/codicons/layout-panel-justify.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M2 1L1 2V14L2 15H14L15 14V2L14 1H2ZM2 10V2H4V10H2ZM5 10V2H11V10H5ZM12 10V2H14V10H12Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-panel-left.svg b/icons/codicons/layout-panel-left.svg
new file mode 100644
index 0000000000..181dd75876
--- /dev/null
+++ b/icons/codicons/layout-panel-left.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M1 2L2 1H14L15 2V14L14 15H2L1 14V2ZM2 2V10H10V2H2ZM11 2V14H14V2H11Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-panel-off.svg b/icons/codicons/layout-panel-off.svg
new file mode 100644
index 0000000000..fc8464f43a
--- /dev/null
+++ b/icons/codicons/layout-panel-off.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M2 1.00073L1 2.00073V14.0007L2 15.0007H14L15 14.0007V2.00073L14 1.00073H2ZM2 10.0007V2.00073H14V10.0007H2ZM2 11.0007H14V14.0007H2V11.0007Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-panel-right.svg b/icons/codicons/layout-panel-right.svg
new file mode 100644
index 0000000000..7cf4177249
--- /dev/null
+++ b/icons/codicons/layout-panel-right.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M1 2L2 1H14L15 2V14L14 15H2L1 14V2ZM2 2V14H5V2H2ZM6 2V10H14V2H6Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-panel.svg b/icons/codicons/layout-panel.svg
new file mode 100644
index 0000000000..7ac17fb7d5
--- /dev/null
+++ b/icons/codicons/layout-panel.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M2 1L1 2V14L2 15H14L15 14V2L14 1H2ZM2 10V2H14V10H2Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-sidebar-left-off.svg b/icons/codicons/layout-sidebar-left-off.svg
new file mode 100644
index 0000000000..50019bfe5f
--- /dev/null
+++ b/icons/codicons/layout-sidebar-left-off.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M2 1.00073L1 2.00073V14.0007L2 15.0007H14L15 14.0007V2.00073L14 1.00073H2ZM2 14.0007V2.00073H6V14.0007H2ZM7 14.0007V2.00073H14V14.0007H7Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-sidebar-left.svg b/icons/codicons/layout-sidebar-left.svg
new file mode 100644
index 0000000000..b513bdac67
--- /dev/null
+++ b/icons/codicons/layout-sidebar-left.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M2 1L1 2V14L2 15H14L15 14V2L14 1H2ZM14 14H7V2H14V14Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-sidebar-right-off.svg b/icons/codicons/layout-sidebar-right-off.svg
new file mode 100644
index 0000000000..951b957155
--- /dev/null
+++ b/icons/codicons/layout-sidebar-right-off.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M2 1.00073L1 2.00073V14.0007L2 15.0007H14L15 14.0007V2.00073L14 1.00073H2ZM2 14.0007V2.00073H9V14.0007H2ZM10 14.0007V2.00073H14V14.0007H10Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-sidebar-right.svg b/icons/codicons/layout-sidebar-right.svg
new file mode 100644
index 0000000000..1017debe0e
--- /dev/null
+++ b/icons/codicons/layout-sidebar-right.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M2 1L1 2V14L2 15H14L15 14V2L14 1H2ZM2 14V2H9V14H2Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout-statusbar.svg b/icons/codicons/layout-statusbar.svg
new file mode 100644
index 0000000000..7f60e5b123
--- /dev/null
+++ b/icons/codicons/layout-statusbar.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M2 1.00073L1 2.00073V14.0007L2 15.0007H14L15 14.0007V2.00073L14 1.00073H2ZM2 13.0007V2.00073H14V13.0007H2Z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/layout.svg b/icons/codicons/layout.svg
new file mode 100644
index 0000000000..655d365c8c
--- /dev/null
+++ b/icons/codicons/layout.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M3 2L2 3V13L3 14H7L8 13V3L7 2H3ZM3 13V3H7V13H3Z"/><path d="M10 3L11 2H14L15 3V6L14 7H11L10 6V3ZM11 3V6H14V3H11Z"/><path d="M10 10L11 9H14L15 10V13L14 14H11L10 13V10ZM11 10V13H14V10H11Z"/></svg>
\ No newline at end of file
diff --git a/icons/lightbulb-autofix.svg b/icons/codicons/lightbulb-autofix.svg
similarity index 100%
rename from icons/lightbulb-autofix.svg
rename to icons/codicons/lightbulb-autofix.svg
diff --git a/icons/lightbulb.svg b/icons/codicons/lightbulb.svg
similarity index 100%
rename from icons/lightbulb.svg
rename to icons/codicons/lightbulb.svg
diff --git a/icons/codicons/link-external.svg b/icons/codicons/link-external.svg
new file mode 100644
index 0000000000..9a594b72b6
--- /dev/null
+++ b/icons/codicons/link-external.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M1.5 1H6v1H2v12h12v-4h1v4.5l-.5.5h-13l-.5-.5v-13l.5-.5z"/><path d="M15 1.5V8h-1V2.707L7.243 9.465l-.707-.708L13.293 2H8V1h6.5l.5.5z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/link.svg b/icons/codicons/link.svg
new file mode 100644
index 0000000000..46bf4d5340
--- /dev/null
+++ b/icons/codicons/link.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M4.4 3h3.085a3.4 3.4 0 0 1 3.4 3.4v.205A3.4 3.4 0 0 1 7.485 10H7V9h.485A2.4 2.4 0 0 0 9.88 6.61V6.4A2.4 2.4 0 0 0 7.49 4H4.4A2.4 2.4 0 0 0 2 6.4v.205A2.394 2.394 0 0 0 4 8.96v1a3.4 3.4 0 0 1-3-3.35V6.4A3.405 3.405 0 0 1 4.4 3zM12 7.04v-1a3.4 3.4 0 0 1 3 3.36v.205A3.405 3.405 0 0 1 11.605 13h-3.09A3.4 3.4 0 0 1 5.12 9.61V9.4A3.4 3.4 0 0 1 8.515 6H9v1h-.485A2.4 2.4 0 0 0 6.12 9.4v.205A2.4 2.4 0 0 0 8.515 12h3.09A2.4 2.4 0 0 0 14 9.61V9.4a2.394 2.394 0 0 0-2-2.36z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/merge.svg b/icons/codicons/merge.svg
new file mode 100644
index 0000000000..0e3049f315
--- /dev/null
+++ b/icons/codicons/merge.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.5 4.646L8.354 2.5h-.707L5.5 4.646l.707.707L7.3 4.261V5.28h-.02v.456l.025.001.006.319c.004.187.02.379.05.574.03.195.069.39.117.586.048.195.114.404.2.627.155.379.343.722.565 1.031.221.309.46.598.715.867.255.27.508.535.76.797.25.262.478.541.681.838.203.297.368.621.494.973.125.351.188.755.188 1.213v.884H12.5v-.884a5.991 5.991 0 0 0-.166-1.39 4.638 4.638 0 0 0-.427-1.1 5.875 5.875 0 0 0-.604-.897c-.222-.27-.453-.527-.693-.774-.24-.246-.471-.492-.693-.738a6.39 6.39 0 0 1-.604-.785 3.794 3.794 0 0 1-.433-.914 3.676 3.676 0 0 1-.16-1.13V5.28h-.001v-1l1.074 1.074.707-.708zM7.042 9.741a8.19 8.19 0 0 0 .329-.369 6.06 6.06 0 0 1-.62-1.15L6.744 8.2a7.26 7.26 0 0 1-.095-.263c-.17.256-.359.498-.565.726-.222.246-.453.492-.693.738-.24.247-.47.504-.693.774-.221.27-.423.568-.604.896a4.643 4.643 0 0 0-.427 1.102 5.995 5.995 0 0 0-.166 1.389v.884h1.42v-.884c0-.457.062-.862.188-1.213.125-.352.29-.676.493-.973.203-.297.43-.576.682-.838.251-.262.504-.527.76-.797z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/multiple-windows.svg b/icons/codicons/multiple-windows.svg
new file mode 100644
index 0000000000..7ee7455754
--- /dev/null
+++ b/icons/codicons/multiple-windows.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M6 1.5l.5-.5h8l.5.5v7l-.5.5H12V8h2V4H7v1H6V1.5zM7 2v1h7V2H7zM1.5 7l-.5.5v7l.5.5h8l.5-.5v-7L9.5 7h-8zM2 9V8h7v1H2zm0 1h7v4H2v-4z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/new-file.svg b/icons/codicons/new-file.svg
new file mode 100644
index 0000000000..caac07c667
--- /dev/null
+++ b/icons/codicons/new-file.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M9.5 1.1l3.4 3.5.1.4v2h-1V6H8V2H3v11h4v1H2.5l-.5-.5v-12l.5-.5h6.7l.3.1zM9 2v3h2.9L9 2zm4 14h-1v-3H9v-1h3V9h1v3h3v1h-3v3z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/new-folder.svg b/icons/codicons/new-folder.svg
new file mode 100644
index 0000000000..3ada63a64a
--- /dev/null
+++ b/icons/codicons/new-folder.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M14.5 2H7.71l-.85-.85L6.51 1h-5l-.5.5v11l.5.5H7v-1H1.99V6h4.49l.35-.15.86-.86H14v1.5l-.001.51h1.011V2.5L14.5 2zm-.51 2h-6.5l-.35.15-.86.86H2v-3h4.29l.85.85.36.15H14l-.01.99zM13 16h-1v-3H9v-1h3V9h1v3h3v1h-3v3z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/open-preview.svg b/icons/codicons/open-preview.svg
new file mode 100644
index 0000000000..765c739044
--- /dev/null
+++ b/icons/codicons/open-preview.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M3 1h11l1 1v5.3a3.21 3.21 0 0 0-1-.3V2H9v10.88L7.88 14H3l-1-1V2l1-1zm0 12h5V2H3v11zm10.379-4.998a2.53 2.53 0 0 0-1.19.348h-.03a2.51 2.51 0 0 0-.799 3.53L9 14.23l.71.71 2.35-2.36c.325.22.7.358 1.09.4a2.47 2.47 0 0 0 1.14-.13 2.51 2.51 0 0 0 1-.63 2.46 2.46 0 0 0 .58-1 2.63 2.63 0 0 0 .07-1.15 2.53 2.53 0 0 0-1.35-1.81 2.53 2.53 0 0 0-1.211-.258zm.24 3.992a1.5 1.5 0 0 1-.979-.244 1.55 1.55 0 0 1-.56-.68 1.49 1.49 0 0 1-.08-.86 1.49 1.49 0 0 1 1.18-1.18 1.49 1.49 0 0 1 .86.08c.276.117.512.311.68.56a1.5 1.5 0 0 1-1.1 2.324z"/></svg>
\ No newline at end of file
diff --git a/icons/plugin-icon.svg b/icons/codicons/plugin-icon.svg
similarity index 100%
rename from icons/plugin-icon.svg
rename to icons/codicons/plugin-icon.svg
diff --git a/icons/codicons/references.svg b/icons/codicons/references.svg
new file mode 100644
index 0000000000..280b3d8375
--- /dev/null
+++ b/icons/codicons/references.svg
@@ -0,0 +1 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M11.105 4.561l-3.43 3.427-1.134-1.12 2.07-2.08h-4.8a2.4 2.4 0 1 0 0 4.8h.89v1.6h-.88a4 4 0 0 1 0-7.991h4.8L6.54 1.13 7.675 0l3.43 3.432v1.13zM16.62 24h-9.6l-.8-.8V10.412l.8-.8h9.6l.8.8V23.2l-.8.8zm-8.8-1.6h8V11.212h-8V22.4zm5.6-20.798h9.6l.8.8v12.786l-.8.8h-4v-1.6h3.2V3.2h-8v4.787h-1.6V2.401l.8-.8zm.8 11.186h-4.8v1.6h4.8v-1.6zm-4.8 3.2h4.8v1.6h-4.8v-1.6zm4.8 3.2h-4.8v1.6h4.8v-1.6zm1.6-14.4h4.8v1.6h-4.8v-1.6zm4.8 6.4h-1.6v1.6h1.6v-1.6zm-3.338-3.176v-.024h3.338v1.6h-1.762l-1.576-1.576z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/refresh.svg b/icons/codicons/refresh.svg
new file mode 100644
index 0000000000..9196015694
--- /dev/null
+++ b/icons/codicons/refresh.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M4.681 3H2V2h3.5l.5.5V6H5V4a5 5 0 1 0 4.53-.761l.302-.954A6 6 0 1 1 4.681 3z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/remote-explorer.svg b/icons/codicons/remote-explorer.svg
new file mode 100644
index 0000000000..0152f47296
--- /dev/null
+++ b/icons/codicons/remote-explorer.svg
@@ -0,0 +1 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.344 2.125h20.312l.782.781v8.599a7.825 7.825 0 0 0-1.563-.912V3.688H2.125V17.75h7.813a7.813 7.813 0 0 0 1.562 4.688H5.25v-1.563h4.688v-1.563H1.344l-.782-.78V2.905l.782-.781zM17.75 11.5a6.25 6.25 0 1 0 0 12.5 6.25 6.25 0 0 0 0-12.5zm0 10.938a4.688 4.688 0 1 1 0-9.377 4.688 4.688 0 0 1 0 9.377zm2.603-3.132L18.2 17.153 20.353 15l.647.646-1.506 1.507L21 18.659l-.647.647zM15 17.246l1.506 1.507L15 20.259l.647.647 2.153-2.153-2.153-2.153-.647.646z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/remove.svg b/icons/codicons/remove.svg
new file mode 100644
index 0000000000..cf31dfe1d4
--- /dev/null
+++ b/icons/codicons/remove.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M15 8H1V7h14v1z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/repo-clone.svg b/icons/codicons/repo-clone.svg
new file mode 100644
index 0000000000..ab8f19a75b
--- /dev/null
+++ b/icons/codicons/repo-clone.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 10H4V2h4V1H3.74a1.9 1.9 0 0 0-.67.13 1.66 1.66 0 0 0-.57.41 1.73 1.73 0 0 0-.37.59 1.68 1.68 0 0 0-.13.62v9.5a1.75 1.75 0 0 0 1.07 1.62 1.9 1.9 0 0 0 .67.13H4v-1h-.26a.72.72 0 0 1-.29-.06.78.78 0 0 1-.4-.4.93.93 0 0 1 0-.29v-.5a.93.93 0 0 1 0-.29.78.78 0 0 1 .4-.4.72.72 0 0 1 .29-.06H13v2H9v1h4.5l.5-.5V9h-1v1zM6 3H5v1h1V3zM5 5h1v1H5V5zm0 2h1v1H5V7zm.28 8H5v-3h3v3h-.28L6.5 13.49 5.28 15zM10 1h4.5l.5.5v6l-.5.5H12v1h-1V8h-1a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1zm.5 6h.5V6h-.5a.5.5 0 0 0 0 1zM12 7h2V6h-2v1zm-1-2h3V2h-3v3z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/repo-force-push.svg b/icons/codicons/repo-force-push.svg
new file mode 100644
index 0000000000..37c9a3dcf5
--- /dev/null
+++ b/icons/codicons/repo-force-push.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M3.74 1h9.76l.5.5v12l-.5.5H10v-1h3v-2h-3v-1h3V2H4v8h3v1H3.74a.74.74 0 0 0-.74.75v.5a.74.74 0 0 0 .74.75H7v1H3.74A1.74 1.74 0 0 1 2 12.25v-9.5A1.74 1.74 0 0 1 3.74 1zm1.6 4.83l.71.7L8 4.58v1.45L5.38 8.65l.71.7 1.92-1.92V15h1V7.328l2.03 2.022.7-.7L9 5.9V4.538l2 1.992.7-.7L8.88 3h-.71L5.34 5.83z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/repo-forked.svg b/icons/codicons/repo-forked.svg
new file mode 100644
index 0000000000..0cc80938ea
--- /dev/null
+++ b/icons/codicons/repo-forked.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M14 4a2 2 0 1 0-2.47 1.94V7a.48.48 0 0 1-.27.44L8.49 8.88l-2.76-1.4A.49.49 0 0 1 5.46 7V5.94a2 2 0 1 0-1 0V7a1.51 1.51 0 0 0 .82 1.34L8 9.74v1.32a2 2 0 1 0 1 0V9.74l2.7-1.36A1.49 1.49 0 0 0 12.52 7V5.92A2 2 0 0 0 14 4zM4 4a1 1 0 1 1 2 0 1 1 0 0 1-2 0zm5.47 9a1 1 0 1 1-2 0 1 1 0 0 1 2 0zM12 5a1 1 0 1 1 0-2 1 1 0 0 1 0 2z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/repo-pull.svg b/icons/codicons/repo-pull.svg
new file mode 100644
index 0000000000..821095901d
--- /dev/null
+++ b/icons/codicons/repo-pull.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 1.5V3h-1V2H3v8h10v3.5l-.5.5H8v-1h4v-2H2.735a.72.72 0 0 0-.285.06.74.74 0 0 0-.4.4.93.93 0 0 0-.05.29v.5a.93.93 0 0 0 .05.29.74.74 0 0 0 .4.4c.091.04.19.06.29.06H3v1h-.26a1.9 1.9 0 0 1-.67-.13 1.77 1.77 0 0 1-.94-.95 1.7 1.7 0 0 1-.13-.67v-9.5a1.7 1.7 0 0 1 .13-.62 1.77 1.77 0 0 1 .94-1A1.9 1.9 0 0 1 2.74 1h9.76l.5.5zM2 10.17V2.748v7.422zM5 3H4v1h1V3zm0 2H4v1h1V5zM4 7h1v1H4V7zm8.07-3.61l-.7.71 1.92 1.92H7v1h6.39l-2.02 2.03.7.7 2.83-2.82v-.71l-2.83-2.83zM5.5 13.49L4.28 15H4v-3h3v3h-.28L5.5 13.49z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/repo-push.svg b/icons/codicons/repo-push.svg
new file mode 100644
index 0000000000..8faf45146f
--- /dev/null
+++ b/icons/codicons/repo-push.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M13.5 1H3.74A1.74 1.74 0 0 0 2 2.75v9.5A1.74 1.74 0 0 0 3.74 14H7v-1H3.74a.74.74 0 0 1-.74-.75v-.5a.74.74 0 0 1 .74-.75H7v-1H4V2h9v8h-3v1h3v2h-3v1h3.5l.5-.5v-12l-.5-.5zM3 2.73a.75.75 0 0 0 0 .02v7.42-7.44zM6 3H5v1h1V3zm-.62 5.65l.71.7 1.92-1.92V15h1V7.328l2.03 2.022.7-.7-2.82-2.83h-.71L5.38 8.65zM5 5h1v1H5V5z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/repo.svg b/icons/codicons/repo.svg
new file mode 100644
index 0000000000..72fd4acd23
--- /dev/null
+++ b/icons/codicons/repo.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M14 10V1.5l-.5-.5H3.74a1.9 1.9 0 0 0-.67.13 1.77 1.77 0 0 0-.94 1 1.7 1.7 0 0 0-.13.62v9.5a1.7 1.7 0 0 0 .13.67c.177.427.515.768.94.95a1.9 1.9 0 0 0 .67.13H4v-1h-.26a.72.72 0 0 1-.29-.06.74.74 0 0 1-.4-.4.93.93 0 0 1-.05-.29v-.5a.93.93 0 0 1 .05-.29.74.74 0 0 1 .4-.4.72.72 0 0 1 .286-.06H13v2H9v1h4.5l.5-.5V10zM4 10V2h9v8H4zm1-7h1v1H5V3zm0 2h1v1H5V5zm1 2H5v1h1V7zm.5 6.49L5.28 15H5v-3h3v3h-.28L6.5 13.49z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/root-folder-opened.svg b/icons/codicons/root-folder-opened.svg
new file mode 100644
index 0000000000..b31bb8f9cf
--- /dev/null
+++ b/icons/codicons/root-folder-opened.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M1 6.257V2.5l.5-.5h5l.35.15.86.85h5.79l.5.5V6h1.13l.48.63-2.63 7-.48.37H8.743a5.48 5.48 0 0 0 .657-1h2.73l2.37-6H8.743a5.534 5.534 0 0 0-.72-.724l.127-.126L8.5 6H13V4H7.5l-.35-.15L6.29 3H2l.01 2.594c-.361.184-.7.407-1.01.663z"/><path d="M6 10.5a1.5 1.5 0 1 1-3 0 1.5 1.5 0 0 1 3 0z"/><path fill-rule="evenodd" clip-rule="evenodd" d="M8 10.5a3.5 3.5 0 1 1-7 0 3.5 3.5 0 0 1 7 0zM4.5 13a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/root-folder.svg b/icons/codicons/root-folder.svg
new file mode 100644
index 0000000000..93839d04ca
--- /dev/null
+++ b/icons/codicons/root-folder.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M7.71 3h6.79l.51.5v10l-.5.5H8.743a5.48 5.48 0 0 0 .657-1h4.59v-1.51l.01-4v-1.5H7.69l-.017.017a5.494 5.494 0 0 0-.881-.508l.348-.349.35-.15h6.5l.01-.99H7.5l-.36-.15-.85-.85H2V5.6a5.45 5.45 0 0 0-.99.649V2.5l.5-.5h5l.35.15.85.85z"/><path d="M6 10.5a1.5 1.5 0 1 1-3 0 1.5 1.5 0 0 1 3 0z"/><path fill-rule="evenodd" clip-rule="evenodd" d="M8 10.5a3.5 3.5 0 1 1-7 0 3.5 3.5 0 0 1 7 0zM4.5 13a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/screen-full.svg b/icons/codicons/screen-full.svg
new file mode 100644
index 0000000000..59d640356b
--- /dev/null
+++ b/icons/codicons/screen-full.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M3 12h10V4H3v8zm2-6h6v4H5V6zM2 6H1V2.5l.5-.5H5v1H2v3zm13-3.5V6h-1V3h-3V2h3.5l.5.5zM14 10h1v3.5l-.5.5H11v-1h3v-3zM2 13h3v1H1.5l-.5-.5V10h1v3z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/screen-normal.svg b/icons/codicons/screen-normal.svg
new file mode 100644
index 0000000000..e64985e69e
--- /dev/null
+++ b/icons/codicons/screen-normal.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M3.5 4H1V3h2V1h1v2.5l-.5.5zM13 3V1h-1v2.5l.5.5H15V3h-2zm-1 9.5V15h1v-2h2v-1h-2.5l-.5.5zM1 12v1h2v2h1v-2.5l-.5-.5H1zm11-1.5l-.5.5h-7l-.5-.5v-5l.5-.5h7l.5.5v5zM10 7H6v2h4V7z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/search-stop.svg b/icons/codicons/search-stop.svg
new file mode 100644
index 0000000000..7a80b70de5
--- /dev/null
+++ b/icons/codicons/search-stop.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M5.738 3.318a4.5 4.5 0 0 0-.877 5.123A4.48 4.48 0 0 0 6.1 10a4.62 4.62 0 0 0-.1 1v.17c-.16-.11-.32-.22-.47-.34L1.75 14.5 1 13.84l3.8-3.69a5.5 5.5 0 1 1 9.62-3.65c0 .268-.02.535-.06.8a5.232 5.232 0 0 0-.94-.68V6.5a4.5 4.5 0 0 0-7.682-3.182zm3.04 4.356a4 4 0 1 1 4.444 6.652 4 4 0 0 1-4.444-6.652zm.1 5.447A3 3 0 0 0 11 14a3 3 0 0 0 1.74-.55L8.55 9.26A3 3 0 0 0 8 11a3 3 0 0 0 .879 2.121zm.382-4.57l4.19 4.189A3 3 0 0 0 14 11a3 3 0 0 0-3-3 3 3 0 0 0-1.74.55z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/search.svg b/icons/codicons/search.svg
new file mode 100644
index 0000000000..13c4df07b7
--- /dev/null
+++ b/icons/codicons/search.svg
@@ -0,0 +1 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M15.25 0a8.25 8.25 0 0 0-6.18 13.72L1 22.88l1.12 1 8.05-9.12A8.251 8.251 0 1 0 15.25.01V0zm0 15a6.75 6.75 0 1 1 0-13.5 6.75 6.75 0 0 1 0 13.5z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/settings-gear.svg b/icons/codicons/settings-gear.svg
new file mode 100644
index 0000000000..0abb193364
--- /dev/null
+++ b/icons/codicons/settings-gear.svg
@@ -0,0 +1 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M19.85 8.75l4.15.83v4.84l-4.15.83 2.35 3.52-3.43 3.43-3.52-2.35-.83 4.15H9.58l-.83-4.15-3.52 2.35-3.43-3.43 2.35-3.52L0 14.42V9.58l4.15-.83L1.8 5.23 5.23 1.8l3.52 2.35L9.58 0h4.84l.83 4.15 3.52-2.35 3.43 3.43-2.35 3.52zm-1.57 5.07l4-.81v-2l-4-.81-.54-1.3 2.29-3.43-1.43-1.43-3.43 2.29-1.3-.54-.81-4h-2l-.81 4-1.3.54-3.43-2.29-1.43 1.43L6.38 8.9l-.54 1.3-4 .81v2l4 .81.54 1.3-2.29 3.43 1.43 1.43 3.43-2.29 1.3.54.81 4h2l.81-4 1.3-.54 3.43 2.29 1.43-1.43-2.29-3.43.54-1.3zm-8.186-4.672A3.43 3.43 0 0 1 12 8.57 3.44 3.44 0 0 1 15.43 12a3.43 3.43 0 1 1-5.336-2.852zm.956 4.274c.281.188.612.288.95.288A1.7 1.7 0 0 0 13.71 12a1.71 1.71 0 1 0-2.66 1.422z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/settings.svg b/icons/codicons/settings.svg
new file mode 100644
index 0000000000..67127eaa5c
--- /dev/null
+++ b/icons/codicons/settings.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M3.5 2h-1v5h1V2zm6.1 5H6.4L6 6.45v-1L6.4 5h3.2l.4.5v1l-.4.5zm-5 3H1.4L1 9.5v-1l.4-.5h3.2l.4.5v1l-.4.5zm3.9-8h-1v2h1V2zm-1 6h1v6h-1V8zm-4 3h-1v3h1v-3zm7.9 0h3.19l.4-.5v-.95l-.4-.5H11.4l-.4.5v.95l.4.5zm2.1-9h-1v6h1V2zm-1 10h1v2h-1v-2z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/source-control.svg b/icons/codicons/source-control.svg
new file mode 100644
index 0000000000..edb96f80a2
--- /dev/null
+++ b/icons/codicons/source-control.svg
@@ -0,0 +1 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M21.007 8.222A3.738 3.738 0 0 0 15.045 5.2a3.737 3.737 0 0 0 1.156 6.583 2.988 2.988 0 0 1-2.668 1.67h-2.99a4.456 4.456 0 0 0-2.989 1.165V7.4a3.737 3.737 0 1 0-1.494 0v9.117a3.776 3.776 0 1 0 1.816.099 2.99 2.99 0 0 1 2.668-1.667h2.99a4.484 4.484 0 0 0 4.223-3.039 3.736 3.736 0 0 0 3.25-3.687zM4.565 3.738a2.242 2.242 0 1 1 4.484 0 2.242 2.242 0 0 1-4.484 0zm4.484 16.441a2.242 2.242 0 1 1-4.484 0 2.242 2.242 0 0 1 4.484 0zm8.221-9.715a2.242 2.242 0 1 1 0-4.485 2.242 2.242 0 0 1 0 4.485z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/split-horizontal.svg b/icons/codicons/split-horizontal.svg
new file mode 100644
index 0000000000..d744a79841
--- /dev/null
+++ b/icons/codicons/split-horizontal.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M14 1H3L2 2v11l1 1h11l1-1V2l-1-1zM8 13H3V2h5v11zm6 0H9V2h5v11z"/></svg>
\ No newline at end of file
diff --git a/icons/codicons/split-vertical.svg b/icons/codicons/split-vertical.svg
new file mode 100644
index 0000000000..3a18ab9f06
--- /dev/null
+++ b/icons/codicons/split-vertical.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M14 1H3L2 2v11l1 1h11l1-1V2l-1-1zm0 12H3V8h11v5zm0-6H3V2h11v5z"/></svg>
\ No newline at end of file
diff --git a/icons/symbol-array.svg b/icons/codicons/symbol-array.svg
similarity index 100%
rename from icons/symbol-array.svg
rename to icons/codicons/symbol-array.svg
diff --git a/icons/symbol-boolean.svg b/icons/codicons/symbol-boolean.svg
similarity index 100%
rename from icons/symbol-boolean.svg
rename to icons/codicons/symbol-boolean.svg
diff --git a/icons/symbol-class.svg b/icons/codicons/symbol-class.svg
similarity index 100%
rename from icons/symbol-class.svg
rename to icons/codicons/symbol-class.svg
diff --git a/icons/symbol-color.svg b/icons/codicons/symbol-color.svg
similarity index 100%
rename from icons/symbol-color.svg
rename to icons/codicons/symbol-color.svg
diff --git a/icons/symbol-constant.svg b/icons/codicons/symbol-constant.svg
similarity index 100%
rename from icons/symbol-constant.svg
rename to icons/codicons/symbol-constant.svg
diff --git a/icons/symbol-enum-member.svg b/icons/codicons/symbol-enum-member.svg
similarity index 100%
rename from icons/symbol-enum-member.svg
rename to icons/codicons/symbol-enum-member.svg
diff --git a/icons/symbol-enum.svg b/icons/codicons/symbol-enum.svg
similarity index 100%
rename from icons/symbol-enum.svg
rename to icons/codicons/symbol-enum.svg
diff --git a/icons/symbol-event.svg b/icons/codicons/symbol-event.svg
similarity index 100%
rename from icons/symbol-event.svg
rename to icons/codicons/symbol-event.svg
diff --git a/icons/symbol-field.svg b/icons/codicons/symbol-field.svg
similarity index 100%
rename from icons/symbol-field.svg
rename to icons/codicons/symbol-field.svg
diff --git a/icons/symbol-file.svg b/icons/codicons/symbol-file.svg
similarity index 100%
rename from icons/symbol-file.svg
rename to icons/codicons/symbol-file.svg
diff --git a/icons/symbol-interface.svg b/icons/codicons/symbol-interface.svg
similarity index 100%
rename from icons/symbol-interface.svg
rename to icons/codicons/symbol-interface.svg
diff --git a/icons/symbol-key.svg b/icons/codicons/symbol-key.svg
similarity index 100%
rename from icons/symbol-key.svg
rename to icons/codicons/symbol-key.svg
diff --git a/icons/symbol-keyword.svg b/icons/codicons/symbol-keyword.svg
similarity index 100%
rename from icons/symbol-keyword.svg
rename to icons/codicons/symbol-keyword.svg
diff --git a/icons/symbol-method.svg b/icons/codicons/symbol-method.svg
similarity index 100%
rename from icons/symbol-method.svg
rename to icons/codicons/symbol-method.svg
diff --git a/icons/symbol-misc.svg b/icons/codicons/symbol-misc.svg
similarity index 100%
rename from icons/symbol-misc.svg
rename to icons/codicons/symbol-misc.svg
diff --git a/icons/symbol-namespace.svg b/icons/codicons/symbol-namespace.svg
similarity index 100%
rename from icons/symbol-namespace.svg
rename to icons/codicons/symbol-namespace.svg
diff --git a/icons/symbol-numeric.svg b/icons/codicons/symbol-numeric.svg
similarity index 100%
rename from icons/symbol-numeric.svg
rename to icons/codicons/symbol-numeric.svg
diff --git a/icons/symbol-operator.svg b/icons/codicons/symbol-operator.svg
similarity index 100%
rename from icons/symbol-operator.svg
rename to icons/codicons/symbol-operator.svg
diff --git a/icons/symbol-parameter.svg b/icons/codicons/symbol-parameter.svg
similarity index 100%
rename from icons/symbol-parameter.svg
rename to icons/codicons/symbol-parameter.svg
diff --git a/icons/symbol-property.svg b/icons/codicons/symbol-property.svg
similarity index 100%
rename from icons/symbol-property.svg
rename to icons/codicons/symbol-property.svg
diff --git a/icons/symbol-ruler.svg b/icons/codicons/symbol-ruler.svg
similarity index 100%
rename from icons/symbol-ruler.svg
rename to icons/codicons/symbol-ruler.svg
diff --git a/icons/symbol-snippet.svg b/icons/codicons/symbol-snippet.svg
similarity index 100%
rename from icons/symbol-snippet.svg
rename to icons/codicons/symbol-snippet.svg
diff --git a/icons/symbol-string.svg b/icons/codicons/symbol-string.svg
similarity index 100%
rename from icons/symbol-string.svg
rename to icons/codicons/symbol-string.svg
diff --git a/icons/symbol-structure.svg b/icons/codicons/symbol-structure.svg
similarity index 100%
rename from icons/symbol-structure.svg
rename to icons/codicons/symbol-structure.svg
diff --git a/icons/symbol-variable.svg b/icons/codicons/symbol-variable.svg
similarity index 100%
rename from icons/symbol-variable.svg
rename to icons/codicons/symbol-variable.svg
diff --git a/icons/codicons/terminal.svg b/icons/codicons/terminal.svg
new file mode 100644
index 0000000000..2ffc08e285
--- /dev/null
+++ b/icons/codicons/terminal.svg
@@ -0,0 +1 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M3 1.5L1.5 3v18L3 22.5h18l1.5-1.5V3L21 1.5H3zM3 21V3h18v18H3zm5.656-4.01l1.038 1.061 5.26-5.243v-.912l-5.26-5.26-1.035 1.06 4.59 4.702-4.593 4.592z"/></svg>
\ No newline at end of file
diff --git a/icons/unsaved.svg b/icons/codicons/unsaved.svg
similarity index 100%
rename from icons/unsaved.svg
rename to icons/codicons/unsaved.svg
diff --git a/icons/codicons/warning.svg b/icons/codicons/warning.svg
new file mode 100644
index 0000000000..9a33f87391
--- /dev/null
+++ b/icons/codicons/warning.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M7.56 1h.88l6.54 12.26-.44.74H1.44L1 13.26 7.56 1zM8 2.28L2.28 13H13.7L8 2.28zM8.625 12v-1h-1.25v1h1.25zm-1.25-2V6h1.25v4h-1.25z"/></svg>
\ No newline at end of file
diff --git a/icons/default_file.svg b/icons/default_file.svg
deleted file mode 100644
index 9ee39aa091..0000000000
--- a/icons/default_file.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><title>default_file</title><path d="M20.414,2H5V30H27V8.586ZM7,28V4H19v6h6V28Z" style="fill:#c5c5c5"/></svg>
\ No newline at end of file
diff --git a/icons/default_folder.svg b/icons/default_folder.svg
deleted file mode 100644
index c6f9b035e9..0000000000
--- a/icons/default_folder.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><title>default_folder</title><path d="M27.5,5.5H18.2L16.1,9.7H4.4V26.5H29.6V5.5Zm0,4.2H19.3l1.1-2.1h7.1Z" style="fill:#c09553"/></svg>
\ No newline at end of file
diff --git a/icons/default_folder_opened.svg b/icons/default_folder_opened.svg
deleted file mode 100644
index 8aab2ff5c3..0000000000
--- a/icons/default_folder_opened.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><title>default_folder_opened</title><path d="M27.4,5.5H18.2L16.1,9.7H4.3V26.5H29.5V5.5Zm0,18.7H6.6V11.8H27.4Zm0-14.5H19.2l1-2.1h7.1V9.7Z" style="fill:#dcb67a"/><polygon points="25.7 13.7 0.5 13.7 4.3 26.5 29.5 26.5 25.7 13.7" style="fill:#dcb67a"/></svg>
\ No newline at end of file
diff --git a/icons/diff-added.svg b/icons/diff-added.svg
deleted file mode 100644
index 0f9cd120e9..0000000000
--- a/icons/diff-added.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 1H13.5L14 1.5V13.5L13.5 14H1.5L1 13.5V1.5L1.5 1ZM2 13H13V2H2V13Z" fill="#C5C5C5"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M8 4H7V7H4V8H7V11H8V8H11V7H8V4Z" fill="#C5C5C5"/>
-</svg>
diff --git a/icons/diff-modified.svg b/icons/diff-modified.svg
deleted file mode 100644
index e7a3694998..0000000000
--- a/icons/diff-modified.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 1H14.5L15 1.5V14.5L14.5 15H1.5L1 14.5V1.5L1.5 1ZM2 2V14H14V2H2ZM8 11C9.65685 11 11 9.65685 11 8C11 6.34315 9.65685 5 8 5C6.34315 5 5 6.34315 5 8C5 9.65685 6.34315 11 8 11Z" fill="#C5C5C5"/>
-</svg>
diff --git a/icons/diff-removed.svg b/icons/diff-removed.svg
deleted file mode 100644
index 8a9891b2a7..0000000000
--- a/icons/diff-removed.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M10 7L10 8L5 8L5 7L10 7Z" fill="#C5C5C5"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 1H13.5L14 1.5V13.5L13.5 14H1.5L1 13.5V1.5L1.5 1ZM2 13H13V2H2V13Z" fill="#C5C5C5"/>
-</svg>
diff --git a/icons/diff-renamed.svg b/icons/diff-renamed.svg
deleted file mode 100644
index 1b1624c376..0000000000
--- a/icons/diff-renamed.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 1H14.5L15 1.5V14.5L14.5 15H1.5L1 14.5V1.5L1.5 1ZM2 14H14V2H2V14ZM4 9H7V12L12 8L7 4V7H4V9Z" fill="#C5C5C5"/>
-</svg>
diff --git a/icons/error.svg b/icons/error.svg
deleted file mode 100644
index 3c35622732..0000000000
--- a/icons/error.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M8.60012 0.999985C10.2001 1.09999 11.7001 1.89999 12.8001 2.99999C14.1001 4.39999 14.8001 6.09999 14.8001 8.09999C14.8001 9.69999 14.2001 11.2 13.2001 12.5C12.2001 13.7 10.8001 14.6 9.20012 14.9C7.60012 15.2 6.00012 15 4.60012 14.2C3.20012 13.4 2.10012 12.2 1.50012 10.7C0.900119 9.19999 0.80012 7.49999 1.30012 5.99999C1.80012 4.39999 2.70012 3.09999 4.10012 2.19999C5.40012 1.29999 7.00012 0.899985 8.60012 0.999985ZM9.10012 13.9C10.4001 13.6 11.6001 12.9 12.5001 11.8C13.3001 10.7 13.8001 9.39999 13.7001 7.99999C13.7001 6.39999 13.1001 4.79999 12.0001 3.69999C11.0001 2.69999 9.80012 2.09999 8.40012 1.99999C7.10012 1.89999 5.70012 2.19999 4.60012 2.99999C3.50012 3.79999 2.70012 4.89999 2.30012 6.29999C1.90012 7.59999 1.90012 8.99999 2.50012 10.3C3.10012 11.6 4.00012 12.6 5.20012 13.3C6.40012 14 7.80012 14.2 9.10012 13.9ZM7.90011 7.5L10.3001 5L11.0001 5.7L8.60011 8.2L11.0001 10.7L10.3001 11.4L7.90011 8.9L5.50011 11.4L4.80011 10.7L7.20011 8.2L4.80011 5.7L5.50011 5L7.90011 7.5Z" fill="#A1260D"/>
-</svg>
diff --git a/icons/file-explorer.svg b/icons/file-explorer.svg
deleted file mode 100644
index 2c8a9611c4..0000000000
--- a/icons/file-explorer.svg
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?> <!-- Created with Vectornator for iOS (http://vectornator.io/) --><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xml:space="preserve" viewBox="0 0 1024 1024" xmlns:vectornator="http://vectornator.io" xmlns="http://www.w3.org/2000/svg" width="100%" height="100%" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" style="fill-rule:nonzero;clip-rule:evenodd;stroke-linecap:round;stroke-linejoin:round;">
-<metadata>
-<vectornator:setting key="IsTimeLapseWatermarkDisabled" value="false"/>
-<vectornator:setting key="WDSnapToEdges" value="false"/>
-<vectornator:setting value="false" key="WDIsolateActiveLayer"/>
-<vectornator:setting value="false" key="WDDynamicGuides"/>
-<vectornator:setting key="WDSnapToGrid" value="false"/>
-<vectornator:setting key="UndoHistoryDisabled" value="false"/>
-<vectornator:setting value="Pixels" key="WDUnits"/>
-<vectornator:setting key="WDGuidesVisible" value="true"/>
-<vectornator:setting value="false" key="WDSnapToPoints"/>
-<vectornator:setting key="WDDisplayWhiteBackground" value="false"/>
-<vectornator:setting key="VNPencilOnly" value="false"/>
-<vectornator:setting key="VNSnapToGuides" value="true"/>
-<vectornator:setting key="WDOutlineMode" value="false"/>
-<vectornator:setting value="false" key="WDCMYKEnabledKey"/>
-<vectornator:setting key="WDRulersVisible" value="true"/>
-<vectornator:setting value="true" key="VNDimensionsVisible"/>
-</metadata>
-<defs/>
-<g vectornator:layerName="Layer 1" id="Layer 1">
-<g opacity="1">
-<path opacity="1" fill-rule="evenodd" d="M160.8+298L864.797+298L864.797+298L864.797+328.4L864.797+328.4L160.8+328.4L160.8+328.4L160.8+298L160.8+298Z" fill="#000000"/>
-<path opacity="1" fill-rule="evenodd" d="M178.4+246L847.201+246L847.201+246L847.201+276.4L847.201+276.4L178.4+276.4L178.4+276.4L178.4+246L178.4+246Z" fill="#000000"/>
-<path fill-rule="evenodd" opacity="1" d="M1007.2+408.398L943.999+408.398L943.999+145.2C943.999+138+938.399+131.6+930.399+131.6L398.4+131.6C393.6+131.6+389.6+129.2+387.2+125.2L343.2+51.6004C340.8+47.6003+336.8+45.2003+332+45.2003L94.4+45.2003C87.1999+45.2003+80.7998+51.6004+80.7998+58.8001L80.7998+408.398L16.8+408.398C13.6+408.398+12+410.798+12+413.998L96.8+974.8C96.8+977.2+99.2001+978.8+101.6+978.8L922.398+978.8C924.799+978.8+926.398+977.2+927.199+974.8L1012+413.998C1012+410.798+1010.4+408.398+1007.2+408.398ZM805.601+857.202L477.599+857.202L463.199+723.6L824.001+723.6L805.601+857.202ZM903.198+408.398L122.4+408.398L122.4+328.4L139.2+328.4L139.2+276.4L156.8+276.4L156.8+224.4L868.798+224.4L868.798+276.4L886.398+276.4L886.398+328.4L903.998+328.4L903.998+408.398L903.198+408.398Z" fill="#000000"/>
-</g>
-</g>
-</svg>
diff --git a/icons/file_type_c.svg b/icons/file_type_c.svg
deleted file mode 100644
index 5a6001d67f..0000000000
--- a/icons/file_type_c.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><title>file_type_c</title><path d="M10.676,15.973a10.052,10.052,0,0,0,1.175,5.151,5.446,5.446,0,0,0,6.306,2.408,4.284,4.284,0,0,0,3.09-3.6c.107-.6.109-.61.109-.61,1.737.251,4.537.658,6.274.906l-.11.44a11.256,11.256,0,0,1-2.7,5.39,9.439,9.439,0,0,1-5.366,2.688,14.61,14.61,0,0,1-8.277-.819A10.151,10.151,0,0,1,5.4,21.687a16.225,16.225,0,0,1,.019-11.45,10.538,10.538,0,0,1,8.963-7.054,13.353,13.353,0,0,1,6.666.555,9.571,9.571,0,0,1,6.167,6.9c.094.352.114.417.114.417-1.932.351-4.319.8-6.238,1.215-.362-1.915-1.265-3.428-3.2-3.9a5.263,5.263,0,0,0-6.616,3.57,10.49,10.49,0,0,0-.385,1.439A12.31,12.31,0,0,0,10.676,15.973Z" style="fill:#005f91"/></svg>
\ No newline at end of file
diff --git a/icons/file_type_cpp.svg b/icons/file_type_cpp.svg
deleted file mode 100644
index 9563371f7f..0000000000
--- a/icons/file_type_cpp.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><title>file_type_cpp</title><path d="M14.742,24.047a10.242,10.242,0,0,1-4.673.919A7.628,7.628,0,0,1,4.155,22.62,8.876,8.876,0,0,1,2,16.369,9.476,9.476,0,0,1,4.422,9.621a8.216,8.216,0,0,1,6.285-2.588,11.151,11.151,0,0,1,4.035.641v3.761A6.839,6.839,0,0,0,11,10.395,4.813,4.813,0,0,0,7.288,11.93a5.9,5.9,0,0,0-1.413,4.159A5.8,5.8,0,0,0,7.209,20.1a4.57,4.57,0,0,0,3.59,1.493,7.319,7.319,0,0,0,3.943-1.113Z" style="fill:#984c93"/><polygon points="17.112 14.829 17.112 12.485 19.456 12.485 19.456 14.829 21.8 14.829 21.8 17.172 19.456 17.172 19.456 19.515 17.112 19.515 17.112 17.172 14.77 17.172 14.77 14.828 17.112 14.829" style="fill:#984c93"/><polygon points="25.313 14.829 25.313 12.485 27.657 12.485 27.657 14.829 30 14.829 30 17.172 27.657 17.172 27.657 19.515 25.313 19.515 25.313 17.172 22.971 17.172 22.971 14.828 25.313 14.829" style="fill:#984c93"/></svg>
\ No newline at end of file
diff --git a/icons/file_type_go.svg b/icons/file_type_go.svg
deleted file mode 100644
index 05a1baa1bb..0000000000
--- a/icons/file_type_go.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 254.5 225"><title>file_type_go</title><path d="M-46.926,89c-.621,0-.777-.311-.466-.777l3.262-4.194a2.225,2.225,0,0,1,1.708-.777H13.026c.621,0,.777.466.466.932l-2.64,4.038a2.367,2.367,0,0,1-1.553.932Z" style="fill:#00acd7"/><path d="M-70.379,103.285c-.621,0-.777-.311-.466-.777l3.262-4.194a2.225,2.225,0,0,1,1.708-.777H4.95a.714.714,0,0,1,.777.932L4.484,102.2a1.358,1.358,0,0,1-1.4.932Z" style="fill:#00acd7"/><path d="M-32.792,117.574c-.621,0-.777-.466-.466-.932l2.174-3.883a2.06,2.06,0,0,1,1.553-.932H1.533c.621,0,.932.466.932,1.087l-.311,3.728a1.167,1.167,0,0,1-1.087,1.087Z" style="fill:#00acd7"/><path d="M128.426,86.2c-9.785,2.485-16.464,4.349-26.093,6.834-2.33.621-2.485.777-4.5-1.553-2.33-2.64-4.038-4.349-7.3-5.9-9.785-4.815-19.259-3.417-28.112,2.33-10.561,6.834-16,16.929-15.842,29.51.155,12.425,8.7,22.676,20.968,24.385,10.561,1.4,19.414-2.33,26.4-10.251,1.4-1.708,2.64-3.572,4.194-5.747H68.163c-3.262,0-4.038-2.019-2.951-4.659,2.019-4.815,5.747-12.891,7.921-16.929a4.194,4.194,0,0,1,3.883-2.485h56.535c-.311,4.194-.311,8.387-.932,12.581a66.239,66.239,0,0,1-12.736,30.442C108.7,159.51,94.1,168.673,75.618,171.158c-15.221,2.019-29.355-.932-41.78-10.251a48.785,48.785,0,0,1-19.725-34.48c-2.019-16.929,2.951-32.15,13.2-45.508C38.342,66.475,52.942,57.312,70.8,54.05c14.6-2.64,28.578-.932,41.159,7.61a48.686,48.686,0,0,1,18.017,21.9C130.911,84.958,130.289,85.735,128.426,86.2Z" style="fill:#00acd7"/><path d="M179.835,172.09c-14.134-.311-27.025-4.349-37.9-13.668a48.711,48.711,0,0,1-16.774-29.976c-2.8-17.551,2.019-33.082,12.581-46.905,11.338-14.91,25.006-22.676,43.488-25.938,15.842-2.8,30.753-1.243,44.265,7.921,12.27,8.387,19.88,19.725,21.9,34.635,2.64,20.968-3.417,38.052-17.861,52.652a71.17,71.17,0,0,1-37.276,19.88C188.067,171.469,183.874,171.624,179.835,172.09ZM216.8,109.343a44.7,44.7,0,0,0-.466-5.125c-2.8-15.376-16.929-24.074-31.684-20.657-14.444,3.262-23.763,12.425-27.18,27.025a25.579,25.579,0,0,0,14.289,29.355c8.542,3.728,17.085,3.262,25.317-.932C209.345,132.64,216.024,122.7,216.8,109.343Z" style="fill:#00acd7"/></svg>
\ No newline at end of file
diff --git a/icons/file_type_json.svg b/icons/file_type_json.svg
deleted file mode 100644
index 26c39ba7c4..0000000000
--- a/icons/file_type_json.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><title>file_type_json</title><path d="M4.014,14.976a2.51,2.51,0,0,0,1.567-.518A2.377,2.377,0,0,0,6.386,13.1,15.261,15.261,0,0,0,6.6,10.156q.012-2.085.075-2.747a5.236,5.236,0,0,1,.418-1.686,3.025,3.025,0,0,1,.755-1.018A3.046,3.046,0,0,1,9,4.125,6.762,6.762,0,0,1,10.544,4h.7V5.96h-.387a2.338,2.338,0,0,0-1.723.468A3.4,3.4,0,0,0,8.709,8.52a36.054,36.054,0,0,1-.137,4.133,4.734,4.734,0,0,1-.768,2.06A4.567,4.567,0,0,1,6.1,16a3.809,3.809,0,0,1,1.992,1.754,8.861,8.861,0,0,1,.618,3.865q0,2.435.05,2.9A1.755,1.755,0,0,0,9.264,25.7a2.639,2.639,0,0,0,1.592.337h.387V28h-.7a5.655,5.655,0,0,1-1.773-.2,2.97,2.97,0,0,1-1.324-.93,3.353,3.353,0,0,1-.681-1.63A24.175,24.175,0,0,1,6.6,22.006,16.469,16.469,0,0,0,6.386,18.9a2.408,2.408,0,0,0-.805-1.361,2.489,2.489,0,0,0-1.567-.524Z" style="fill:#f5de19"/><path d="M27.986,17.011a2.489,2.489,0,0,0-1.567.524,2.408,2.408,0,0,0-.805,1.361,16.469,16.469,0,0,0-.212,3.109,24.175,24.175,0,0,1-.169,3.234,3.353,3.353,0,0,1-.681,1.63,2.97,2.97,0,0,1-1.324.93,5.655,5.655,0,0,1-1.773.2h-.7V26.04h.387a2.639,2.639,0,0,0,1.592-.337,1.755,1.755,0,0,0,.506-1.186q.05-.462.05-2.9a8.861,8.861,0,0,1,.618-3.865A3.809,3.809,0,0,1,25.9,16a4.567,4.567,0,0,1-1.7-1.286,4.734,4.734,0,0,1-.768-2.06,36.054,36.054,0,0,1-.137-4.133,3.4,3.4,0,0,0-.425-2.092,2.338,2.338,0,0,0-1.723-.468h-.387V4h.7A6.762,6.762,0,0,1,23,4.125a3.046,3.046,0,0,1,1.149.581,3.025,3.025,0,0,1,.755,1.018,5.236,5.236,0,0,1,.418,1.686q.062.662.075,2.747a15.261,15.261,0,0,0,.212,2.947,2.377,2.377,0,0,0,.805,1.355,2.51,2.51,0,0,0,1.567.518Z" style="fill:#f5de19"/></svg>
\ No newline at end of file
diff --git a/icons/file_type_license.svg b/icons/file_type_license.svg
deleted file mode 100644
index 6859deae8d..0000000000
--- a/icons/file_type_license.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 32 32"><defs><linearGradient id="a" x1="-264.845" y1="181.772" x2="-255.586" y2="182.061" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -292.36, -27.561)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#bd6316"/><stop offset="1" stop-color="#4e1500"/></linearGradient><linearGradient id="b" x1="-263.276" y1="170.205" x2="-256.603" y2="171.772" xlink:href="#a"/><linearGradient id="c" x1="-265.068" y1="175.732" x2="-256.777" y2="178.801" xlink:href="#a"/><linearGradient id="d" x1="-655.014" y1="147.549" x2="-655.555" y2="146.948" gradientTransform="matrix(-0.947, -0.323, -0.323, 0.947, -558.144, -332.613)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ffd436"/><stop offset="1" stop-color="#8b3f02"/></linearGradient><linearGradient id="e" x1="-258.899" y1="170.981" x2="-253.843" y2="171.325" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -292.36, -27.561)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#fff8b7"/><stop offset="1" stop-color="#fcbf0e"/></linearGradient><linearGradient id="f" x1="-258.884" y1="170.975" x2="-253.896" y2="171.314" xlink:href="#a"/><linearGradient id="g" x1="-257.805" y1="172.266" x2="-257.726" y2="168.648" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -292.36, -27.561)" xlink:href="#d"/><linearGradient id="h" x1="-258.935" y1="181.92" x2="-256.173" y2="182.108" xlink:href="#e"/><linearGradient id="i" x1="-274.156" y1="170.544" x2="-274.512" y2="173.778" gradientTransform="matrix(-1, 0, 0, 1, -257.657, -155.509)" xlink:href="#d"/><linearGradient id="j" x1="-645.79" y1="-337.938" x2="-645.121" y2="-334.17" gradientTransform="matrix(-0.615, -0.789, -0.789, 0.615, -644.695, -286.477)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ffef94"/><stop offset="1" stop-color="#ffd200"/></linearGradient><linearGradient id="k" x1="-276.128" y1="178.682" x2="-274.754" y2="178.682" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -305.235, -16.952)" xlink:href="#d"/><linearGradient id="l" x1="-274.314" y1="178.887" x2="-271.841" y2="178.987" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -305.235, -16.952)" xlink:href="#d"/><linearGradient id="m" x1="-273.817" y1="189.281" x2="-274.213" y2="174.569" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -305.235, -16.952)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#d89530"/><stop offset="1" stop-color="#772d00"/></linearGradient><linearGradient id="n" x1="-274.075" y1="174.09" x2="-273.917" y2="181.459" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -305.235, -16.952)" xlink:href="#d"/><linearGradient id="o" x1="-272.919" y1="189.281" x2="-273.315" y2="174.57" xlink:href="#m"/><linearGradient id="p" x1="-273.177" y1="174.071" x2="-273.019" y2="181.44" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -305.235, -16.952)" xlink:href="#d"/><linearGradient id="q" x1="-652.29" y1="-335.227" x2="-651.867" y2="-332.867" gradientTransform="matrix(-0.615, -0.789, -0.789, 0.615, -644.695, -286.477)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ffdb57"/><stop offset="1" stop-color="#b55c13"/></linearGradient><linearGradient id="r" x1="-665.076" y1="157.413" x2="-659.751" y2="150.922" gradientTransform="matrix(-0.947, -0.323, -0.323, 0.947, -558.144, -332.613)" xlink:href="#m"/><linearGradient id="s" x1="-665.161" y1="156.114" x2="-664.822" y2="155.701" gradientTransform="matrix(-0.947, -0.323, -0.323, 0.947, -558.144, -332.613)" xlink:href="#m"/><linearGradient id="t" x1="-665.308" y1="156.436" x2="-665.836" y2="155.32" gradientTransform="matrix(-0.947, -0.323, -0.323, 0.947, -558.144, -332.613)" xlink:href="#m"/><linearGradient id="u" x1="-655.442" y1="147.568" x2="-654.817" y2="146.776" xlink:href="#d"/><linearGradient id="v" x1="-253.999" y1="175.1" x2="-254.134" y2="173.736" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -292.36, -27.561)" xlink:href="#m"/><linearGradient id="w" x1="-252.571" y1="173.138" x2="-252.785" y2="170.963" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -292.36, -27.561)" xlink:href="#m"/><linearGradient id="x" x1="-257.206" y1="169.107" x2="-259.174" y2="169.787" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -292.36, -27.561)" xlink:href="#m"/><linearGradient id="y" x1="-260.717" y1="170.284" x2="-260.77" y2="171.228" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -292.36, -27.561)" xlink:href="#m"/><linearGradient id="z" x1="-257.835" y1="174.993" x2="-257.782" y2="171.93" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -292.36, -27.561)" xlink:href="#d"/><linearGradient id="aa" x1="-263.928" y1="171.018" x2="-255.721" y2="171.018" gradientTransform="matrix(-0.897, 0.441, 0.441, 0.897, -292.36, -27.561)" xlink:href="#d"/><linearGradient id="ab" x1="-514.299" y1="-57.926" x2="-505.041" y2="-57.638" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#a"/><linearGradient id="ac" x1="-512.744" y1="-69.496" x2="-505.964" y2="-67.904" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#a"/><linearGradient id="ad" x1="-514.521" y1="-63.966" x2="-506.23" y2="-60.897" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#a"/><linearGradient id="ae" x1="-662.221" y1="-197.167" x2="-662.762" y2="-197.768" gradientTransform="matrix(-0.564, -0.911, -0.774, 0.455, -516.113, -497.612)" xlink:href="#d"/><linearGradient id="af" x1="-508.354" y1="-68.717" x2="-503.297" y2="-68.373" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#e"/><linearGradient id="ag" x1="-508.338" y1="-68.723" x2="-503.351" y2="-68.384" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#a"/><linearGradient id="ah" x1="-507.26" y1="-67.432" x2="-507.18" y2="-71.05" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#d"/><linearGradient id="ai" x1="-508.389" y1="-57.779" x2="-505.627" y2="-57.591" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#e"/><linearGradient id="aj" x1="-523.609" y1="-69.153" x2="-523.966" y2="-65.918" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -492.49, -86.99)" xlink:href="#d"/><linearGradient id="ak" x1="-645.333" y1="-334.169" x2="-642.973" y2="-332.091" xlink:href="#j"/><linearGradient id="al" x1="-525.581" y1="-61.015" x2="-524.207" y2="-61.015" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -492.49, -86.99)" xlink:href="#d"/><linearGradient id="am" x1="-523.768" y1="-60.81" x2="-521.294" y2="-60.71" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -492.49, -86.99)" xlink:href="#d"/><linearGradient id="an" x1="-523.27" y1="-50.416" x2="-523.666" y2="-65.127" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -492.49, -86.99)" xlink:href="#m"/><linearGradient id="ao" x1="-523.528" y1="-65.606" x2="-523.37" y2="-58.238" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -492.49, -86.99)" xlink:href="#d"/><linearGradient id="ap" x1="-522.372" y1="-50.416" x2="-522.768" y2="-65.127" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -492.49, -86.99)" xlink:href="#m"/><linearGradient id="aq" x1="-522.631" y1="-65.626" x2="-522.472" y2="-58.257" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -492.49, -86.99)" xlink:href="#d"/><linearGradient id="ar" x1="-649.116" y1="-328.591" x2="-646.827" y2="-326.795" xlink:href="#j"/><linearGradient id="as" x1="-672.284" y1="-187.303" x2="-666.958" y2="-193.795" gradientTransform="matrix(-0.564, -0.911, -0.774, 0.455, -516.113, -497.612)" xlink:href="#m"/><linearGradient id="at" x1="-672.369" y1="-188.603" x2="-672.03" y2="-189.016" gradientTransform="matrix(-0.564, -0.911, -0.774, 0.455, -516.113, -497.612)" xlink:href="#m"/><linearGradient id="au" x1="-672.516" y1="-188.281" x2="-673.044" y2="-189.397" gradientTransform="matrix(-0.564, -0.911, -0.774, 0.455, -516.113, -497.612)" xlink:href="#m"/><linearGradient id="av" x1="-662.648" y1="-197.148" x2="-662.023" y2="-197.94" gradientTransform="matrix(-0.564, -0.911, -0.774, 0.455, -516.113, -497.612)" xlink:href="#d"/><linearGradient id="aw" x1="-503.367" y1="-64.607" x2="-503.501" y2="-65.971" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#m"/><linearGradient id="ax" x1="-502.006" y1="-66.361" x2="-502.232" y2="-68.654" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#m"/><linearGradient id="ay" x1="-506.661" y1="-70.591" x2="-508.629" y2="-69.911" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#m"/><linearGradient id="az" x1="-510.172" y1="-69.414" x2="-510.224" y2="-68.47" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#m"/><linearGradient id="ba" x1="-507.289" y1="-64.705" x2="-507.236" y2="-67.768" gradientTransform="matrix(-0.947, -0.323, -0.148, 0.966, -476.554, -85.464)" xlink:href="#d"/><linearGradient id="bb" x1="-642.337" y1="-337.231" x2="-640.048" y2="-335.435" gradientTransform="matrix(-0.615, -0.789, -0.789, 0.615, -644.695, -286.477)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ffdb57"/><stop offset="1" stop-color="#b66512"/></linearGradient><linearGradient id="bc" x1="-628.479" y1="-215.005" x2="-627.663" y2="-209.203" gradientTransform="matrix(-0.79, -0.614, -0.614, 0.79, -612.222, -211.392)" xlink:href="#a"/><linearGradient id="bd" x1="-633.006" y1="-211.18" x2="-622.552" y2="-211.18" gradientTransform="matrix(-0.79, -0.614, -0.614, 0.79, -612.222, -211.392)" xlink:href="#e"/><linearGradient id="be" x1="-627.491" y1="-215.556" x2="-627.755" y2="-211.648" gradientTransform="matrix(-0.79, -0.614, -0.614, 0.79, -612.222, -211.392)" xlink:href="#d"/><linearGradient id="bf" x1="-627.796" y1="-210.705" x2="-627.057" y2="-205.186" gradientTransform="matrix(-0.79, -0.614, -0.614, 0.79, -612.222, -211.392)" xlink:href="#d"/><linearGradient id="bg" x1="245.815" y1="139.434" x2="245.923" y2="136.367" gradientTransform="translate(-214.883 -165.485) rotate(7.312)" xlink:href="#e"/><linearGradient id="bh" x1="-626.269" y1="-215.112" x2="-627.643" y2="-213.078" gradientTransform="matrix(-0.79, -0.614, -0.614, 0.79, -612.222, -211.392)" xlink:href="#d"/></defs><title>file_type_license</title><polygon points="13.372 16.416 18.385 13.952 19.315 15.845 19.261 16.083 17.213 17.09 22.919 28.701 22.698 29.06 21.155 29.818 20.335 29.368 14.876 18.259 14.394 18.496 13.372 16.416" style="fill:url(#a)"/><path d="M9.24,13.619l1.2,2.44c.072.146.416.252.617.292l2.634.683L18.3,14.766l.867-2.342a.679.679,0,0,0,.036-.674l-1.2-2.44a.546.546,0,0,0-.452-.3l-4.44.136a1.278,1.278,0,0,0-1.018.541l-2.72,3.162A.916.916,0,0,0,9.24,13.619Zm1.932.033a.356.356,0,0,1,.011-.334l1.84-2.215a.829.829,0,0,1,.66-.351l2.877-.088a.355.355,0,0,1,.293.2l.356.725a.242.242,0,0,1-.139.339L11.833,14.5a.224.224,0,0,1-.3-.121Z" style="fill:url(#b)"/><path d="M9.426,13.209l1.2,2.44c.072.146.416.252.617.292l2.7.547.782,1.591L15.1,17.9l5.459,11.109.82.451L22.92,28.7l-.017-.683,0,0,.868-1.458-.241-.49-.54.1-.31-.63.41-.366L22.5,23.974l-.593-.006-.277-.564.357-.473-.3-.607-.568.043-.432-.879.382-.423-.161-.327a.871.871,0,0,1-.659-1.342l-.345-.7a1.347,1.347,0,0,1-.962-1.956l-.29-.591.631-.31-.773-1.546.843-2.277a.68.68,0,0,0,.035-.674l-1.2-2.44a.546.546,0,0,0-.453-.3L13.3,8.733a1.278,1.278,0,0,0-1.018.541l-2.84,3.419A.548.548,0,0,0,9.426,13.209Zm1.932.033a.356.356,0,0,1,.011-.334l1.84-2.215a.828.828,0,0,1,.66-.351l2.877-.088a.354.354,0,0,1,.293.2l.356.725a.242.242,0,0,1-.139.339l-5.238,2.574a.224.224,0,0,1-.3-.121Z" style="fill:url(#c)"/><polygon points="14.47 18.381 14.746 18.063 15.081 17.899 14.942 18.144 14.47 18.381" style="fill:url(#d)"/><path d="M11.259,15.828l2.776.6,4.38-2.152.865-2.339a.576.576,0,0,0,.024-.567L18.1,8.917a.441.441,0,0,0-.367-.246l-4.438.13a1.169,1.169,0,0,0-.938.5L9.52,12.725a.447.447,0,0,0-.011.414l1.206,2.453A1,1,0,0,0,11.259,15.828Zm.354-1.836,0,0-.358-.729a.463.463,0,0,1,.013-.434l0-.008L13.121,10.6a.922.922,0,0,1,.739-.389l2.881-.084a.468.468,0,0,1,.392.257l.358.729c.005.009.19.3-.187.481l-5.244,2.577C11.788,14.3,11.62,14.007,11.613,13.992Z" style="fill:url(#e)"/><path d="M11.246,15.738c.006,0,2.438.51,2.751.591l4.354-2.139c.028-.076.878-2.336.878-2.336a.472.472,0,0,0,.015-.458L18.036,8.938a.337.337,0,0,0-.282-.187L13.3,8.892a1.083,1.083,0,0,0-.864.46L9.573,12.788a.341.341,0,0,0-.008.313l1.206,2.454A1.118,1.118,0,0,0,11.246,15.738Zm.245-1.7-.355-.723a.568.568,0,0,1,.018-.535l0-.008.01-.015,1.865-2.241a1.033,1.033,0,0,1,.824-.43l2.9-.091a.575.575,0,0,1,.492.316l.359.73a.456.456,0,0,1,.027.338.484.484,0,0,1-.265.286l-5.287,2.6a.415.415,0,0,1-.331.025h0A.486.486,0,0,1,11.49,14.042Z" style="fill:url(#f)"/><path d="M11.268,15.663c.009,0,2.53.528,2.722.577l4.3-2.113.878-2.314a.419.419,0,0,0,.01-.4l-1.2-2.436a.282.282,0,0,0-.237-.156l-4.433.149a1.033,1.033,0,0,0-.82.437L10.135,12.23l-.5.595a.285.285,0,0,0,0,.254L10.828,15.5A1.181,1.181,0,0,0,11.268,15.663Zm.14-1.529-.351-.715a.575.575,0,0,1-.011-.56l1.959-2.36a1.082,1.082,0,0,1,.86-.447l2.887-.1a.628.628,0,0,1,.538.341l.356.724a.539.539,0,0,1-.309.773l-5.267,2.588A.482.482,0,0,1,11.408,14.135Z" style="fill:url(#g)"/><path d="M18.463,14.345l.7,1.433-.653.321.319.649a1.428,1.428,0,0,0,1,2.043l.3.619a.958.958,0,0,0,.706,1.436l.107.218-.39.428.5,1.011.577-.047.239.485-.366.478.336.683.6,0,.523,1.065-.419.371.382.777.549-.1.181.368C23.612,26.671,22.8,28,22.8,28v.638l-1.342.659-.729-.414L15.241,17.707l-.467.23-.7-1.433Z" style="fill:url(#h)"/><rect x="14.289" y="15.413" width="4.622" height="1.4" transform="translate(-5.405 8.973) rotate(-26.171)" style="fill:url(#i)"/><path d="M18.128,14.582l-.8.392.617,1.256.8-.392Zm-1.319.648.617,1.256.308-.152-.617-1.256Z" style="fill:url(#j)"/><path d="M18.4,16.123l.308.628a1.523,1.523,0,0,0,1.037,2.11l.263.535a1.052,1.052,0,0,0,.744,1.513l.054.111-.381.423.557,1.134.567-.043.177.36-.357.472.392.8.591.006.456.929-.409.366.45.917.539-.1.12.243L22.634,28l-1.027.5L16.082,17.265Z" style="fill:url(#k)"/><path d="M17.141,16.745l5.528,11.248.046.511-1.247.613-.613-.349L15.372,17.614Z" style="fill:url(#l)"/><polygon points="22.287 28.694 22.714 28.484 17.92 18.73 16.892 17.176 17.494 18.94 22.287 28.694" style="fill:url(#m)"/><polygon points="16.892 17.176 22.5 28.589 22.287 28.694 17.494 18.94 16.892 17.176" style="fill:url(#n)"/><polygon points="21.481 29.09 21.908 28.881 17.114 19.126 16.086 17.572 16.688 19.336 21.481 29.09" style="fill:url(#o)"/><polygon points="16.086 17.572 21.694 28.985 21.481 29.09 16.688 19.336 16.086 17.572" style="fill:url(#p)"/><path d="M18.27,16.189l-.411.2,5.285,10.755.279-.47-.181-.369-.386.072-.45-.917L22.7,25.2l-.508-1.034-.424,0-.392-.8.256-.338-.237-.482-.407.031-.557-1.134.273-.3-.143-.291a1.038,1.038,0,0,1-.619-1.259l-.391-.8a1.505,1.505,0,0,1-.906-1.844Zm-.68.334,5.371,10.929.108-.182L17.75,16.445Z" style="fill:url(#q)"/><polygon points="15.018 18.247 20.374 29.244 20.57 28.971 15.179 17.939 15.018 18.247" style="fill:url(#r)"/><polygon points="20.436 29.315 20.647 29.024 21.352 29.385 21.149 29.679 20.436 29.315" style="fill:url(#s)"/><polygon points="21.446 29.41 21.267 29.67 22.649 29.011 22.78 28.77 21.446 29.41" style="fill:url(#t)"/><polygon points="14.029 16.673 13.804 17.061 14.405 18.354 14.702 18 14.029 16.673" style="fill:url(#u)"/><polygon points="13.946 16.506 13.707 16.938 10.763 16.177 10.887 15.832 13.946 16.506" style="fill:url(#v)"/><path d="M9.359,13s-.145.444-.087.563l1.212,2.465.2-.384Z" style="fill:url(#w)"/><path d="M16.683,10.624l.1-.327-2.963.095a.914.914,0,0,0-.51.251l-.007.165a1.871,1.871,0,0,1,.394-.1Z" style="fill:url(#x)"/><path d="M16.83,10.309a.329.329,0,0,1,.17.137c.047.095.358.714.382.762l-.164.279-.341-.693c-.023-.047-.108-.145-.147-.149Z" style="fill:url(#y)"/><path d="M11.237,13.786l.171.348a.482.482,0,0,0,.661.248l5.267-2.588a.539.539,0,0,0,.309-.773l-.153-.31,1.08-.531.606,1.232a.419.419,0,0,1-.01.4l-.878,2.314-4.3,2.113c-.191-.049-2.713-.575-2.722-.577a1.181,1.181,0,0,1-.439-.16l-.6-1.222Z" style="fill:url(#z)"/><path d="M13.377,8.968l.532,1.084.539-.018L13.916,8.95Zm2.306-.077-1.395.047.533,1.084,1.4-.046Zm1.471,2.994-1.142.561,1.106,2.25,1.142-.561Zm-1.447.711-.441.217,1.106,2.251.441-.217Z" style="fill:url(#aa)"/><polygon points="10.65 14.159 15.937 15.962 15.623 18 15.45 18.134 13.29 17.397 11.369 29.898 10.998 30 9.371 29.445 8.976 28.532 10.814 16.571 10.306 16.398 10.65 14.159" style="fill:url(#ab)"/><path d="M8.951,9.175l-.542,2.747a.567.567,0,0,0,.175.452l1.976,2.461,4.866,1.659,1.969-1.077a.535.535,0,0,0,.4-.463l.4-2.627a.659.659,0,0,0-.188-.544L14.453,8.7a1.313,1.313,0,0,0-1.1-.337l-3.874.345A.707.707,0,0,0,8.951,9.175Zm1.5,1.407a.281.281,0,0,1,.192-.234l2.633-.256a.928.928,0,0,1,.724.315l2.3,2a.426.426,0,0,1,.121.352l-.1.651s-.027.237-.3.146L10.5,11.667a.269.269,0,0,1-.172-.305Z" style="fill:url(#ac)"/><path d="M9.322,9.01l-.4,2.627c-.024.157.188.481.324.653l1.817,2.33L10.8,16.334l.392.134L9.349,28.427l.395.914,1.627.555.363-.507v0l1.483-.436.081-.528-.479-.314.1-.678.523.028.2-1.283-.461-.428.093-.608.54-.087.1-.653-.469-.375.145-.946.532-.034.054-.352a1.047,1.047,0,0,1-.29-.859.688.688,0,0,1,.512-.585l.116-.756a1.6,1.6,0,0,1-.364-1.232,1.07,1.07,0,0,1,.688-.874l.1-.636.666.227.246-1.674,1.915-1.047a.535.535,0,0,0,.4-.463l.4-2.627a.657.657,0,0,0-.188-.544l-3.556-3.08a1.313,1.313,0,0,0-1.1-.336l-4.109.445A.434.434,0,0,0,9.322,9.01Zm1.5,1.407a.281.281,0,0,1,.192-.234l2.663-.289a.852.852,0,0,1,.711.218l2.3,2a.427.427,0,0,1,.122.352l-.12.781s-.027.237-.3.146L10.871,11.5A.269.269,0,0,1,10.7,11.2Z" style="fill:url(#ad)"/><polygon points="10.428 16.37 10.82 16.337 11.173 16.457 10.929 16.535 10.428 16.37" style="fill:url(#ae)"/><path d="M9.317,12.221l1.846,2.421,4.619,1.575,1.967-1.076a.454.454,0,0,0,.331-.393l.406-2.641a.53.53,0,0,0-.152-.441L14.782,8.583a1.207,1.207,0,0,0-1.011-.31l-4.109.453a.354.354,0,0,0-.237.292L9.02,11.659A1.261,1.261,0,0,0,9.317,12.221Zm1.289-1.077v0l.121-.785a.367.367,0,0,1,.25-.305l.008,0,2.675-.295a.953.953,0,0,1,.794.247l2.3,2a.563.563,0,0,1,.166.467l-.121.785c0,.01-.014.35-.411.215l-5.53-1.886A.423.423,0,0,1,10.606,11.144Z" style="fill:url(#af)"/><path d="M9.356,12.146c0,.005,1.63,2.115,1.831,2.4l4.591,1.566,1.974-1.065a.372.372,0,0,0,.264-.321l.406-2.646a.405.405,0,0,0-.118-.338L14.733,8.651a1.117,1.117,0,0,0-.931-.285L9.669,8.81a.271.271,0,0,0-.179.221l-.406,2.642A1.421,1.421,0,0,0,9.356,12.146Zm1.126-1.054.12-.778a.451.451,0,0,1,.309-.375l.008,0,.016,0,2.7-.29a1.07,1.07,0,0,1,.883.278l2.324,2.01a.694.694,0,0,1,.212.581l-.121.786a.38.38,0,0,1-.165.265.417.417,0,0,1-.365.018l-5.576-1.9a.5.5,0,0,1-.273-.219h0A.55.55,0,0,1,10.482,11.091Z" style="fill:url(#ag)"/><path d="M9.415,12.108c.006.008,1.693,2.194,1.816,2.366l4.535,1.546,1.963-1.048a.33.33,0,0,0,.228-.282l.4-2.623a.339.339,0,0,0-.1-.283L14.7,8.719a1.066,1.066,0,0,0-.884-.271l-3.4.359L9.7,8.883a.226.226,0,0,0-.142.183s-.4,2.594-.4,2.611A1.506,1.506,0,0,0,9.415,12.108Zm.952-1.007.118-.77a.463.463,0,0,1,.3-.414l2.836-.308a1.12,1.12,0,0,1,.921.292l2.316,2a.758.758,0,0,1,.234.632s-.1.633-.12.779c-.034.219-.191.5-.668.339l-5.555-1.894A.584.584,0,0,1,10.366,11.1Z" style="fill:url(#ah)"/><path d="M15.781,16.3l-.237,1.543-.689-.235-.107.7a1.158,1.158,0,0,0-.7.917,1.723,1.723,0,0,0,.367,1.283l-.1.666a.765.765,0,0,0-.527.634,1.154,1.154,0,0,0,.29.912l-.036.235-.542.031-.167,1.088.479.379-.08.522-.55.084-.113.736.471.432-.176,1.146-.532-.031-.128.837.488.317-.061.4c-.09.027-1.455.411-1.455.411l-.352.462L9.9,29.286l-.343-.822L11.4,16.434l-.493-.168.237-1.543Z" style="fill:url(#ai)"/><polygon points="11.056 16.181 15.43 17.672 15.638 16.32 11.264 14.828 11.056 16.181" style="fill:url(#aj)"/><path d="M15.388,16.234l-.842-.287L14.339,17.3l.841.287ZM14,15.76l-.208,1.353.325.111.208-1.353Z" style="fill:url(#ak)"/><path d="M14.756,17.55l-.1.676a1.251,1.251,0,0,0-.7.957A1.845,1.845,0,0,0,14.3,20.5l-.089.576a.844.844,0,0,0-.525.678,1.256,1.256,0,0,0,.275.95l-.018.119-.531.034-.188,1.221.469.375-.06.388-.539.087-.132.858.46.427-.154,1-.522-.028-.152.987.478.314-.04.262-1.506.443-1.083-.369,1.86-12.1Z" style="fill:url(#al)"/><path d="M13.423,17.1,11.563,29.2l-.246.4L10,29.16l-.289-.692,1.845-12.009Z" style="fill:url(#am)"/><polygon points="10.877 29.44 11.327 29.594 12.941 19.093 12.99 17.23 12.491 18.939 10.877 29.44" style="fill:url(#an)"/><polygon points="12.99 17.23 11.102 29.517 10.877 29.44 12.491 18.939 12.99 17.23" style="fill:url(#ao)"/><polygon points="10.028 29.151 10.477 29.304 12.091 18.803 12.14 16.94 11.641 18.65 10.028 29.151" style="fill:url(#ap)"/><polygon points="12.14 16.94 10.253 29.227 10.028 29.151 11.641 18.65 12.14 16.94" style="fill:url(#aq)"/><path d="M14.615,17.5l-.433-.148L12.4,28.932l.478-.14.061-.4L12.6,28.17l.152-.987.374.02.171-1.113-.33-.306.132-.858.387-.062.08-.519-.336-.268.188-1.221.381-.024.048-.314a1.2,1.2,0,0,1-.154-.766.85.85,0,0,1,.363-.59l.132-.856a1.79,1.79,0,0,1-.231-1.123,1.261,1.261,0,0,1,.536-.861Zm-.717-.244L12.09,29.024l.185-.054,1.791-11.655Z" style="fill:url(#ar)"/><polygon points="10.932 16.665 9.075 28.47 9.378 28.412 11.228 16.557 10.932 16.665" style="fill:url(#as)"/><polygon points="9.085 28.566 9.41 28.506 9.764 29.272 9.443 29.34 9.085 28.566" style="fill:url(#at)"/><polygon points="9.823 29.357 9.54 29.417 10.987 29.93 11.222 29.849 9.823 29.357" style="fill:url(#au)"/><polygon points="11.024 14.816 10.633 14.936 10.392 16.303 10.821 16.26 11.024 14.816" style="fill:url(#av)"/><polygon points="11.05 14.636 10.625 14.777 8.541 12.171 9.024 11.957 11.05 14.636" style="fill:url(#aw)"/><path d="M9.384,8.813s-.358.218-.378.346L8.46,11.932l.51-.253Z" style="fill:url(#ax)"/><path d="M16.435,12.332l.256-.168-2.375-2.052a.962.962,0,0,0-.538-.183l-.1.115a2.143,2.143,0,0,1,.362.211Z" style="fill:url(#ay)"/><path d="M16.724,12.208a.393.393,0,0,1,.058.221c-.016.1-.112.774-.12.825l-.283.085s.107-.7.115-.747a.4.4,0,0,0-.033-.213Z" style="fill:url(#az)"/><path d="M10.424,10.725l-.058.375a.584.584,0,0,0,.381.653L16.3,13.647c.478.163.634-.12.668-.339l.051-.334,1.139.388-.2,1.327a.33.33,0,0,1-.228.282l-1.963,1.048-4.535-1.546c-.123-.173-1.81-2.359-1.816-2.366a1.506,1.506,0,0,1-.257-.43l.2-1.315Z" style="fill:url(#ba)"/><path d="M14.756,8.764l-.179,1.166.432.373.179-1.167Zm1.851,1.595-1.119-.965-.179,1.167,1.119.965Zm-.5,3.223-1.2-.411-.372,2.423,1.2.411Zm-1.526-.52L14.12,12.9l-.372,2.423.465.159Z" style="fill:url(#bb)"/><path d="M9.936,2.733c2.042-1.441,5.206-.715,7.065,1.8A6.169,6.169,0,0,1,18.27,9.1c-.219-.73-1.023-.427-1.664-.441a4.11,4.11,0,0,0-.763-3.207C14.6,3.778,12.41,3.1,11.07,4.094s-1.382,3.253-.143,4.929a3.68,3.68,0,0,0,3.69,1.742c.521.444,1,.871,1.507,1.329-1.84,1.134-4.8.334-6.51-1.982C7.754,7.6,7.684,4.323,9.936,2.733Z" style="fill:url(#bc)"/><path d="M9.956,2.841c1.939-1.405,5.111-.606,6.892,1.8A6.587,6.587,0,0,1,18.228,8.8c-.293-.387-1.035-.264-1.466-.211a4.6,4.6,0,0,0-.823-3.272c-1.317-1.78-3.546-2.373-4.97-1.32s-1.442,3.27-.125,5.051a4.034,4.034,0,0,0,3.842,1.905c.4.35.79.715,1.185,1.073-1.982,1.012-4.528.084-6.123-2.073C7.966,7.545,7.851,4.366,9.956,2.841Z" style="fill:url(#bd)"/><path d="M10.1,2.918c1.855-1.345,4.971-.5,6.675,1.8a6.635,6.635,0,0,1,1.361,3.89,1.872,1.872,0,0,0-1.148-.126,4.555,4.555,0,0,0-.946-3.23c-1.394-1.885-3.6-2.472-5.1-1.357s-1.511,3.279-.171,5.2a4.075,4.075,0,0,0,3.976,1.973c.323.285.639.58.957.871-1.939.959-4.394-.1-5.893-2.131C8.1,7.511,8.1,4.363,10.1,2.918Z" style="fill:url(#be)"/><path d="M9.684,3.412C8.6,4.969,8.825,7.5,10.3,9.494c1.413,1.911,3.466,2.885,5.249,2.443-1.694.674-4.074-.233-5.554-2.235C8.455,7.621,8.335,4.919,9.684,3.412Z" style="fill:url(#bf)"/><path d="M9.9,3.511c-.171.291.366.627.547.144a4.29,4.29,0,0,1,2.442-1.222A3.558,3.558,0,0,0,9.9,3.511Zm.077.506a.244.244,0,1,0,.211.273A.243.243,0,0,0,9.975,4.017Z" style="fill:url(#bg)"/><path d="M11.035,3.763c1.4-1.181,3.664-.647,5.163,1.132a4.723,4.723,0,0,1,1.2,3.542c-.136.014-.273.03-.411.048a4.555,4.555,0,0,0-.946-3.23c-1.394-1.885-3.6-2.472-5.1-1.357-.071.053-.136.11-.2.167A2.672,2.672,0,0,1,11.035,3.763Z" style="fill:url(#bh)"/></svg>
\ No newline at end of file
diff --git a/icons/file_type_markdown.svg b/icons/file_type_markdown.svg
deleted file mode 100644
index c5b32a6f7b..0000000000
--- a/icons/file_type_markdown.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><title>file_type_markdown</title><rect x="2.5" y="7.955" width="27" height="16.091" style="fill:none;stroke:#755838"/><polygon points="5.909 20.636 5.909 11.364 8.636 11.364 11.364 14.773 14.091 11.364 16.818 11.364 16.818 20.636 14.091 20.636 14.091 15.318 11.364 18.727 8.636 15.318 8.636 20.636 5.909 20.636" style="fill:#755838"/><polygon points="22.955 20.636 18.864 16.136 21.591 16.136 21.591 11.364 24.318 11.364 24.318 16.136 27.045 16.136 22.955 20.636" style="fill:#755838"/></svg>
\ No newline at end of file
diff --git a/icons/file_type_rust.svg b/icons/file_type_rust.svg
deleted file mode 100644
index f62525ee8c..0000000000
--- a/icons/file_type_rust.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 32 32"><path d="M15 3.77a.951.951 0 1 1 1.902 0 .951.951 0 0 1-1.902 0m-11.346 8.61a.951.951 0 1 1 1.902 0 .951.951 0 0 1-1.902 0m22.692.044a.951.951 0 0 1 1.902 0 .951.951 0 0 1-1.902 0M6.406 13.73a.87.87 0 0 0 .441-1.146l-.422-.954h1.66v7.48H4.736a11.71 11.71 0 0 1-.379-4.47zm6.942.184v-2.205H17.3c.204 0 1.44.236 1.44 1.16 0 .768-.95 1.044-1.73 1.044zM7.952 25.785a.951.951 0 1 1 1.902 0 .951.951 0 0 1-1.902 0m14.093.044a.951.951 0 0 1 1.902 0 .951.951 0 0 1-1.902 0m.294-2.157c-.47-.1-.93.198-1.03.667l-.477 2.228a11.71 11.71 0 0 1-9.765-.047l-.477-2.228c-.1-.47-.56-.768-1.03-.667l-1.967.422a11.71 11.71 0 0 1-1.017-1.199h9.57c.108 0 .18-.02.18-.118v-3.385c0-.1-.072-.118-.18-.118h-2.8v-2.146h3.027c.276 0 1.477.08 1.862 1.614l.565 2.5c.18.55.913 1.653 1.693 1.653h4.94a11.71 11.71 0 0 1-1.085 1.255zm5.314-8.938a11.71 11.71 0 0 1 .025 2.033h-1.2c-.12 0-.17.08-.17.197v.552c0 1.3-.732 1.58-1.374 1.653-.61.07-1.29-.256-1.372-.63-.36-2.028-.96-2.46-1.9-3.21 1.177-.748 2.402-1.85 2.402-3.327 0-1.594-1.093-2.598-1.838-3.09-1.045-.69-2.202-.827-2.514-.827H7.277a11.71 11.71 0 0 1 6.551-3.697l1.465 1.537c.33.347.88.36 1.226.028l1.64-1.567a11.71 11.71 0 0 1 8.017 5.709l-1.122 2.534a.87.87 0 0 0 .441 1.146zm2.798.04l-.038-.392 1.156-1.078c.235-.22.147-.66-.153-.772l-1.477-.552-.116-.38.92-1.28c.188-.26.015-.675-.3-.727l-1.558-.253-.187-.35.655-1.437c.134-.293-.115-.667-.437-.655l-1.58.055-.25-.303.363-1.54c.073-.313-.244-.63-.557-.557l-1.54.363-.304-.25.055-1.58c.012-.32-.362-.57-.654-.437l-1.436.655-.35-.188-.254-1.558c-.05-.316-.467-.488-.727-.3l-1.28.92-.38-.115-.552-1.477c-.112-.3-.553-.388-.772-.154l-1.078 1.156-.392-.038-.832-1.345c-.168-.272-.62-.272-.787 0l-.832 1.345-.392.038L13.305.43c-.22-.234-.66-.147-.772.154l-.552 1.477-.38.115-1.28-.92c-.26-.188-.676-.015-.727.3l-.254 1.558-.35.188-1.436-.655c-.292-.133-.667.117-.654.437l.055 1.58-.304.25-1.54-.363c-.313-.073-.63.244-.557.557l.363 1.54-.25.303-1.58-.055c-.32-.01-.57.362-.437.655l.655 1.437-.188.35-1.558.253c-.316.05-.488.467-.3.727l.92 1.28-.116.38-1.477.552c-.3.112-.388.553-.153.772l1.156 1.078-.038.392-1.345.832c-.272.168-.272.62 0 .787l1.345.832.038.392L.43 18.697c-.234.22-.147.66.153.772l1.477.552.116.38-.92 1.28c-.187.26-.015.676.3.727l1.557.253.188.35-.655 1.436c-.133.292.118.667.437.655l1.58-.055.25.304-.363 1.54c-.073.312.244.63.557.556l1.54-.363.304.25-.055 1.58c-.012.32.362.57.654.437l1.436-.655.35.188.254 1.557c.05.317.467.488.727.302l1.28-.922.38.116.552 1.477c.112.3.553.388.772.153l1.078-1.156.392.04.832 1.345c.168.27.618.272.787 0l.832-1.345.392-.04 1.078 1.156c.22.235.66.147.772-.153l.552-1.477.38-.116 1.28.922c.26.187.676.015.727-.302l.254-1.557.35-.188 1.436.655c.292.133.666-.116.654-.437l-.055-1.58.303-.25 1.54.363c.313.073.63-.244.557-.556l-.363-1.54.25-.304 1.58.055c.32.013.57-.363.437-.655l-.655-1.436.187-.35 1.558-.253c.317-.05.49-.466.3-.727l-.92-1.28.116-.38 1.477-.552c.3-.113.388-.553.153-.772l-1.156-1.078.038-.392 1.345-.832c.272-.168.273-.618 0-.787z"/></svg>
\ No newline at end of file
diff --git a/icons/file_type_toml.svg b/icons/file_type_toml.svg
deleted file mode 100644
index a0a5890783..0000000000
--- a/icons/file_type_toml.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><title>file_type_toml</title><path d="M22.76,6.83v3.25h-5V25.17H14.26V10.08h-5V6.83Z" style="fill:#7f7f7f"/><path d="M2,2H8.2V5.09H5.34v21.8H8.2V30H2Z" style="fill:#bfbfbf"/><path d="M30,30H23.8V26.91h2.86V5.11H23.8V2H30Z" style="fill:#bfbfbf"/></svg>
\ No newline at end of file
diff --git a/icons/file_type_yaml.svg b/icons/file_type_yaml.svg
deleted file mode 100644
index 601979d57d..0000000000
--- a/icons/file_type_yaml.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><title>file_type_yaml</title><path d="M2,12.218c.755,0,1.51-.008,2.264,0l.053.038Q5.7,13.638,7.078,15.014c.891-.906,1.8-1.794,2.7-2.7.053-.052.11-.113.192-.1.608,0,1.215,0,1.823,0a1.4,1.4,0,0,1,.353.019c-.7.67-1.377,1.369-2.069,2.05L5.545,18.8c-.331.324-.648.663-.989.975-.754.022-1.511.007-2.266.007,1.223-1.209,2.431-2.433,3.658-3.637C4.627,14.841,3.318,13.525,2,12.218Z" style="fill:#ffe885"/><path d="M12.7,12.218c.613,0,1.226,0,1.839,0q0,3.783,0,7.566c-.611,0-1.222.012-1.832-.008,0-1.664,0-3.329,0-4.994-1.6,1.607-3.209,3.2-4.811,4.8-.089.08-.166.217-.305.194-.824-.006-1.649,0-2.474,0Q8.916,16,12.7,12.218Z" style="fill:#ffe885"/><path d="M14.958,12.22c.47-.009.939,0,1.409,0,.836.853,1.69,1.689,2.536,2.532q1.268-1.267,2.539-2.532.7,0,1.4,0-.008,3.784,0,7.567c-.471,0-.943.006-1.414,0q.008-2.387,0-4.773c-.844.843-1.676,1.7-2.526,2.536-.856-.835-1.687-1.695-2.532-2.541,0,1.594-.006,3.188.006,4.781-.472,0-.943.005-1.415,0Q14.958,16,14.958,12.22Z" style="fill:#ffe885"/><path d="M23.259,12.217c.472,0,.944-.007,1.416,0q-.007,3.083,0,6.166c1.26,0,2.521,0,3.782,0,.063.006.144-.012.191.045.448.454.907.9,1.353,1.354q-3.371.007-6.741,0Q23.267,16,23.259,12.217Z" style="fill:#ffe885"/></svg>
\ No newline at end of file
diff --git a/icons/git-icon.svg b/icons/git-icon.svg
deleted file mode 100644
index 74a9c0ab76..0000000000
--- a/icons/git-icon.svg
+++ /dev/null
@@ -1,52 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   id="svg2"
-   version="1.1"
-   inkscape:version="0.91 r13725"
-   xml:space="preserve"
-   width="114.8625"
-   height="114.8625"
-   viewBox="0 0 114.8625 114.8625"
-   sodipodi:docname="Git-Icon-Black.svg"><metadata
-     id="metadata8"><rdf:RDF><cc:Work
-         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
-     id="defs6" /><sodipodi:namedview
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="702"
-     inkscape:window-height="480"
-     id="namedview4"
-     showgrid="false"
-     inkscape:zoom="2.0546305"
-     inkscape:cx="57.431252"
-     inkscape:cy="57.431252"
-     inkscape:window-x="0"
-     inkscape:window-y="25"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="g10" /><g
-     id="g10"
-     inkscape:groupmode="layer"
-     inkscape:label="ink_ext_XXXXXX"
-     transform="matrix(1.25,0,0,-1.25,0,114.8625)"><g
-       id="g12"
-       transform="scale(0.1,0.1)"><path
-         d="M 901.547,500.352 500.355,901.527 c -23.093,23.11 -60.566,23.11 -83.691,0 L 333.363,818.211 439.039,712.535 c 24.559,8.293 52.723,2.727 72.293,-16.847 19.688,-19.696 25.207,-48.102 16.699,-72.75 L 629.887,521.094 c 24.648,8.496 53.066,3.004 72.754,-16.711 27.5,-27.492 27.5,-72.059 0,-99.574 -27.52,-27.516 -72.078,-27.516 -99.61,0 -20.683,20.703 -25.801,51.097 -15.312,76.582 l -95,94.992 0,-249.969 c 6.699,-3.32 13.027,-7.742 18.613,-13.312 27.5,-27.497 27.5,-72.059 0,-99.598 -27.5,-27.488 -72.09,-27.488 -99.57,0 -27.5,27.539 -27.5,72.101 0,99.598 6.797,6.789 14.668,11.925 23.066,15.363 l 0,252.281 c -8.398,3.438 -16.25,8.531 -23.066,15.367 -20.828,20.821 -25.84,51.395 -15.157,76.977 L 292.426,777.285 17.3281,502.211 c -23.10544,-23.129 -23.10544,-60.602 0,-83.711 L 418.539,17.3242 c 23.098,-23.10545 60.559,-23.10545 83.691,0 L 901.547,416.641 c 23.117,23.113 23.117,60.605 0,83.711"
-         style="fill:#100f0d;fill-opacity:1;fill-rule:nonzero;stroke:none"
-         id="path14"
-         inkscape:connector-curvature="0" /></g></g></svg>
\ No newline at end of file
diff --git a/icons/remote.svg b/icons/lapce/lapce_remote.svg
similarity index 100%
rename from icons/remote.svg
rename to icons/lapce/lapce_remote.svg
diff --git a/icons/link.svg b/icons/link.svg
deleted file mode 100644
index 1f9933c9bd..0000000000
--- a/icons/link.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M4.40024 3H7.48524C8.38698 3 9.25178 3.35821 9.88941 3.99584C10.527 4.63346 10.8852 5.49826 10.8852 6.4V6.605C10.8839 7.50587 10.5251 8.36939 9.88764 9.00593C9.25016 9.64247 8.38611 10 7.48524 10H7.00024V9H7.48524C8.11917 8.99868 8.72683 8.74662 9.17555 8.29883C9.62427 7.85105 9.8776 7.24392 9.88024 6.61V6.4C9.88025 5.76521 9.62877 5.15627 9.18084 4.70647C8.73291 4.25667 8.12503 4.00265 7.49024 4H4.40024C3.76372 4 3.15328 4.25286 2.70319 4.70294C2.48033 4.9258 2.30354 5.19038 2.18293 5.48156C2.06232 5.77274 2.00024 6.08483 2.00024 6.4V6.605C2.00175 7.17053 2.2034 7.71727 2.56948 8.14833C2.93556 8.57938 3.44242 8.86693 4.00024 8.96V9.96C3.17805 9.86262 2.41964 9.46858 1.86731 8.85181C1.31498 8.23503 1.00667 7.43791 1.00024 6.61V6.4C1.00157 5.49867 1.3602 4.63463 1.99754 3.9973C2.63488 3.35996 3.49891 3.00132 4.40024 3ZM12.0004 7.04V6.04C12.8243 6.1376 13.584 6.53307 14.1366 7.15194C14.6891 7.77081 14.9964 8.57036 15.0004 9.4V9.605C14.9977 10.5046 14.6392 11.3666 14.0031 12.0027C13.367 12.6388 12.505 12.9974 11.6054 13H8.51536C7.61622 12.9987 6.75421 12.6413 6.11796 12.0059C5.4817 11.3706 5.123 10.5091 5.12036 9.61V9.4C5.12036 8.49913 5.47789 7.63508 6.11443 6.9976C6.75097 6.36012 7.61449 6.00132 8.51536 6H9.00036V7H8.51536C7.87971 7.00132 7.27054 7.25477 6.82154 7.70471C6.37253 8.15465 6.12036 8.76435 6.12036 9.4V9.605C6.12168 10.2398 6.37444 10.8482 6.8233 11.2971C7.27216 11.7459 7.88057 11.9987 8.51536 12H11.6054C12.2393 11.9987 12.8469 11.7466 13.2957 11.2988C13.7444 10.851 13.9977 10.2439 14.0004 9.61V9.4C14 8.83361 13.7989 8.28568 13.4327 7.85358C13.0666 7.42149 12.559 7.13321 12.0004 7.04Z" fill="#424242"/>
-</svg>
diff --git a/icons/search.svg b/icons/search.svg
deleted file mode 100644
index 9a39565868..0000000000
--- a/icons/search.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M15.2502 1.02546e-06C13.6607 -0.000791296 12.1048 0.457574 10.7697 1.32007C9.43447 2.18256 8.37681 3.4124 7.724 4.8617C7.07118 6.31099 6.85102 7.91801 7.08984 9.4895C7.32867 11.061 8.01628 12.5301 9.07019 13.72L1.00024 22.88L2.12024 23.88L10.1703 14.76C11.2057 15.5693 12.4195 16.1196 13.7106 16.365C15.0017 16.6104 16.3328 16.5437 17.5929 16.1707C18.853 15.7976 20.0058 15.1288 20.9552 14.2201C21.9046 13.3114 22.6232 12.1891 23.0511 10.9465C23.4791 9.70396 23.6041 8.37703 23.4155 7.07642C23.227 5.77581 22.7304 4.53915 21.9673 3.46924C21.2041 2.39933 20.1964 1.52711 19.0281 0.925416C17.8597 0.323719 16.5644 0.00991516 15.2502 0.0100108V1.02546e-06ZM15.2502 15C13.9152 15 12.6102 14.6041 11.5001 13.8624C10.3901 13.1207 9.52493 12.0665 9.01404 10.8331C8.50315 9.59973 8.36943 8.24248 8.62988 6.93311C8.89033 5.62373 9.53329 4.42106 10.4773 3.47705C11.4213 2.53305 12.624 1.89009 13.9333 1.62964C15.2427 1.36919 16.6 1.5029 17.8334 2.01379C19.0668 2.52469 20.121 3.38985 20.8627 4.49988C21.6044 5.60991 22.0002 6.91498 22.0002 8.25C22.0002 10.0402 21.2891 11.7571 20.0232 13.023C18.7573 14.2888 17.0405 15 15.2502 15Z" fill="#424242"/>
-</svg>
diff --git a/icons/settings.svg b/icons/settings.svg
deleted file mode 100644
index 9a64fbdf88..0000000000
--- a/icons/settings.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24"><path d="M24 13.616v-3.232c-1.651-.587-2.694-.752-3.219-2.019v-.001c-.527-1.271.1-2.134.847-3.707l-2.285-2.285c-1.561.742-2.433 1.375-3.707.847h-.001c-1.269-.526-1.435-1.576-2.019-3.219h-3.232c-.582 1.635-.749 2.692-2.019 3.219h-.001c-1.271.528-2.132-.098-3.707-.847l-2.285 2.285c.745 1.568 1.375 2.434.847 3.707-.527 1.271-1.584 1.438-3.219 2.02v3.232c1.632.58 2.692.749 3.219 2.019.53 1.282-.114 2.166-.847 3.707l2.285 2.286c1.562-.743 2.434-1.375 3.707-.847h.001c1.27.526 1.436 1.579 2.019 3.219h3.232c.582-1.636.75-2.69 2.027-3.222h.001c1.262-.524 2.12.101 3.698.851l2.285-2.286c-.744-1.563-1.375-2.433-.848-3.706.527-1.271 1.588-1.44 3.221-2.021zm-12 2.384c-2.209 0-4-1.791-4-4s1.791-4 4-4 4 1.791 4 4-1.791 4-4 4z"/></svg>
\ No newline at end of file
diff --git a/icons/split-horizontal.svg b/icons/split-horizontal.svg
deleted file mode 100644
index f025e26ba0..0000000000
--- a/icons/split-horizontal.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M14.0002 1H3.00024L2.00024 2V13L3.00024 14H14.0002L15.0002 13V2L14.0002 1ZM8.00024 13H3.00024V2H8.00024V13ZM14.0002 13H9.00024V2H14.0002V13Z" fill="#424242"/>
-</svg>
diff --git a/icons/terminal.svg b/icons/terminal.svg
deleted file mode 100644
index d279a90653..0000000000
--- a/icons/terminal.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M3 1.5L1.5 3V21L3 22.5H21L22.5 21V3L21 1.5H3ZM3 21V3H21V21H3ZM8.65649 16.99L9.6937 18.0513L14.954 12.8078V11.8965L9.69398 6.63641L8.65856 7.69591L13.2486 12.3979L8.65649 16.99Z" fill="#424242"/>
-</svg>
diff --git a/icons/triangle-right.svg b/icons/triangle-right.svg
deleted file mode 100644
index 689b27c299..0000000000
--- a/icons/triangle-right.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M5.56 14L5 13.587V2.393L5.54 2 11 7.627v.827L5.56 14z"/></svg>
\ No newline at end of file
diff --git a/icons/warning.svg b/icons/warning.svg
deleted file mode 100644
index 32695e1117..0000000000
--- a/icons/warning.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M7.56 1H8.44L14.98 13.26L14.54 14H1.44L1 13.26L7.56 1ZM8 2.28L2.28 13H13.7L8 2.28ZM8.625 12V11H7.375V12H8.625ZM7.375 10V6H8.625V10H7.375Z" fill="#DDB100"/>
-</svg>
diff --git a/lapce-core/Cargo.toml b/lapce-core/Cargo.toml
index ca415493fa..5ff71ea2c4 100644
--- a/lapce-core/Cargo.toml
+++ b/lapce-core/Cargo.toml
@@ -1,76 +1,142 @@
 [package]
 name = "lapce-core"
-version = "0.1.2"
-authors = ["Dongdong Zhou <dzhou121@gmail.com>"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
 
 [dependencies]
-thiserror = "1.0"
-itertools = "0.10.3"
-log = "0.4.14"
+anyhow.workspace = true
+directories.workspace = true
+itertools.workspace = true
+log.workspace = true
+once_cell.workspace = true
+serde.workspace = true
+strum.workspace = true
+strum_macros.workspace = true
+thiserror.workspace = true
+
+lsp-types.workspace = true
+
+lapce-xi-rope.workspace = true
+
+lapce-rpc.workspace = true
+
 bitflags = "1.3.2"
-strum = "0.24.0"
-strum_macros = "0.24"
-serde = "1.0"
-serde_json = "1.0"
-tree-sitter = "0.20.6"
-tree-sitter-highlight = "0.20.1"
-tree-sitter-rust = { version = "0.20.0", optional = true }
-tree-sitter-go = { version = "0.19.1", optional = true }
-tree-sitter-javascript = { version = "0.20.0", optional = true }
-tree-sitter-typescript = { version = "0.20.0", optional = true }
-tree-sitter-python = { version = "0.19.1", optional = true }
-tree-sitter-toml = { version = "0.20.0", optional = true }
-tree-sitter-elixir = { git = "https://github.com/elixir-lang/tree-sitter-elixir.git", version = "0.19.0", optional = true  }
-tree-sitter-php = { git = "https://github.com/tree-sitter/tree-sitter-php.git", version = "0.19.1", optional = true  }
-tree-sitter-ruby = { git = "https://github.com/Liberatys/tree-sitter-ruby.git", branch = "chore/allow-range-of-tree-sitter", optional = true  }
-tree-sitter-c = { version = "0.20.1", optional = true }
+slotmap = "1.0"
+arc-swap = "1.5.1"
+tree-sitter = "0.20.7"
+
+# please keep below dependencies and features sorted just like LANGUAGES in language.rs
+
+tree-sitter-bash = { git = "https://github.com/tree-sitter/tree-sitter-bash", rev = "4488aa41406547e478636a4fcfd24f5bbc3f2f74", optional = true }
+tree-sitter-c = { version = "0.20.2", optional = true }
+tree-sitter-c-sharp = { git = "https://github.com/tree-sitter/tree-sitter-c-sharp", rev = "5b60f99545fea00a33bbfae5be956f684c4c69e2", optional = true }
 tree-sitter-cpp = { version = "0.20.0", optional = true }
-tree-sitter-json = { version = "0.19.0", optional = true }
-tree-sitter-md = { git = "https://github.com/MDeiml/tree-sitter-markdown.git", version = "0.0.1", optional = true  }
-tree-sitter-html = { version = "0.19.0", optional = true }
-tree-sitter-java = { git = "https://github.com/tree-sitter/tree-sitter-java.git", version = "0.20.0", optional = true  }
+tree-sitter-clojure = { git = "https://github.com/abreumatheus/tree-sitter-clojure", rev = "fdc969eb04fc711e38ad74afe441d74b3b5d3091", optional = true }
+tree-sitter-cmake = { version = "0.1.0", optional = true }
+# switch to upstream version after this is merged https://github.com/tree-sitter/tree-sitter-css/pull/22
+tree-sitter-css = { git = "https://github.com/syntacti/tree-sitter-css", rev = "397aa132b9982fcdd2d473ed69343762a557f10a", optional = true }
+tree-sitter-d = {  git = "https://github.com/ghishadow/tree-sitter-d", rev = "36603135ecb37ac6494c520efff91b875815d6f7", optional = true }
+tree-sitter-dart = { git = "https://github.com/syntacti/tree-sitter-dart", rev = "78cad4503571d72666f78d5ba8ed6c1417653063", optional = true }
+tree-sitter-dockerfile = { git = "https://github.com/panekj/tree-sitter-dockerfile", rev = "c49d819e07685c90456270f1cc654d9cba640f53", optional = true }
+tree-sitter-elixir = { git = "https://github.com/elixir-lang/tree-sitter-elixir.git", rev = "05e3631c6a0701c1fa518b0fee7be95a2ceef5e2", optional = true }
 tree-sitter-elm = { version = "5.6.0", optional = true }
-tree-sitter-swift = { version = "0.3.0", optional = true }
-tree-sitter-ql = { git = "https://github.com/tree-sitter/tree-sitter-ql", version = "0.19.0", optional = true }
-tree-sitter-haskell = { git = "https://github.com/tree-sitter/tree-sitter-haskell", version = "0.14.0", optional = true }
-tree-sitter-ocaml = { git = "https://github.com/tree-sitter/tree-sitter-ocaml", version = "0.20.0", optional = true }
-tree-sitter-glimmer = { git = "https://github.com/VixieTSQ/tree-sitter-glimmer", version = "0.0.1", optional = true }
-tree-sitter-haxe = { git = "https://github.com/VixieTSQ/tree-sitter-haxe", version = "0.0.1", optional = true }
-tree-sitter-hcl = { git = "https://github.com/VixieTSQ/tree-sitter-hcl", version = "0.0.1", optional = true }
-tree-sitter-scss = { git = "https://github.com/VixieTSQ/tree-sitter-scss", version = "0.0.1", branch = "patch-1", optional = true }
+tree-sitter-erlang = { git = "https://github.com/WhatsApp/tree-sitter-erlang", rev = "a8b8b0e16c4f5552f5e85af3dec976a5d16af8b9", optional = true }
+tree-sitter-glimmer = { git = "https://github.com/VixieTSQ/tree-sitter-glimmer", rev = "7281caca2ba114e1960c5d944a37860ef0841426", optional = true }
+tree-sitter-glsl = { git = "https://github.com/theHamsta/tree-sitter-glsl", rev = "74329feb2605deccd32b1c644af507daa6fb82f1", optional = true }
+tree-sitter-go = { version = "0.19.1", optional = true }
 tree-sitter-hare = { version = "0.20.7", optional = true }
-lsp-types = { version = "0.89.2", features = ["proposed"] }
-xi-rope = { git = "https://github.com/lapce/xi-editor", features = ["serde"] }
-lapce-rpc = { path = "../lapce-rpc" }
+tree-sitter-haskell = { git = "https://github.com/tree-sitter/tree-sitter-haskell", rev = "e30bdfd53eb28c73f26a68b77d436fd2140af167", optional = true }
+tree-sitter-haxe = { git = "https://github.com/vantreeseba/tree-sitter-haxe", rev = "52e3d2b9c3955aca886bccc38b496ef99b603a09", optional = true }
+tree-sitter-hcl = { git = "https://github.com/VixieTSQ/tree-sitter-hcl", rev = "f4aa4553344e03e149ec459549a7f686d6846626", optional = true }
+tree-sitter-html = { version = "0.19.0", optional = true }
+tree-sitter-java = { git = "https://github.com/tree-sitter/tree-sitter-java.git", rev = "09d650def6cdf7f479f4b78f595e9ef5b58ce31e", optional = true }
+tree-sitter-javascript = { version = "0.20.0", optional = true }
+# new version cannot be published on crates.io - https://github.com/tree-sitter/tree-sitter-json/issues/21
+# tree-sitter-json = { version = "0.19.0", optional = true }
+tree-sitter-json = { git = "https://github.com/tree-sitter/tree-sitter-json.git", rev = "11e2cc12d9b267766fb11a06e52952792fd8e3f0", optional = true }
+tree-sitter-julia = { git = "https://github.com/varlad/tree-sitter-julia.git", rev = "2ad4c9b79e0f213b61dbb3820754bfc6306e595a", optional = true }
+tree-sitter-kotlin = { git = "https://github.com/fwcd/tree-sitter-kotlin", rev = "a4f71eb9b8c9b19ded3e0e9470be4b1b77c2b569", optional = true }
+tree-sitter-latex = { git = "https://github.com/latex-lsp/tree-sitter-latex", rev = "b3b2cf27f33e71438ebe46934900b1153901c6f2", optional = true }
+tree-sitter-lua = { git = "https://github.com/syntacti/tree-sitter-lua", rev = "a29f646c14ed800aaeef1ca58a9bacc6d92922e8", optional = true }
+tree-sitter-md = { git = "https://github.com/MDeiml/tree-sitter-markdown.git", rev = "272e080bca0efd19a06a7f4252d746417224959e", optional = true }
+tree-sitter-nix = { git = "https://github.com/panekj/tree-sitter-nix", rev = "59fc47150ab437e8bb356c7ab21e9531e87f7cc8", optional = true }
+tree-sitter-ocaml = { git = "https://github.com/tree-sitter/tree-sitter-ocaml", rev = "cc26b1ef111100f26a137bcbcd39fd4e35be9a59", optional = true }
+tree-sitter-php = { git = "https://github.com/tree-sitter/tree-sitter-php.git", rev = "ab2e72179ceb8bb0b249c8ac9162a148e911b3dc", optional = true }
+tree-sitter-prisma-io = { version = "1.3.0", optional = true }
+tree-sitter-protobuf = { git = "https://github.com/yusdacra/tree-sitter-protobuf", rev = "5aef38d655f76a6b0d172340eed3766c93b3124c", optional = true }
+tree-sitter-python = { version = "0.20.1", optional = true }
+tree-sitter-ql = { git = "https://github.com/tree-sitter/tree-sitter-ql", rev = "bd087020f0d8c183080ca615d38de0ec827aeeaf", optional = true }
+tree-sitter-r = { version = "0.19.5", optional = true }
+tree-sitter-ruby = { git = "https://github.com/tree-sitter/tree-sitter-ruby.git", rev = "656abef0645caea793e33c1c773570722463e1d8", optional = true }
+tree-sitter-rust = { version = "0.20.0", optional = true }
+tree-sitter-scheme = { git = "https://github.com/6cdh/tree-sitter-scheme.git", rev = "af0fd1fa452cb2562dc7b5c8a8c55551c39273b9", optional = true }
+tree-sitter-scss = { git = "https://github.com/VixieTSQ/tree-sitter-scss", rev = "3aac3391ede5098edbf4cc8a9f6d0cfdfe28e5dc", optional = true }
+# switch to upstream version after this is merged  https://github.com/m-novikov/tree-sitter-sql/pull/68
+tree-sitter-sql = { git = "https://github.com/oknozor/tree-sitter-sql", rev = "15dad0f3cae8a094a7dac17d712ea8fb25228011", optional = true }
+tree-sitter-svelte = { git = "https://github.com/Himujjal/tree-sitter-svelte", rev = "52e122ae68b316d3aa960a0a422d3645ba717f42", optional = true }
+tree-sitter-swift = { version = "0.3.4", optional = true }
+tree-sitter-toml = { version = "0.20.0", optional = true }
+tree-sitter-typescript = { version = "0.20.0", optional = true }
+tree-sitter-vue = { version = "0.0.3", optional = true }
+tree-sitter-wgsl = { git = "https://github.com/szebniok/tree-sitter-wgsl", rev = "272e89ef2aeac74178edb9db4a83c1ffef80a463", optional = true }
+tree-sitter-xml = { git = "https://github.com/RenjiSann/tree-sitter-xml", rev = "422528a43630db6dcc1e222d1c5ee3babd559473", optional = true }
+tree-sitter-yaml = { git = "https://github.com/panekj/tree-sitter-yaml", rev = "80c8d76847f03e772c5c524cf29bafb56858a8d1", optional = true }
+tree-sitter-zig = { git = "https://github.com/maxxnino/tree-sitter-zig", rev = "8d3224c3bd0890fe08358886ebf54fca2ed448a6", optional = true }
 
 [features]
 default = []
 # See lapce-ui/Cargo.toml for how to choose the languages.  See also
 # src/language.rs for how to add new languages.  The feature names should follow
 # the tree-sitter crate names.
-lang-rust = ["dep:tree-sitter-rust"]
-lang-go = ["dep:tree-sitter-go"]
-lang-javascript = ["dep:tree-sitter-javascript"]
-lang-typescript = ["dep:tree-sitter-typescript"]
-lang-python = ["dep:tree-sitter-python"]
-lang-toml = ["dep:tree-sitter-toml"]
-lang-elixir = ["dep:tree-sitter-elixir"]
-lang-php = ["dep:tree-sitter-php"]
-lang-ruby = ["dep:tree-sitter-ruby"]
+lang-bash = ["dep:tree-sitter-bash"]
 lang-c = ["dep:tree-sitter-c"]
+lang-clojure = ["dep:tree-sitter-clojure"]
+lang-cmake = ["dep:tree-sitter-cmake"]
 lang-cpp = ["dep:tree-sitter-cpp"]
-lang-json = ["dep:tree-sitter-json"]
-lang-md = ["dep:tree-sitter-md"]
-lang-html = ["dep:tree-sitter-html"]
-lang-java = ["dep:tree-sitter-java"]
+lang-csharp = ["dep:tree-sitter-c-sharp"]
+lang-css = ["dep:tree-sitter-css"]
+lang-d = ["dep:tree-sitter-d"]
+lang-dart = ["dep:tree-sitter-dart"]
+lang-dockerfile = ["dep:tree-sitter-dockerfile"]
+lang-elixir = ["dep:tree-sitter-elixir"]
 lang-elm = ["dep:tree-sitter-elm"]
-lang-swift = ["dep:tree-sitter-swift"]
-lang-ql = ["dep:tree-sitter-ql"]
-lang-haskell = ["dep:tree-sitter-haskell"]
-lang-ocaml = ["dep:tree-sitter-ocaml"]
+lang-erlang = ["dep:tree-sitter-erlang"]
 lang-glimmer = ["dep:tree-sitter-glimmer"]
+lang-glsl = ["dep:tree-sitter-glsl"]
+lang-go = ["dep:tree-sitter-go"]
+lang-hare = ["dep:tree-sitter-hare"]
+lang-haskell = ["dep:tree-sitter-haskell"]
 lang-haxe = ["dep:tree-sitter-haxe"]
 lang-hcl = ["dep:tree-sitter-hcl"]
+lang-html = ["dep:tree-sitter-html"]
+lang-java = ["dep:tree-sitter-java"]
+lang-javascript = ["dep:tree-sitter-javascript"]
+lang-json = ["dep:tree-sitter-json"]
+lang-julia = ["dep:tree-sitter-julia"]
+lang-kotlin = ["dep:tree-sitter-kotlin"]
+lang-latex = ["dep:tree-sitter-latex"]
+lang-lua = ["dep:tree-sitter-lua"]
+lang-markdown = ["dep:tree-sitter-md"]
+lang-nix = ["dep:tree-sitter-nix"]
+lang-ocaml = ["dep:tree-sitter-ocaml"]
+lang-php = ["dep:tree-sitter-php"]
+lang-prisma = ["dep:tree-sitter-prisma-io"]
+lang-protobuf = ["dep:tree-sitter-protobuf"]
+lang-python = ["dep:tree-sitter-python"]
+lang-ql = ["dep:tree-sitter-ql"]
+lang-r = ["dep:tree-sitter-r"]
+lang-ruby = ["dep:tree-sitter-ruby"]
+lang-rust = ["dep:tree-sitter-rust"]
+lang-scheme = ["dep:tree-sitter-scheme"]
 lang-scss = ["dep:tree-sitter-scss"]
-lang-hare = ["dep:tree-sitter-hare"]
\ No newline at end of file
+lang-sql = ["dep:tree-sitter-sql"]
+lang-svelte = ["dep:tree-sitter-svelte"]
+lang-swift = ["dep:tree-sitter-swift"]
+lang-toml = ["dep:tree-sitter-toml"]
+lang-typescript = ["dep:tree-sitter-typescript"]
+lang-vue = ["dep:tree-sitter-vue"]
+lang-wgsl = ["dep:tree-sitter-wgsl"]
+lang-yaml = ["dep:tree-sitter-yaml"]
+lang-xml = ["dep:tree-sitter-xml"]
+lang-zig = ["dep:tree-sitter-zig"]
diff --git a/lapce-core/queries/c/highlights.scm b/lapce-core/queries/c/highlights.scm
new file mode 100644
index 0000000000..d01f6ed2f7
--- /dev/null
+++ b/lapce-core/queries/c/highlights.scm
@@ -0,0 +1,145 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/c/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+"sizeof" @keyword
+
+[
+  "enum"
+  "struct"
+  "typedef"
+  "union"
+] @keyword.storage.type
+
+[
+  "extern"
+  "register"
+  (type_qualifier)
+  (storage_class_specifier)
+] @keyword.storage.modifier
+
+[
+  "goto"
+  "break"
+  "continue"
+] @keyword.control
+
+[
+  "do"
+  "for"
+  "while"
+] @keyword.control.repeat
+
+[
+  "if"
+  "else"
+  "switch"
+  "case"
+  "default"
+] @keyword.control.conditional
+
+"return" @keyword.control.return
+
+[
+  "defined"
+  "#define"
+  "#elif"
+  "#else"
+  "#endif"
+  "#if"
+  "#ifdef"
+  "#ifndef"
+  "#include"
+  (preproc_directive)
+] @keyword.directive
+
+(pointer_declarator "*" @type.builtin)
+(abstract_pointer_declarator "*" @type.builtin)
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "++"
+  "--"
+  "%"
+  "=="
+  "!="
+  ">"
+  "<"
+  ">="
+  "<="
+  "&&"
+  "||"
+  "!"
+  "&"
+  "|"
+  "^"
+  "~"
+  "<<"
+  ">>"
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "<<="
+  ">>="
+  "&="
+  "^="
+  "|="
+  "?"
+] @operator
+
+(conditional_expression ":" @operator)
+
+"..." @punctuation
+
+["," "." ":" ";" "->" "::"] @punctuation.delimiter
+
+["(" ")" "[" "]" "{" "}"] @punctuation.bracket
+
+[(true) (false)] @constant.builtin.boolean
+
+(enumerator name: (identifier) @type.enum.variant)
+
+(string_literal) @string
+(system_lib_string) @string
+
+(null) @constant
+(number_literal) @constant.numeric
+(char_literal) @constant.character
+
+(call_expression
+  function: (identifier) @function)
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @function))
+(call_expression (argument_list (identifier) @variable))
+(function_declarator
+  declarator: [(identifier) (field_identifier)] @function)
+(parameter_declaration
+  declarator: (identifier) @variable.parameter)
+(parameter_declaration
+  (pointer_declarator
+    declarator: (identifier) @variable.parameter))
+(preproc_function_def
+  name: (identifier) @function.special)
+
+(attribute
+  name: (identifier) @attribute)
+
+(field_identifier) @variable.other.member
+(statement_identifier) @label
+(type_identifier) @type
+(primitive_type) @type.builtin
+(sized_type_specifier) @type.builtin
+
+((identifier) @constant
+  (#match? @constant "^[A-Z][A-Z\\d_]*$"))
+
+(identifier) @variable
+
+(comment) @comment
\ No newline at end of file
diff --git a/lapce-core/queries/clojure/highlights.scm b/lapce-core/queries/clojure/highlights.scm
new file mode 100644
index 0000000000..daac017277
--- /dev/null
+++ b/lapce-core/queries/clojure/highlights.scm
@@ -0,0 +1,88 @@
+; src: https://github.com/helix-editor/helix/blob/master/runtime/queries/clojure/highlights.scm
+; license: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+(dis_expr) @comment
+
+(kwd_lit) @string.special.symbol
+
+(str_lit) @string
+
+(num_lit) @constant.numeric
+
+[(bool_lit) (nil_lit)] @constant.builtin
+
+(comment) @comment
+
+;; metadata experiment
+(meta_lit
+ marker: "^" @punctuation)
+
+;; dynamic variables
+((sym_lit) @variable
+ (#match? @variable "^\\*.+\\*$"))
+
+;; parameter-related
+((sym_lit) @variable.parameter
+ (#match? @variable.parameter "^&.*$"))
+
+;; gensym
+((sym_lit) @variable
+ (#match? @variable "^.*#$"))
+
+;; def-like things
+(list_lit
+ .
+ (sym_lit) @function.macro
+ .
+ (sym_lit) @function
+ (#match? @function.macro "^(declare|def|definline|definterface|defmacro|defmethod|defmulti|defn|defn-|defonce|defprotocol|defstruct|deftype|ns)$"))
+
+;; other macros
+(list_lit
+ .
+ (sym_lit) @function.macro
+ (#match? @function.macro "^(\\.|\\.\\.|\\->|\\->>|amap|and|areduce|as\\->|assert|binding|bound\\-fn|case|catch|comment|cond|cond\\->|cond\\->>|condp|delay|do|doseq|dosync|dotimes|doto|extend-protocol|extend-type|finally|fn|fn\\*|for|future|gen-class|gen-interface|if|if\\-let|if\\-not|if\\-some|import|io!|lazy\\-cat|lazy\\-seq|let|letfn|locking|loop|memfn|monitor\\-enter|monitor\\-exit|or|proxy|proxy-super|pvalues|quote|recur|refer\\-clojure|reify|set!|some\\->|some\\->>|sync|throw|time|try|unquote|unquote\\-splicing|var|vswap!|when|when\\-first|when\\-let|when\\-not|when\\-some|while|with\\-bindings|with\\-in\\-str|with\\-loading\\-context|with\\-local\\-vars|with\\-open|with\\-out\\-str|with\\-precision|with\\-redefs)$"))
+
+(anon_fn_lit
+ .
+ (sym_lit) @function.macro
+ (#match? @function.macro "^(\\.|\\.\\.|\\->|\\->>|amap|and|areduce|as\\->|assert|binding|bound\\-fn|case|catch|comment|cond|cond\\->|cond\\->>|condp|delay|do|doseq|dosync|dotimes|doto|extend-protocol|extend-type|finally|fn|fn\\*|for|future|gen-class|gen-interface|if|if\\-let|if\\-not|if\\-some|import|io!|lazy\\-cat|lazy\\-seq|let|letfn|locking|loop|memfn|monitor\\-enter|monitor\\-exit|or|proxy|proxy-super|pvalues|quote|recur|refer\\-clojure|reify|set!|some\\->|some\\->>|sync|throw|time|try|unquote|unquote\\-splicing|var|vswap!|when|when\\-first|when\\-let|when\\-not|when\\-some|while|with\\-bindings|with\\-in\\-str|with\\-loading\\-context|with\\-local\\-vars|with\\-open|with\\-out\\-str|with\\-precision|with\\-redefs)$"))
+
+;; clojure.core=> (cp/pprint (sort (keep (fn [[s v]] (when-not (:macro (meta v)) s)) (ns-publics *ns*))))
+;; ...and then some manual filtering...
+(list_lit
+ .
+ (sym_lit) @function.builtin
+ (#match? @function.builtin "^(\\*|\\*'|\\+|\\+'|\\-|\\-'|\\->ArrayChunk|\\->Eduction|\\->Vec|\\->VecNode|\\->VecSeq|\\-cache\\-protocol\\-fn|\\-reset\\-methods|/|<|<=|=|==|>|>=|PrintWriter\\-on|StackTraceElement\\->vec|Throwable\\->map|accessor|aclone|add\\-classpath|add\\-tap|add\\-watch|agent|agent\\-error|agent\\-errors|aget|alength|alias|all\\-ns|alter|alter\\-meta!|alter\\-var\\-root|ancestors|any\\?|apply|array\\-map|aset|aset\\-boolean|aset\\-byte|aset\\-char|aset\\-double|aset\\-float|aset\\-int|aset\\-long|aset\\-short|assoc|assoc!|assoc\\-in|associative\\?|atom|await|await\\-for|await1|bases|bean|bigdec|bigint|biginteger|bit\\-and|bit\\-and\\-not|bit\\-clear|bit\\-flip|bit\\-not|bit\\-or|bit\\-set|bit\\-shift\\-left|bit\\-shift\\-right|bit\\-test|bit\\-xor|boolean|boolean\\-array|boolean\\?|booleans|bound\\-fn\\*|bound\\?|bounded\\-count|butlast|byte|byte\\-array|bytes|bytes\\?|cast|cat|char|char\\-array|char\\-escape\\-string|char\\-name\\-string|char\\?|chars|chunk|chunk\\-append|chunk\\-buffer|chunk\\-cons|chunk\\-first|chunk\\-next|chunk\\-rest|chunked\\-seq\\?|class|class\\?|clear\\-agent\\-errors|clojure\\-version|coll\\?|commute|comp|comparator|compare|compare\\-and\\-set!|compile|complement|completing|concat|conj|conj!|cons|constantly|construct\\-proxy|contains\\?|count|counted\\?|create\\-ns|create\\-struct|cycle|dec|dec'|decimal\\?|dedupe|default\\-data\\-readers|delay\\?|deliver|denominator|deref|derive|descendants|destructure|disj|disj!|dissoc|dissoc!|distinct|distinct\\?|doall|dorun|double|double\\-array|double\\?|doubles|drop|drop\\-last|drop\\-while|eduction|empty|empty\\?|ensure|ensure\\-reduced|enumeration\\-seq|error\\-handler|error\\-mode|eval|even\\?|every\\-pred|every\\?|ex\\-cause|ex\\-data|ex\\-info|ex\\-message|extend|extenders|extends\\?|false\\?|ffirst|file\\-seq|filter|filterv|find|find\\-keyword|find\\-ns|find\\-protocol\\-impl|find\\-protocol\\-method|find\\-var|first|flatten|float|float\\-array|float\\?|floats|flush|fn\\?|fnext|fnil|force|format|frequencies|future\\-call|future\\-cancel|future\\-cancelled\\?|future\\-done\\?|future\\?|gensym|get|get\\-in|get\\-method|get\\-proxy\\-class|get\\-thread\\-bindings|get\\-validator|group\\-by|halt\\-when|hash|hash\\-combine|hash\\-map|hash\\-ordered\\-coll|hash\\-set|hash\\-unordered\\-coll|ident\\?|identical\\?|identity|ifn\\?|in\\-ns|inc|inc'|indexed\\?|init\\-proxy|inst\\-ms|inst\\-ms\\*|inst\\?|instance\\?|int|int\\-array|int\\?|integer\\?|interleave|intern|interpose|into|into\\-array|ints|isa\\?|iterate|iterator\\-seq|juxt|keep|keep\\-indexed|key|keys|keyword|keyword\\?|last|line\\-seq|list|list\\*|list\\?|load|load\\-file|load\\-reader|load\\-string|loaded\\-libs|long|long\\-array|longs|macroexpand|macroexpand\\-1|make\\-array|make\\-hierarchy|map|map\\-entry\\?|map\\-indexed|map\\?|mapcat|mapv|max|max\\-key|memoize|merge|merge\\-with|meta|method\\-sig|methods|min|min\\-key|mix\\-collection\\-hash|mod|munge|name|namespace|namespace\\-munge|nat\\-int\\?|neg\\-int\\?|neg\\?|newline|next|nfirst|nil\\?|nnext|not|not\\-any\\?|not\\-empty|not\\-every\\?|not=|ns\\-aliases|ns\\-imports|ns\\-interns|ns\\-map|ns\\-name|ns\\-publics|ns\\-refers|ns\\-resolve|ns\\-unalias|ns\\-unmap|nth|nthnext|nthrest|num|number\\?|numerator|object\\-array|odd\\?|parents|partial|partition|partition\\-all|partition\\-by|pcalls|peek|persistent!|pmap|pop|pop!|pop\\-thread\\-bindings|pos\\-int\\?|pos\\?|pr|pr\\-str|prefer\\-method|prefers|primitives\\-classnames|print|print\\-ctor|print\\-dup|print\\-method|print\\-simple|print\\-str|printf|println|println\\-str|prn|prn\\-str|promise|proxy\\-call\\-with\\-super|proxy\\-mappings|proxy\\-name|push\\-thread\\-bindings|qualified\\-ident\\?|qualified\\-keyword\\?|qualified\\-symbol\\?|quot|rand|rand\\-int|rand\\-nth|random\\-sample|range|ratio\\?|rational\\?|rationalize|re\\-find|re\\-groups|re\\-matcher|re\\-matches|re\\-pattern|re\\-seq|read|read+string|read\\-line|read\\-string|reader\\-conditional|reader\\-conditional\\?|realized\\?|record\\?|reduce|reduce\\-kv|reduced|reduced\\?|reductions|ref|ref\\-history\\-count|ref\\-max\\-history|ref\\-min\\-history|ref\\-set|refer|release\\-pending\\-sends|rem|remove|remove\\-all\\-methods|remove\\-method|remove\\-ns|remove\\-tap|remove\\-watch|repeat|repeatedly|replace|replicate|require|requiring\\-resolve|reset!|reset\\-meta!|reset\\-vals!|resolve|rest|restart\\-agent|resultset\\-seq|reverse|reversible\\?|rseq|rsubseq|run!|satisfies\\?|second|select\\-keys|send|send\\-off|send\\-via|seq|seq\\?|seqable\\?|seque|sequence|sequential\\?|set|set\\-agent\\-send\\-executor!|set\\-agent\\-send\\-off\\-executor!|set\\-error\\-handler!|set\\-error\\-mode!|set\\-validator!|set\\?|short|short\\-array|shorts|shuffle|shutdown\\-agents|simple\\-ident\\?|simple\\-keyword\\?|simple\\-symbol\\?|slurp|some|some\\-fn|some\\?|sort|sort\\-by|sorted\\-map|sorted\\-map\\-by|sorted\\-set|sorted\\-set\\-by|sorted\\?|special\\-symbol\\?|spit|split\\-at|split\\-with|str|string\\?|struct|struct\\-map|subs|subseq|subvec|supers|swap!|swap\\-vals!|symbol|symbol\\?|tagged\\-literal|tagged\\-literal\\?|take|take\\-last|take\\-nth|take\\-while|tap>|test|the\\-ns|thread\\-bound\\?|to\\-array|to\\-array\\-2d|trampoline|transduce|transient|tree\\-seq|true\\?|type|unchecked\\-add|unchecked\\-add\\-int|unchecked\\-byte|unchecked\\-char|unchecked\\-dec|unchecked\\-dec\\-int|unchecked\\-divide\\-int|unchecked\\-double|unchecked\\-float|unchecked\\-inc|unchecked\\-inc\\-int|unchecked\\-int|unchecked\\-long|unchecked\\-multiply|unchecked\\-multiply\\-int|unchecked\\-negate|unchecked\\-negate\\-int|unchecked\\-remainder\\-int|unchecked\\-short|unchecked\\-subtract|unchecked\\-subtract\\-int|underive|unquote|unquote\\-splicing|unreduced|unsigned\\-bit\\-shift\\-right|update|update\\-in|update\\-proxy|uri\\?|use|uuid\\?|val|vals|var\\-get|var\\-set|var\\?|vary\\-meta|vec|vector|vector\\-of|vector\\?|volatile!|volatile\\?|vreset!|with\\-bindings\\*|with\\-meta|with\\-redefs\\-fn|xml\\-seq|zero\\?|zipmap)$"))
+
+(anon_fn_lit
+ .
+ (sym_lit) @function.builtin
+ (#match? @function.builtin "^(\\*|\\*'|\\+|\\+'|\\-|\\-'|\\->ArrayChunk|\\->Eduction|\\->Vec|\\->VecNode|\\->VecSeq|\\-cache\\-protocol\\-fn|\\-reset\\-methods|/|<|<=|=|==|>|>=|PrintWriter\\-on|StackTraceElement\\->vec|Throwable\\->map|accessor|aclone|add\\-classpath|add\\-tap|add\\-watch|agent|agent\\-error|agent\\-errors|aget|alength|alias|all\\-ns|alter|alter\\-meta!|alter\\-var\\-root|ancestors|any\\?|apply|array\\-map|aset|aset\\-boolean|aset\\-byte|aset\\-char|aset\\-double|aset\\-float|aset\\-int|aset\\-long|aset\\-short|assoc|assoc!|assoc\\-in|associative\\?|atom|await|await\\-for|await1|bases|bean|bigdec|bigint|biginteger|bit\\-and|bit\\-and\\-not|bit\\-clear|bit\\-flip|bit\\-not|bit\\-or|bit\\-set|bit\\-shift\\-left|bit\\-shift\\-right|bit\\-test|bit\\-xor|boolean|boolean\\-array|boolean\\?|booleans|bound\\-fn\\*|bound\\?|bounded\\-count|butlast|byte|byte\\-array|bytes|bytes\\?|cast|cat|char|char\\-array|char\\-escape\\-string|char\\-name\\-string|char\\?|chars|chunk|chunk\\-append|chunk\\-buffer|chunk\\-cons|chunk\\-first|chunk\\-next|chunk\\-rest|chunked\\-seq\\?|class|class\\?|clear\\-agent\\-errors|clojure\\-version|coll\\?|commute|comp|comparator|compare|compare\\-and\\-set!|compile|complement|completing|concat|conj|conj!|cons|constantly|construct\\-proxy|contains\\?|count|counted\\?|create\\-ns|create\\-struct|cycle|dec|dec'|decimal\\?|dedupe|default\\-data\\-readers|delay\\?|deliver|denominator|deref|derive|descendants|destructure|disj|disj!|dissoc|dissoc!|distinct|distinct\\?|doall|dorun|double|double\\-array|double\\?|doubles|drop|drop\\-last|drop\\-while|eduction|empty|empty\\?|ensure|ensure\\-reduced|enumeration\\-seq|error\\-handler|error\\-mode|eval|even\\?|every\\-pred|every\\?|ex\\-cause|ex\\-data|ex\\-info|ex\\-message|extend|extenders|extends\\?|false\\?|ffirst|file\\-seq|filter|filterv|find|find\\-keyword|find\\-ns|find\\-protocol\\-impl|find\\-protocol\\-method|find\\-var|first|flatten|float|float\\-array|float\\?|floats|flush|fn\\?|fnext|fnil|force|format|frequencies|future\\-call|future\\-cancel|future\\-cancelled\\?|future\\-done\\?|future\\?|gensym|get|get\\-in|get\\-method|get\\-proxy\\-class|get\\-thread\\-bindings|get\\-validator|group\\-by|halt\\-when|hash|hash\\-combine|hash\\-map|hash\\-ordered\\-coll|hash\\-set|hash\\-unordered\\-coll|ident\\?|identical\\?|identity|ifn\\?|in\\-ns|inc|inc'|indexed\\?|init\\-proxy|inst\\-ms|inst\\-ms\\*|inst\\?|instance\\?|int|int\\-array|int\\?|integer\\?|interleave|intern|interpose|into|into\\-array|ints|isa\\?|iterate|iterator\\-seq|juxt|keep|keep\\-indexed|key|keys|keyword|keyword\\?|last|line\\-seq|list|list\\*|list\\?|load|load\\-file|load\\-reader|load\\-string|loaded\\-libs|long|long\\-array|longs|macroexpand|macroexpand\\-1|make\\-array|make\\-hierarchy|map|map\\-entry\\?|map\\-indexed|map\\?|mapcat|mapv|max|max\\-key|memoize|merge|merge\\-with|meta|method\\-sig|methods|min|min\\-key|mix\\-collection\\-hash|mod|munge|name|namespace|namespace\\-munge|nat\\-int\\?|neg\\-int\\?|neg\\?|newline|next|nfirst|nil\\?|nnext|not|not\\-any\\?|not\\-empty|not\\-every\\?|not=|ns\\-aliases|ns\\-imports|ns\\-interns|ns\\-map|ns\\-name|ns\\-publics|ns\\-refers|ns\\-resolve|ns\\-unalias|ns\\-unmap|nth|nthnext|nthrest|num|number\\?|numerator|object\\-array|odd\\?|parents|partial|partition|partition\\-all|partition\\-by|pcalls|peek|persistent!|pmap|pop|pop!|pop\\-thread\\-bindings|pos\\-int\\?|pos\\?|pr|pr\\-str|prefer\\-method|prefers|primitives\\-classnames|print|print\\-ctor|print\\-dup|print\\-method|print\\-simple|print\\-str|printf|println|println\\-str|prn|prn\\-str|promise|proxy\\-call\\-with\\-super|proxy\\-mappings|proxy\\-name|push\\-thread\\-bindings|qualified\\-ident\\?|qualified\\-keyword\\?|qualified\\-symbol\\?|quot|rand|rand\\-int|rand\\-nth|random\\-sample|range|ratio\\?|rational\\?|rationalize|re\\-find|re\\-groups|re\\-matcher|re\\-matches|re\\-pattern|re\\-seq|read|read+string|read\\-line|read\\-string|reader\\-conditional|reader\\-conditional\\?|realized\\?|record\\?|reduce|reduce\\-kv|reduced|reduced\\?|reductions|ref|ref\\-history\\-count|ref\\-max\\-history|ref\\-min\\-history|ref\\-set|refer|release\\-pending\\-sends|rem|remove|remove\\-all\\-methods|remove\\-method|remove\\-ns|remove\\-tap|remove\\-watch|repeat|repeatedly|replace|replicate|require|requiring\\-resolve|reset!|reset\\-meta!|reset\\-vals!|resolve|rest|restart\\-agent|resultset\\-seq|reverse|reversible\\?|rseq|rsubseq|run!|satisfies\\?|second|select\\-keys|send|send\\-off|send\\-via|seq|seq\\?|seqable\\?|seque|sequence|sequential\\?|set|set\\-agent\\-send\\-executor!|set\\-agent\\-send\\-off\\-executor!|set\\-error\\-handler!|set\\-error\\-mode!|set\\-validator!|set\\?|short|short\\-array|shorts|shuffle|shutdown\\-agents|simple\\-ident\\?|simple\\-keyword\\?|simple\\-symbol\\?|slurp|some|some\\-fn|some\\?|sort|sort\\-by|sorted\\-map|sorted\\-map\\-by|sorted\\-set|sorted\\-set\\-by|sorted\\?|special\\-symbol\\?|spit|split\\-at|split\\-with|str|string\\?|struct|struct\\-map|subs|subseq|subvec|supers|swap!|swap\\-vals!|symbol|symbol\\?|tagged\\-literal|tagged\\-literal\\?|take|take\\-last|take\\-nth|take\\-while|tap>|test|the\\-ns|thread\\-bound\\?|to\\-array|to\\-array\\-2d|trampoline|transduce|transient|tree\\-seq|true\\?|type|unchecked\\-add|unchecked\\-add\\-int|unchecked\\-byte|unchecked\\-char|unchecked\\-dec|unchecked\\-dec\\-int|unchecked\\-divide\\-int|unchecked\\-double|unchecked\\-float|unchecked\\-inc|unchecked\\-inc\\-int|unchecked\\-int|unchecked\\-long|unchecked\\-multiply|unchecked\\-multiply\\-int|unchecked\\-negate|unchecked\\-negate\\-int|unchecked\\-remainder\\-int|unchecked\\-short|unchecked\\-subtract|unchecked\\-subtract\\-int|underive|unquote|unquote\\-splicing|unreduced|unsigned\\-bit\\-shift\\-right|update|update\\-in|update\\-proxy|uri\\?|use|uuid\\?|val|vals|var\\-get|var\\-set|var\\?|vary\\-meta|vec|vector|vector\\-of|vector\\?|volatile!|volatile\\?|vreset!|with\\-bindings\\*|with\\-meta|with\\-redefs\\-fn|xml\\-seq|zero\\?|zipmap)$"))
+
+;; anonymous function positional arguments
+((sym_lit) @operator
+ (#match? @operator "^%"))
+
+;; other calls
+(list_lit
+ .
+ (sym_lit) @function)
+
+;; interop-ish
+(list_lit
+ .
+ (sym_lit) @function.method
+ (#match? @function.method "^\\."))
+
+;; other symbols
+(sym_lit) @variable
+
+;; quote
+(quoting_lit) @constant.character.escape
+
+;; syntax quote
+["{" "}" "(" ")" "[" "]"] @punctuation.bracket
+["~" "~@" "#'" "@"] @operator
+(syn_quoting_lit) @constant.character.escape
diff --git a/lapce-core/queries/clojure/injections.scm b/lapce-core/queries/clojure/injections.scm
new file mode 100644
index 0000000000..df707522e1
--- /dev/null
+++ b/lapce-core/queries/clojure/injections.scm
@@ -0,0 +1,7 @@
+; src: https://github.com/helix-editor/helix/blob/master/runtime/queries/clojure/injections.scm
+; license: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+((regex_lit) @injection.content
+ (#set! injection.language "regex"))
+ 
\ No newline at end of file
diff --git a/lapce-core/queries/cmake/highlights.scm b/lapce-core/queries/cmake/highlights.scm
new file mode 100644
index 0000000000..f03dfd1324
--- /dev/null
+++ b/lapce-core/queries/cmake/highlights.scm
@@ -0,0 +1,100 @@
+; src: https://github.com/helix-editor/helix/blob/master/runtime/queries/cmake/highlights.scm
+; license: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+[
+  (quoted_argument)
+  (bracket_argument)
+ ] @string
+
+(variable) @variable
+
+[
+  (bracket_comment)
+  (line_comment)
+ ] @comment
+
+(normal_command (identifier) @function)
+
+["ENV" "CACHE"] @string.special.symbol
+["$" "{" "}" "<" ">"] @punctuation
+["(" ")"] @punctuation.bracket
+
+[
+  (function)
+  (endfunction)
+  (macro)
+  (endmacro)
+ ] @keyword.function
+
+[
+  (if)
+  (elseif)
+  (else)
+  (endif)
+ ] @keyword.control.conditional
+
+[
+  (foreach)
+  (endforeach)
+  (while)
+  (endwhile)
+ ] @keyword.control.repeat
+
+(function_command
+   (function)
+   . (argument) @function
+   (argument)* @variable.parameter
+ )
+
+(macro_command
+   (macro)
+   . (argument) @function.macro
+   (argument)* @variable.parameter
+ )
+
+(normal_command
+  (identifier) @function.builtin
+  . (argument) @variable
+  (#match? @function.builtin "^(?i)(set)$"))
+
+(normal_command
+  (identifier) @function.builtin
+  . (argument)
+  (argument) @constant
+  (#match? @constant "^(?:PARENT_SCOPE|CACHE)$")
+  (#match? @function.builtin "^(?i)(unset)$"))
+
+(normal_command
+  (identifier) @function.builtin
+  . (argument)
+  . (argument)
+  (argument) @constant
+  (#match? @constant "^(?:PARENT_SCOPE|CACHE|FORCE)$")
+  (#match? @function.builtin "^(?i)(set)$")
+ )
+
+((argument) @constant.builtin.boolean
+   (#match? @constant.builtin.boolean "^(?i)(?:1|on|yes|true|y|0|off|no|false|n|ignore|notfound|.*-notfound)$")
+ )
+
+(if_command
+   (if)
+   (argument) @operator
+   (#match? @operator "^(?:NOT|AND|OR|COMMAND|POLICY|TARGET|TEST|DEFINED|IN_LIST|EXISTS|IS_NEWER_THAN|IS_DIRECTORY|IS_SYMLINK|IS_ABSOLUTE|MATCHES|LESS|GREATER|EQUAL|LESS_EQUAL|GREATER_EQUAL|STRLESS|STRGREATER|STREQUAL|STRLESS_EQUAL|STRGREATER_EQUAL|VERSION_LESS|VERSION_GREATER|VERSION_EQUAL|VERSION_LESS_EQUAL|VERSION_GREATER_EQUAL)$")
+)
+
+(normal_command
+   (identifier) @function.builtin
+   . (argument)
+   (argument) @constant
+   (#match? @constant "^(?:ALL|COMMAND|DEPENDS|BYPRODUCTS|WORKING_DIRECTORY|COMMENT|JOB_POOL|VERBATIM|USES_TERMINAL|COMMAND_EXPAND_LISTS|SOURCES)$")
+   (#match? @function.builtin "^(?i)(add_custom_target)$")
+ )
+
+(normal_command
+   (identifier) @function.builtin
+   (argument) @constant
+   (#match? @constant "^(?:OUTPUT|COMMAND|MAIN_DEPENDENCY|DEPENDS|BYPRODUCTS|IMPLICIT_DEPENDS|WORKING_DIRECTORY|COMMENT|DEPFILE|JOB_POOL|VERBATIM|APPEND|USES_TERMINAL|COMMAND_EXPAND_LISTS)$")
+   (#match? @function.builtin "^(?i)(add_custom_command)$")
+ )
diff --git a/lapce-core/queries/cmake/injections.scm b/lapce-core/queries/cmake/injections.scm
new file mode 100644
index 0000000000..b4a9b39574
--- /dev/null
+++ b/lapce-core/queries/cmake/injections.scm
@@ -0,0 +1,8 @@
+; src: https://github.com/helix-editor/helix/blob/master/runtime/queries/cmake/injections.scm
+; license: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+((line_comment) @injection.content
+ (#set! injection.language "comment"))
+((bracket_comment) @injection.content
+ (#set! injection.language "comment"))
\ No newline at end of file
diff --git a/lapce-core/queries/cpp/highlights.scm b/lapce-core/queries/cpp/highlights.scm
new file mode 100644
index 0000000000..48e97b3d58
--- /dev/null
+++ b/lapce-core/queries/cpp/highlights.scm
@@ -0,0 +1,161 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/cpp/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+(storage_class_specifier) @keyword.storage
+
+"goto" @keyword
+"register" @keyword
+"break" @keyword
+"case" @keyword
+"continue" @keyword
+"default" @keyword
+"do" @keyword
+"else" @keyword
+"enum" @keyword
+"extern" @keyword
+"for" @keyword
+"if" @keyword
+"inline" @keyword
+"return" @keyword
+"sizeof" @keyword
+"struct" @keyword
+"switch" @keyword
+"typedef" @keyword
+"union" @keyword
+"volatile" @keyword
+"while" @keyword
+"const" @keyword
+
+[
+ "#define"
+ "#elif"
+ "#else"
+ "#endif"
+ "#if"
+ "#ifdef"
+ "#ifndef"
+ "#include"
+ (preproc_directive)
+] @keyword.directive
+
+"--" @operator
+"-" @operator
+"-=" @operator
+"->" @operator
+"=" @operator
+"!=" @operator
+"*" @operator
+"&" @operator
+"&&" @operator
+"+" @operator
+"++" @operator
+"+=" @operator
+"<" @operator
+"==" @operator
+">" @operator
+"||" @operator
+">=" @operator
+"<=" @operator
+
+"." @punctuation.delimiter
+";" @punctuation.delimiter
+
+[(true) (false)] @constant.builtin.boolean
+
+(enumerator) @type.enum.variant
+
+(string_literal) @string
+(system_lib_string) @string
+
+(null) @constant
+(number_literal) @constant.numeric.integer
+(char_literal) @constant.character
+
+(call_expression
+  function: (identifier) @function)
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @function))
+(function_declarator
+  declarator: (identifier) @function)
+(preproc_function_def
+  name: (identifier) @function.special)
+
+(field_identifier) @variable.other.member
+(statement_identifier) @label
+(type_identifier) @type
+(primitive_type) @type
+(sized_type_specifier) @type
+
+((identifier) @constant
+ (#match? @constant "^[A-Z][A-Z\\d_]*$"))
+
+(identifier) @variable
+
+(comment) @comment
+
+
+; Functions
+
+(call_expression
+  function: (qualified_identifier
+    name: (identifier) @function))
+
+(template_function
+  name: (identifier) @function)
+
+(template_method
+  name: (field_identifier) @function)
+
+(template_function
+  name: (identifier) @function)
+
+(function_declarator
+  declarator: (qualified_identifier
+    name: (identifier) @function))
+
+(function_declarator
+  declarator: (qualified_identifier
+    name: (identifier) @function))
+
+(function_declarator
+  declarator: (field_identifier) @function)
+
+; Types
+
+((namespace_identifier) @type
+ (#match? @type "^[A-Z]"))
+
+(auto) @type
+
+; Constants
+
+(this) @variable.builtin
+(nullptr) @constant
+
+; Keywords
+
+"catch" @keyword
+"class" @keyword
+"constexpr" @keyword
+"delete" @keyword
+"explicit" @keyword
+"final" @keyword
+"friend" @keyword
+"mutable" @keyword
+"namespace" @keyword
+"noexcept" @keyword
+"new" @keyword
+"override" @keyword
+"private" @keyword
+"protected" @keyword
+"public" @keyword
+"template" @keyword
+"throw" @keyword
+"try" @keyword
+"typename" @keyword
+"using" @keyword
+"virtual" @keyword
+
+; Strings
diff --git a/lapce-core/queries/css/highlights.scm b/lapce-core/queries/css/highlights.scm
new file mode 100644
index 0000000000..5a2b68c922
--- /dev/null
+++ b/lapce-core/queries/css/highlights.scm
@@ -0,0 +1,68 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/css/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+(comment) @comment
+
+(tag_name) @tag
+(nesting_selector) @tag
+(universal_selector) @tag
+
+"~" @operator
+">" @operator
+"+" @operator
+"-" @operator
+"*" @operator
+"/" @operator
+"=" @operator
+"^=" @operator
+"|=" @operator
+"~=" @operator
+"$=" @operator
+"*=" @operator
+
+"and" @operator
+"or" @operator
+"not" @operator
+"only" @operator
+
+(attribute_selector (plain_value) @string)
+(pseudo_element_selector (tag_name) @attribute)
+(pseudo_class_selector (class_name) @attribute)
+
+(class_name) @variable.other.member
+(id_name) @variable.other.member
+(namespace_name) @variable.other.member
+(property_name) @variable.other.member
+(feature_name) @variable.other.member
+
+(attribute_name) @attribute
+
+(function_name) @function
+
+((property_name) @variable
+ (#match? @variable "^--"))
+((plain_value) @variable
+ (#match? @variable "^--"))
+
+"@media" @keyword
+"@import" @keyword
+"@charset" @keyword
+"@namespace" @keyword
+"@supports" @keyword
+"@keyframes" @keyword
+(at_keyword) @keyword
+(to) @keyword
+(from) @keyword
+(important) @keyword
+
+(string_value) @string
+(color_value) @string.special
+
+(integer_value) @constant.numeric.integer
+(float_value) @constant.numeric.float
+(unit) @type
+
+"#" @punctuation.delimiter
+"," @punctuation.delimiter
+":" @punctuation.delimiter
\ No newline at end of file
diff --git a/lapce-core/queries/elm/highlights.scm b/lapce-core/queries/elm/highlights.scm
new file mode 100644
index 0000000000..bdc94c7523
--- /dev/null
+++ b/lapce-core/queries/elm/highlights.scm
@@ -0,0 +1,88 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/elm/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+; Keywords
+[
+    "if"
+    "then"
+    "else"
+    "let"
+    "in"
+ ] @keyword.control
+(case) @keyword.control
+(of) @keyword.control
+
+(colon) @keyword.operator
+(backslash) @keyword
+(as) @keyword
+(port) @keyword
+(exposing) @keyword
+(alias) @keyword
+(infix) @keyword
+
+(arrow) @keyword.operator
+(dot) @keyword.operator
+
+(port) @keyword
+
+(type_annotation(lower_case_identifier) @function)
+(port_annotation(lower_case_identifier) @function)
+(file (value_declaration (function_declaration_left(lower_case_identifier) @function)))
+
+(field name: (lower_case_identifier) @attribute)
+(field_access_expr(lower_case_identifier) @attribute)
+
+(operator_identifier) @keyword.operator
+(eq) @keyword.operator.assignment
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+"|" @keyword
+"," @punctuation.delimiter
+
+[
+  "|>"
+] @keyword
+
+
+(import) @keyword.control.import
+(module) @keyword.other
+
+(number_constant_expr) @constant.numeric
+
+(type) @type
+
+(type_declaration(upper_case_identifier) @type)
+(type_ref) @type
+(type_alias_declaration name: (upper_case_identifier) @type)
+
+(union_pattern constructor: (upper_case_qid (upper_case_identifier) @label (dot) (upper_case_identifier) @variable.other.member)) 
+(union_pattern constructor: (upper_case_qid (upper_case_identifier) @variable.other.member)) 
+
+(union_variant(upper_case_identifier) @variable.other.member)
+(value_expr name: (value_qid (upper_case_identifier) @label))
+(value_expr (upper_case_qid (upper_case_identifier) @label (dot) (upper_case_identifier) @variable.other.member))
+(value_expr(upper_case_qid(upper_case_identifier)) @variable.other.member)
+
+; comments
+(line_comment) @comment
+(block_comment) @comment
+
+; strings
+(string_escape) @constant.character.escape
+
+(open_quote) @string
+(close_quote) @string
+(regular_string_part) @string
+
+(open_char) @constant.character
+(close_char) @constant.character
+
diff --git a/lapce-core/queries/erlang/highlights.scm b/lapce-core/queries/erlang/highlights.scm
new file mode 100644
index 0000000000..a2fa5884f8
--- /dev/null
+++ b/lapce-core/queries/erlang/highlights.scm
@@ -0,0 +1,108 @@
+; source: https://github.com/nvim-treesitter/nvim-treesitter/blob/master/queries/erlang/highlights.scm
+; licence: https://github.com/nvim-treesitter/nvim-treesitter/blob/master/LICENSE
+; spdx: Apache-2.0
+
+;; keywoord
+[
+  "fun"
+  "div"
+] @keyword
+;; bracket
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+	"#"
+] @punctuation.bracket
+;; conditional
+[
+  "receive"
+  "if"
+  "case"
+  "of"
+  "when"
+  "after"
+  "end"
+] @conditional
+
+[
+  "catch"
+	"try"
+	"throw"
+] @exception
+;;; module define
+[
+  "module"
+  "export"
+] @include
+;;; operator
+[
+  ":"
+  ":="
+  "?"
+  "!"
+  "-"
+  "+"
+  "="
+  "->"
+  "=>"
+	"|"
+	;;;TODO
+	"$"
+ ] @operator
+
+(comment) @comment
+(string) @string
+(variable) @variable
+
+(module_name
+  (atom) @namespace
+)
+;;; expr_function_call
+(expr_function_call
+  name: (computed_function_name) @function.call
+)
+
+(expr_function_call
+  arguments: (atom) @variable
+)
+
+;;; map
+(map
+ (map_entry [
+   (atom)
+   (variable)
+ ] @variable)
+)
+
+
+(tuple (atom) @variable)
+(pat_tuple ( pattern (atom) @variable))
+
+(computed_function_name) @function
+;;; case
+(case_clause
+  pattern: (pattern
+    (atom) @variable
+  )
+)
+(case_clause
+  body: (atom) @variable
+)
+
+;;; function
+(qualified_function_name
+  module_name: (atom) @attribute
+  function_name: (atom) @function
+)
+;; function
+(function_clause
+  name: (atom) @function)
+;;;lambda
+(lambda_clause
+  arguments:
+    (pattern) @variable
+)
diff --git a/lapce-core/queries/javascript/highlights.scm b/lapce-core/queries/javascript/highlights.scm
new file mode 100644
index 0000000000..02bbcb56ba
--- /dev/null
+++ b/lapce-core/queries/javascript/highlights.scm
@@ -0,0 +1,261 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/javascript/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+; Function and method parameters
+;-------------------------------
+
+; (p) => ...
+(formal_parameters 
+  (identifier) @variable.parameter)
+
+; (...p) => ...
+(formal_parameters
+  (rest_pattern
+    (identifier) @variable.parameter))
+
+; ({ p }) => ...
+(formal_parameters
+  (object_pattern
+    (shorthand_property_identifier_pattern) @variable.parameter))
+
+; ({ a: p }) => ...
+(formal_parameters
+  (object_pattern
+    (pair_pattern
+      value: (identifier) @variable.parameter)))
+
+; ([ p ]) => ...
+(formal_parameters
+  (array_pattern
+    (identifier) @variable.parameter))
+
+; (p = 1) => ...
+(formal_parameters
+  (assignment_pattern
+    left: (identifier) @variable.parameter))
+
+; p => ...
+(arrow_function
+  parameter: (identifier) @variable.parameter)
+
+; Special identifiers
+;--------------------
+
+([
+    (identifier)
+    (shorthand_property_identifier)
+    (shorthand_property_identifier_pattern)
+ ] @constant
+ (#match? @constant "^[A-Z_][A-Z\\d_]+$"))
+
+
+((identifier) @constructor
+ (#match? @constructor "^[A-Z]"))
+
+((identifier) @variable.builtin
+ (#match? @variable.builtin "^(arguments|module|console|window|document)$")
+ (#is-not? local))
+
+((identifier) @function.builtin
+ (#eq? @function.builtin "require")
+ (#is-not? local))
+
+; Function and method definitions
+;--------------------------------
+
+(function
+  name: (identifier) @function)
+(function_declaration
+  name: (identifier) @function)
+(method_definition
+  name: (property_identifier) @function.method)
+
+(pair
+  key: (property_identifier) @function.method
+  value: [(function) (arrow_function)])
+
+(assignment_expression
+  left: (member_expression
+    property: (property_identifier) @function.method)
+  right: [(function) (arrow_function)])
+
+(variable_declarator
+  name: (identifier) @function
+  value: [(function) (arrow_function)])
+
+(assignment_expression
+  left: (identifier) @function
+  right: [(function) (arrow_function)])
+  
+
+; Function and method calls
+;--------------------------
+
+(call_expression
+  function: (identifier) @function)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @function.method))
+
+; Variables
+;----------
+
+(identifier) @variable
+
+; Properties
+;-----------
+
+(property_identifier) @variable.other.member
+(shorthand_property_identifier) @variable.other.member
+(shorthand_property_identifier_pattern) @variable.other.member
+
+; Literals
+;---------
+
+(this) @variable.builtin
+(super) @variable.builtin
+
+[
+  (true)
+  (false)
+  (null)
+  (undefined)
+] @constant.builtin
+
+(comment) @comment
+
+[
+  (string)
+  (template_string)
+] @string
+
+(regex) @string.regexp
+(number) @constant.numeric.integer
+
+; Tokens
+;-------
+
+(template_substitution
+  "${" @punctuation.special
+  "}" @punctuation.special) @embedded
+
+[
+  ";"
+  "?."
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "-"
+  "--"
+  "-="
+  "+"
+  "++"
+  "+="
+  "*"
+  "*="
+  "**"
+  "**="
+  "/"
+  "/="
+  "%"
+  "%="
+  "<"
+  "<="
+  "<<"
+  "<<="
+  "="
+  "=="
+  "==="
+  "!"
+  "!="
+  "!=="
+  "=>"
+  ">"
+  ">="
+  ">>"
+  ">>="
+  ">>>"
+  ">>>="
+  "~"
+  "^"
+  "&"
+  "|"
+  "^="
+  "&="
+  "|="
+  "&&"
+  "||"
+  "??"
+  "&&="
+  "||="
+  "??="
+  "..."
+] @operator
+
+(ternary_expression ["?" ":"] @operator)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+]  @punctuation.bracket
+
+[
+  "as"
+  "async"
+  "debugger"
+  "delete"
+  "extends"
+  "function"
+  "get"
+  "in"
+  "instanceof"
+  "new"
+  "of"
+  "set"
+  "static"
+  "target"
+  "try"
+  "typeof"
+  "void"
+  "with"
+] @keyword
+
+[
+  "class"
+  "let"
+  "const"
+  "var"
+] @keyword.storage.type
+
+[
+  "switch"
+  "case"
+  "if"
+  "else"
+  "yield"
+  "throw"
+  "finally"
+  "return"
+  "catch"
+  "continue"
+  "while"
+  "break"
+  "for"
+  "do"
+  "await"
+] @keyword.control
+
+[
+  "import"
+  "default"
+  "from"
+  "export"
+] @keyword.control.import 
\ No newline at end of file
diff --git a/lapce-core/queries/jsx/highlights.scm b/lapce-core/queries/jsx/highlights.scm
new file mode 100644
index 0000000000..96e0da0b74
--- /dev/null
+++ b/lapce-core/queries/jsx/highlights.scm
@@ -0,0 +1,250 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/jsx/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+; Special identifiers
+;--------------------
+
+([
+    (identifier)
+    (shorthand_property_identifier)
+    (shorthand_property_identifier_pattern)
+ ] @constant
+ (#match? @constant "^[A-Z_][A-Z\\d_]+$"))
+
+
+((identifier) @constructor
+ (#match? @constructor "^[A-Z]"))
+
+((identifier) @variable.builtin
+ (#match? @variable.builtin "^(arguments|module|console|window|document)$")
+ (#is-not? local))
+
+((identifier) @function.builtin
+ (#eq? @function.builtin "require")
+ (#is-not? local))
+
+; Function and method definitions
+;--------------------------------
+
+(function
+  name: (identifier) @function)
+(function_declaration
+  name: (identifier) @function)
+(method_definition
+  name: (property_identifier) @function.method)
+
+(pair
+  key: (property_identifier) @function.method
+  value: [(function) (arrow_function)])
+
+(assignment_expression
+  left: (member_expression
+    property: (property_identifier) @function.method)
+  right: [(function) (arrow_function)])
+
+(variable_declarator
+  name: (identifier) @function
+  value: [(function) (arrow_function)])
+
+(assignment_expression
+  left: (identifier) @function
+  right: [(function) (arrow_function)])
+  
+
+; Function and method calls
+;--------------------------
+
+(call_expression
+  function: (identifier) @function)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @function.method))
+
+; Variables
+;----------
+
+(identifier) @variable
+
+; Properties
+;-----------
+
+(property_identifier) @variable.other.member
+(shorthand_property_identifier) @variable.other.member
+(shorthand_property_identifier_pattern) @variable.other.member
+
+; Literals
+;---------
+
+(this) @variable.builtin
+(super) @variable.builtin
+
+[
+  (true)
+  (false)
+  (null)
+  (undefined)
+] @constant.builtin
+
+(comment) @comment
+
+[
+  (string)
+  (template_string)
+] @string
+
+(regex) @string.regexp
+(number) @constant.numeric.integer
+
+; Tokens
+;-------
+
+(template_substitution
+  "${" @punctuation.special
+  "}" @punctuation.special) @embedded
+
+[
+  ";"
+  "?."
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "-"
+  "--"
+  "-="
+  "+"
+  "++"
+  "+="
+  "*"
+  "*="
+  "**"
+  "**="
+  "/"
+  "/="
+  "%"
+  "%="
+  "<"
+  "<="
+  "<<"
+  "<<="
+  "="
+  "=="
+  "==="
+  "!"
+  "!="
+  "!=="
+  "=>"
+  ">"
+  ">="
+  ">>"
+  ">>="
+  ">>>"
+  ">>>="
+  "~"
+  "^"
+  "&"
+  "|"
+  "^="
+  "&="
+  "|="
+  "&&"
+  "||"
+  "??"
+  "&&="
+  "||="
+  "??="
+  "..."
+] @operator
+
+(ternary_expression ["?" ":"] @operator)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+]  @punctuation.bracket
+
+[
+  "as"
+  "async"
+  "debugger"
+  "delete"
+  "extends"
+  "function"
+  "get"
+  "in"
+  "instanceof"
+  "new"
+  "of"
+  "set"
+  "static"
+  "target"
+  "try"
+  "typeof"
+  "void"
+  "with"
+] @keyword
+
+[
+  "class"
+  "let"
+  "const"
+  "var"
+] @keyword.storage.type
+
+[
+  "switch"
+  "case"
+  "if"
+  "else"
+  "yield"
+  "throw"
+  "finally"
+  "return"
+  "catch"
+  "continue"
+  "while"
+  "break"
+  "for"
+  "do"
+  "await"
+] @keyword.control
+
+[
+  "import"
+  "default"
+  "from"
+  "export"
+] @keyword.control.import 
+
+; Highlight component names differently
+(jsx_opening_element ((identifier) @constructor
+ (#match? @constructor "^[A-Z]")))
+
+; Handle the dot operator effectively - <My.Component>
+(jsx_opening_element ((nested_identifier (identifier) @tag (identifier) @constructor)))
+
+(jsx_closing_element ((identifier) @constructor
+ (#match? @constructor "^[A-Z]")))
+
+; Handle the dot operator effectively - </My.Component>
+(jsx_closing_element ((nested_identifier (identifier) @tag (identifier) @constructor)))
+
+(jsx_self_closing_element ((identifier) @constructor
+ (#match? @constructor "^[A-Z]")))
+
+; Handle the dot operator effectively - <My.Component />
+(jsx_self_closing_element ((nested_identifier (identifier) @tag (identifier) @constructor)))
+
+; TODO: also tag @punctuation.delimiter?
+
+(jsx_opening_element (identifier) @tag)
+(jsx_closing_element (identifier) @tag)
+(jsx_self_closing_element (identifier) @tag)
+(jsx_attribute (property_identifier) @variable.other.member)
\ No newline at end of file
diff --git a/lapce-core/queries/julia/highlights.scm b/lapce-core/queries/julia/highlights.scm
new file mode 100644
index 0000000000..5c059126cf
--- /dev/null
+++ b/lapce-core/queries/julia/highlights.scm
@@ -0,0 +1,296 @@
+; ----------
+; Primitives
+; ----------
+
+[
+  (line_comment)
+  (block_comment)
+] @comment
+
+(
+  ((identifier) @constant.builtin)
+  (#match? @constant.builtin "^(nothing|missing|undef)$"))
+
+[
+  (true)
+  (false)
+] @constant.builtin.boolean
+
+(integer_literal) @constant.numeric.integer
+(float_literal) @constant.numeric.float
+
+(
+  ((identifier) @constant.numeric.float)
+  (#match? @constant.numeric.float "^((Inf|NaN)(16|32|64)?)$"))
+
+(character_literal) @constant.character
+(escape_sequence) @constant.character.escape
+
+(string_literal) @string
+
+(prefixed_string_literal
+  prefix: (identifier) @function.macro) @string
+
+(quote_expression
+  (identifier) @string.special.symbol) 
+  
+; -------------------
+; Modules and Imports
+; -------------------
+
+(module_definition
+  name: (identifier) @namespace)
+  
+(import_statement
+  (identifier) @namespace)
+  
+(selected_import
+  . (identifier) @namespace)
+
+(scoped_identifier
+  (identifier) @namespace)
+
+; -----
+; Types
+; -----
+
+(abstract_definition
+  name: (identifier) @type)
+  
+(primitive_definition
+  name: (identifier) @type)
+
+(struct_definition
+  name: (identifier) @type)
+
+(struct_definition
+  . (_)
+    (identifier) @variable.other.member)
+
+(struct_definition
+  . (_)
+  (typed_expression
+    . (identifier) @variable.other.member))
+    
+(type_parameter_list
+  (identifier) @type)
+
+(constrained_type_parameter
+  (identifier) @type)
+  
+(subtype_clause
+  (identifier) @type)
+
+(typed_expression
+  (identifier) @type . )
+
+(parameterized_identifier
+  (identifier) @type)
+  
+(type_argument_list
+  (identifier) @type)
+
+(where_clause
+  (identifier) @type)
+
+; -------------------
+; Function definition
+; -------------------
+
+(
+  (function_definition
+    name: [
+      (identifier) @function
+      (scoped_identifier
+        (identifier) @namespace
+        (identifier) @function)
+    ])
+  ; prevent constructors (PascalCase) to be highlighted as functions
+  (#match? @function "^[^A-Z]"))
+
+(
+  (short_function_definition
+    name: [
+      (identifier) @function
+      (scoped_identifier
+        (identifier) @namespace
+        (identifier) @function)
+    ])
+  ; prevent constructors (PascalCase) to be highlighted as functions
+  (#match? @function "^[^A-Z]"))
+
+(parameter_list
+  (identifier) @variable.parameter)
+
+(typed_parameter
+  (identifier) @variable.parameter
+  (identifier)? @type)
+
+(optional_parameter
+  . (identifier) @variable.parameter)
+
+(slurp_parameter
+  (identifier) @variable.parameter)
+
+(function_expression
+  . (identifier) @variable.parameter)
+
+; ---------------
+; Functions calls
+; ---------------
+
+(
+  (call_expression
+    (identifier) @function)
+  ; prevent constructors (PascalCase) to be highlighted as functions
+  (#match? @function "^[^A-Z]"))
+
+(
+  (broadcast_call_expression
+    (identifier) @function)
+  (#match? @function "^[^A-Z]"))
+
+(
+  (call_expression
+    (field_expression (identifier) @function .))
+  (#match? @function "^[^A-Z]"))
+
+(
+  (broadcast_call_expression
+    (field_expression (identifier) @function .))
+  (#match? @function "^[^A-Z]"))
+
+; ------
+; Macros
+; ------
+
+(macro_definition
+  name: (identifier) @function.macro)
+
+(macro_identifier
+  "@" @function.macro
+  (identifier) @function.macro)
+
+; --------
+; Keywords
+; --------
+
+(function_definition 
+  ["function" "end"] @keyword.function)
+
+(if_statement
+  ["if" "end"] @keyword.control.conditional)
+(elseif_clause
+  ["elseif"] @keyword.control.conditional)
+(else_clause
+  ["else"] @keyword.control.conditional)
+(ternary_expression
+  ["?" ":"] @keyword.control.conditional)
+
+(for_statement
+  ["for" "end"] @keyword.control.repeat)
+(while_statement
+  ["while" "end"] @keyword.control.repeat)
+(break_statement) @keyword.control.repeat
+(continue_statement) @keyword.control.repeat
+(for_binding
+  "in" @keyword.control.repeat)
+(for_clause
+  "for" @keyword.control.repeat)
+
+(try_statement
+  ["try" "end" ] @keyword.control.exception)
+(finally_clause
+  "finally" @keyword.control.exception)
+(catch_clause
+  "catch" @keyword.control.exception)
+
+[
+  "export"
+  "import"
+  "using"
+] @keyword.control.import
+
+[
+  "abstract"
+  "baremodule"
+  "begin"
+  "const"
+  "do"
+  "end"
+  "let"
+  "macro"
+  "module"
+  "mutable"
+  "primitive"
+  "quote"
+  "return"
+  "struct"
+  "type"
+  "where"
+] @keyword
+
+; TODO: fix this
+((identifier) @keyword (match? @keyword "global|local"))
+
+; ---------
+; Operators
+; ---------
+
+[
+  (operator)
+  "::"
+  "<:"
+  ":"
+  "=>"
+  "..."
+  "$"
+] @operator
+
+; ------------
+; Punctuations
+; ------------
+
+[
+  "."
+  "," 
+  ";"
+] @punctuation.delimiter
+
+[
+  "["
+  "]"
+  "("
+  ")" 
+  "{" 
+  "}"
+] @punctuation.bracket
+
+; ---------------------
+; Remaining identifiers
+; ---------------------
+
+(const_statement
+  (variable_declaration
+    . (identifier) @constant))
+
+; SCREAMING_SNAKE_CASE
+(
+  (identifier) @constant
+  (match? @constant "^[A-Z][A-Z0-9_]*$"))
+
+; remaining identifiers that start with capital letters should be types (PascalCase)
+(
+  (identifier) @type
+  (match? @type "^[A-Z]"))
+
+; Field expressions are either module content or struct fields.
+; Module types and constants should already be captured, so this
+; assumes the remaining identifiers to be struct fields.
+(field_expression
+  (_)
+  (identifier) @variable.other.member)
+
+(identifier) @variable
+
+; Taken from https://github.com/helix-editor/helix/blob/master/runtime/queries/julia/highlights.scm
\ No newline at end of file
diff --git a/lapce-core/queries/julia/injections.scm b/lapce-core/queries/julia/injections.scm
new file mode 100644
index 0000000000..c671e7f427
--- /dev/null
+++ b/lapce-core/queries/julia/injections.scm
@@ -0,0 +1,30 @@
+(
+  (source_file
+    (string_literal) @injection.content
+    .
+    [
+      (module_definition)
+      (function_definition)
+      (macro_definition)
+      (primitive_definition)
+      (abstract_definition)
+      (struct_definition)
+      (assignment_expression)
+      (const_statement)
+    ])
+  (#set! injection.language "markdown"))
+
+(
+  [
+    (line_comment) 
+    (block_comment)
+  ] @injection.content
+  (#set! injection.language "comment"))
+
+(
+  (prefixed_string_literal
+    prefix: (identifier) @function.macro) @injection.content
+  (#eq? @function.macro "re")
+  (#set! injection.language "regex"))
+
+;; taken from https://github.com/helix-editor/helix/blob/master/runtime/queries/julia/injections.scm
\ No newline at end of file
diff --git a/lapce-core/queries/kotlin/highlights.scm b/lapce-core/queries/kotlin/highlights.scm
new file mode 100644
index 0000000000..31da4bcc4b
--- /dev/null
+++ b/lapce-core/queries/kotlin/highlights.scm
@@ -0,0 +1,298 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/kotlin/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+
+(multi_line_string_literal
+	"$" @punctuation
+  (interpolated_identifier) @none)
+(multi_line_string_literal
+	"${" @punctuation
+	(interpolated_expression) @none
+	"}" @punctuation.)
+
+; NOTE: `interpolated_identifier`s can be highlighted in any way
+(line_string_literal
+	"$" @punctuation
+	(interpolated_identifier) @none)
+(line_string_literal
+	"${" @punctuation
+	(interpolated_expression) @none
+	"}" @punctuation)
+
+[
+	"."
+	","
+	";"
+	":"
+	"::"
+] @punctuation.delimiter
+
+[
+	"(" ")"
+	"[" "]"
+	"{" "}"
+] @punctuation.bracket
+
+[
+	"!"
+	"!="
+	"!=="
+	"="
+	"=="
+	"==="
+	">"
+	">="
+	"<"
+	"<="
+	"||"
+	"&&"
+	"+"
+	"++"
+	"+="
+	"-"
+	"--"
+	"-="
+	"*"
+	"*="
+	"/"
+	"/="
+	"%"
+	"%="
+	"?."
+	"?:"
+	"!!"
+	"is"
+	"!is"
+	"in"
+	"!in"
+	"as"
+	"as?"
+	".."
+	"->"
+] @operator
+
+;;; Keywords
+
+(type_alias "typealias" @keyword)
+[
+	(class_modifier)
+	(member_modifier)
+	(function_modifier)
+	(property_modifier)
+	(platform_modifier)
+	(variance_modifier)
+	(parameter_modifier)
+	(visibility_modifier)
+	(reification_modifier)
+	(inheritance_modifier)
+]@keyword
+
+[
+	"val"
+	"var"
+	"enum"
+	"class"
+	"object"
+	"interface"
+;	"typeof" ; NOTE: It is reserved for future use
+] @keyword
+
+("fun") @keyword.function
+
+(jump_expression) @keyword.control.return
+
+[
+	"if"
+	"else"
+	"when"
+] @keyword.control.conditional
+
+[
+	"for"
+	"do"
+	"while"
+] @keyword.control.repeat
+
+[
+	"try"
+	"catch"
+	"throw"
+	"finally"
+] @keyword.control.exception
+
+(annotation
+	"@" @attribute (use_site_target)? @attribute)
+(annotation
+	(user_type
+		(type_identifier) @attribute))
+(annotation
+	(constructor_invocation
+		(user_type
+			(type_identifier) @attribute)))
+
+(file_annotation
+	"@" @attribute "file" @attribute ":" @attribute)
+(file_annotation
+	(user_type
+		(type_identifier) @attribute))
+(file_annotation
+	(constructor_invocation
+		(user_type
+			(type_identifier) @attribute)))
+
+;;; Literals
+; NOTE: Escapes not allowed in multi-line strings
+(line_string_literal (character_escape_seq) @constant.character.escape)
+
+[
+	(line_string_literal)
+	(multi_line_string_literal)
+] @string
+
+(character_literal) @constant.character
+
+[
+	"null" ; should be highlighted the same as booleans
+	(boolean_literal)
+] @constant.builtin.boolean
+
+(real_literal) @constant.numeric.float
+[
+	(integer_literal)
+	(long_literal)
+	(hex_literal)
+	(bin_literal)
+	(unsigned_literal)
+] @constant.numeric.integer
+
+[
+	(comment)
+	(shebang_line)
+] @comment
+
+;;; Function calls
+
+(call_expression
+	. (simple_identifier) @function.builtin
+    (#match? @function.builtin "^(arrayOf|arrayOfNulls|byteArrayOf|shortArrayOf|intArrayOf|longArrayOf|ubyteArrayOf|ushortArrayOf|uintArrayOf|ulongArrayOf|floatArrayOf|doubleArrayOf|booleanArrayOf|charArrayOf|emptyArray|mapOf|setOf|listOf|emptyMap|emptySet|emptyList|mutableMapOf|mutableSetOf|mutableListOf|print|println|error|TODO|run|runCatching|repeat|lazy|lazyOf|enumValues|enumValueOf|assert|check|checkNotNull|require|requireNotNull|with|suspend|synchronized)$"))
+
+; object.function() or object.property.function()
+(call_expression
+	(navigation_expression
+		(navigation_suffix
+			(simple_identifier) @function) . ))
+
+; function()
+(call_expression
+	. (simple_identifier) @function)
+
+;;; Function definitions
+
+; lambda parameters
+(lambda_literal
+	(lambda_parameters
+		(variable_declaration
+			(simple_identifier) @variable.parameter)))
+			
+(parameter_with_optional_type
+	(simple_identifier) @variable.parameter)
+			
+(parameter
+	(simple_identifier) @variable.parameter)
+			
+(anonymous_initializer
+	("init") @constructor)
+
+(constructor_invocation
+	(user_type
+		(type_identifier) @constructor))
+			
+(secondary_constructor
+	("constructor") @constructor)
+(primary_constructor) @constructor
+			
+(getter
+	("get") @function.builtin)
+(setter
+	("set") @function.builtin)
+
+(function_declaration
+	. (simple_identifier) @function)
+
+; TODO: Separate labeled returns/breaks/continue/super/this
+;       Must be implemented in the parser first
+(label) @label
+
+(import_header
+	(identifier
+		(simple_identifier) @function @_import .)
+	(import_alias
+		(type_identifier) @function)?
+		(#match? @_import "^[a-z]"))
+
+; The last `simple_identifier` in a `import_header` will always either be a function
+; or a type. Classes can appear anywhere in the import path, unlike functions
+(import_header
+	(identifier
+		(simple_identifier) @type @_import)
+	(import_alias
+		(type_identifier) @type)?
+		(#match? @_import "^[A-Z]"))
+
+(import_header
+	"import" @keyword.control.import)
+
+(package_header
+	. (identifier)) @namespace
+
+((type_identifier) @type.builtin
+	(#match? @function.builtin "^(Byte|Short|Int|Long|UByte|UShort|UInt|ULong|Float|Double|Boolean|Char|String|Array|ByteArray|ShortArray|IntArray|LongArray|UByteArray|UShortArray|UIntArray|ULongArray|FloatArray|DoubleArray|BooleanArray|CharArray|Map|Set|List|EmptyMap|EmptySet|EmptyList|MutableMap|MutableSet|MutableList)$"))
+
+(type_identifier) @type
+
+(enum_entry
+	(simple_identifier) @constant)
+
+(_
+	(navigation_suffix
+		(simple_identifier) @constant
+		(#match? @constant "^[A-Z][A-Z0-9_]*$")))
+
+; SCREAMING CASE identifiers are assumed to be constants
+((simple_identifier) @constant
+(#match? @constant "^[A-Z][A-Z0-9_]*$"))
+
+; id_1.id_2.id_3: `id_2` and `id_3` are assumed as object properties
+(_
+	(navigation_suffix
+		(simple_identifier) @variable.other.member))
+
+(class_body
+	(property_declaration
+		(variable_declaration
+			(simple_identifier) @variable.other.member)))
+
+(class_parameter
+	(simple_identifier) @variable.other.member)
+
+; `super` keyword inside classes
+(super_expression) @variable.builtin
+
+; `this` this keyword inside classes
+(this_expression) @variable.builtin
+
+;;; Identifiers
+; `field` keyword inside property getter/setter
+; FIXME: This will highlight the keyword outside of getters and setters
+;        since tree-sitter does not allow us to check for arbitrary nestation
+((simple_identifier) @variable.builtin
+(#eq? @variable.builtin "field"))
+
+; `it` keyword inside lambdas
+; FIXME: This will highlight the keyword outside of lambdas since tree-sitter
+;        does not allow us to check for arbitrary nestation
+((simple_identifier) @variable.builtin
+(#eq? @variable.builtin "it"))
+
+(simple_identifier) @variable
diff --git a/lapce-core/queries/kotlin/injections.scm b/lapce-core/queries/kotlin/injections.scm
new file mode 100644
index 0000000000..06d39e1dfb
--- /dev/null
+++ b/lapce-core/queries/kotlin/injections.scm
@@ -0,0 +1,40 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/kotlin/injections.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+((comment) @injection.content
+	(#set! injection.language "comment"))
+
+; There are 3 ways to define a regex
+;    - "[abc]?".toRegex()
+((call_expression
+	(navigation_expression
+		([(line_string_literal) (multi_line_string_literal)] @injection.content)
+		(navigation_suffix
+			((simple_identifier) @_function
+			(#eq? @_function "toRegex")))))
+	(#set! injection.language "regex"))
+
+;    - Regex("[abc]?")
+((call_expression
+	((simple_identifier) @_function
+	(#eq? @_function "Regex"))
+	(call_suffix
+		(value_arguments
+			(value_argument
+				[ (line_string_literal) (multi_line_string_literal) ] @injection.content))))
+	(#set! injection.language "regex"))
+
+;    - Regex.fromLiteral("[abc]?")
+((call_expression
+	(navigation_expression
+		((simple_identifier) @_class
+		(#eq? @_class "Regex"))
+		(navigation_suffix
+			((simple_identifier) @_function
+			(#eq? @_function "fromLiteral"))))
+	(call_suffix
+		(value_arguments
+			(value_argument
+				[ (line_string_literal) (multi_line_string_literal) ] @injection.content))))
+	(#set! injection.language "regex"))
diff --git a/lapce-core/queries/latex/highlights.scm b/lapce-core/queries/latex/highlights.scm
new file mode 100644
index 0000000000..1ad0d86184
--- /dev/null
+++ b/lapce-core/queries/latex/highlights.scm
@@ -0,0 +1,247 @@
+; source: https://github.com/nvim-treesitter/nvim-treesitter/blob/965a74f76a2999b81fe3a543fb5e53bf6c84b8b7/queries/latex/highlights.scm
+; licence: https://github.com/nvim-treesitter/nvim-treesitter/blob/965a74f76a2999b81fe3a543fb5e53bf6c84b8b7/LICENSE
+; spdx: Apache-2.0
+
+;; General syntax
+(ERROR) @error
+
+(command_name) @function
+(caption
+  command: _ @function)
+
+(key_value_pair
+  key: (_) @parameter
+  value: (_))
+
+[
+ (line_comment)
+ (block_comment)
+ (comment_environment)
+] @comment
+
+[
+ (brack_group)
+ (brack_group_argc)
+] @parameter
+
+[(operator) "="] @operator
+
+"\\item" @punctuation.special
+
+((word) @punctuation.delimiter
+(#eq? @punctuation.delimiter "&"))
+
+["[" "]" "{" "}"] @punctuation.bracket ; "(" ")" has no syntactical meaning in LaTeX
+
+;; General environments
+(begin
+ command: _ @text.environment
+ name: (curly_group_text (text) @text.environment.name))
+
+(end
+ command: _ @text.environment
+ name: (curly_group_text (text) @text.environment.name))
+
+;; Definitions and references
+(new_command_definition
+ command: _ @function.macro
+ declaration: (curly_group_command_name (_) @function))
+(old_command_definition
+ command: _ @function.macro
+ declaration: (_) @function)
+(let_command_definition
+ command: _ @function.macro
+ declaration: (_) @function)
+
+(environment_definition
+ command: _ @function.macro
+ name: (curly_group_text (_) @text.reference))
+
+(theorem_definition
+ command: _ @function.macro
+ name: (curly_group_text (_) @text.environment.name))
+
+(paired_delimiter_definition
+ command: _ @function.macro
+ declaration: (curly_group_command_name (_) @function))
+
+(label_definition
+ command: _ @function.macro
+ name: (curly_group_text (_) @text.reference))
+(label_reference_range
+ command: _ @function.macro
+ from: (curly_group_text (_) @text.reference)
+ to: (curly_group_text (_) @text.reference))
+(label_reference
+ command: _ @function.macro
+ names: (curly_group_text_list (_) @text.reference))
+(label_number
+ command: _ @function.macro
+ name: (curly_group_text (_) @text.reference)
+ number: (_) @text.reference)
+
+(citation
+ command: _ @function.macro
+ keys: (curly_group_text_list) @text.reference)
+
+(glossary_entry_definition
+ command: _ @function.macro
+ name: (curly_group_text (_) @text.reference))
+(glossary_entry_reference
+ command: _ @function.macro
+ name: (curly_group_text (_) @text.reference))
+
+(acronym_definition
+ command: _ @function.macro
+ name: (curly_group_text (_) @text.reference))
+(acronym_reference
+ command: _ @function.macro
+ name: (curly_group_text (_) @text.reference))
+
+(color_definition
+ command: _ @function.macro
+ name: (curly_group_text (_) @text.reference))
+(color_reference
+ command: _ @function.macro
+ name: (curly_group_text (_) @text.reference))
+
+;; Math
+[
+ (displayed_equation)
+ (inline_formula)
+] @text.math
+
+(math_environment
+  (begin
+   command: _ @text.math
+   name: (curly_group_text (text) @text.math)))
+
+(math_environment
+  (text) @text.math)
+
+(math_environment
+  (end
+   command: _ @text.math
+   name: (curly_group_text (text) @text.math)))
+
+;; Sectioning
+(title_declaration
+  command: _ @namespace
+  options: (brack_group (_) @text.title)?
+  text: (curly_group (_) @text.title))
+
+(author_declaration
+  command: _ @namespace
+  authors: (curly_group_author_list
+             ((author)+ @text.title)))
+
+(chapter
+  command: _ @namespace
+  toc: (brack_group (_) @text.title)?
+  text: (curly_group (_) @text.title))
+
+(part
+  command: _ @namespace
+  toc: (brack_group (_) @text.title)?
+  text: (curly_group (_) @text.title))
+
+(section
+  command: _ @namespace
+  toc: (brack_group (_) @text.title)?
+  text: (curly_group (_) @text.title))
+
+(subsection
+  command: _ @namespace
+  toc: (brack_group (_) @text.title)?
+  text: (curly_group (_) @text.title))
+
+(subsubsection
+  command: _ @namespace
+  toc: (brack_group (_) @text.title)?
+  text: (curly_group (_) @text.title))
+
+(paragraph
+  command: _ @namespace
+  toc: (brack_group (_) @text.title)?
+  text: (curly_group (_) @text.title))
+
+(subparagraph
+  command: _ @namespace
+  toc: (brack_group (_) @text.title)?
+  text: (curly_group (_) @text.title))
+
+;; Beamer frames
+(generic_environment
+  (begin
+    name: (curly_group_text
+            (text) @text.environment.name)
+    (#any-of? @text.environment.name "frame"))
+  .
+  (curly_group (_) @text.title))
+
+((generic_command
+  command: (command_name) @_name
+  arg: (curly_group
+          (text) @text.title))
+ (#eq? @_name "\\frametitle"))
+
+;; Formatting
+((generic_command
+  command: (command_name) @_name
+  arg: (curly_group (_) @text.emphasis))
+  (#eq? @_name "\\emph"))
+
+((generic_command
+  command: (command_name) @_name
+  arg: (curly_group (_) @text.emphasis))
+  (#match? @_name "^(\\\\textit|\\\\mathit)$"))
+
+((generic_command
+  command: (command_name) @_name
+  arg: (curly_group (_) @text.strong))
+  (#match? @_name "^(\\\\textbf|\\\\mathbf)$"))
+
+((generic_command
+  command: (command_name) @_name
+  .
+  arg: (curly_group (_) @text.uri))
+ (#match? @_name "^(\\\\url|\\\\href)$"))
+
+;; File inclusion commands
+(class_include
+  command: _ @include
+  path: (curly_group_path) @string)
+
+(package_include
+  command: _ @include
+  paths: (curly_group_path_list) @string)
+
+(latex_include
+  command: _ @include
+  path: (curly_group_path) @string)
+(import_include
+  command: _ @include
+  directory: (curly_group_path) @string
+  file: (curly_group_path) @string)
+
+(bibtex_include
+  command: _ @include
+  path: (curly_group_path) @string)
+(biblatex_include
+  "\\addbibresource" @include
+  glob: (curly_group_glob_pattern) @string.regex)
+
+(graphics_include
+  command: _ @include
+  path: (curly_group_path) @string)
+(tikz_library_import
+  command: _ @include
+  paths: (curly_group_path_list) @string)
+
+(
+    (text) @spell
+    (#not-has-parent? @spell
+        inline_formula
+        displayed_equation
+    )
+)
\ No newline at end of file
diff --git a/lapce-core/queries/latex/injections.scm b/lapce-core/queries/latex/injections.scm
new file mode 100644
index 0000000000..d2b924b5ed
--- /dev/null
+++ b/lapce-core/queries/latex/injections.scm
@@ -0,0 +1,25 @@
+; source: https://github.com/nvim-treesitter/nvim-treesitter/blob/965a74f76a2999b81fe3a543fb5e53bf6c84b8b7/queries/latex/injections.scm
+; licence: https://github.com/nvim-treesitter/nvim-treesitter/blob/965a74f76a2999b81fe3a543fb5e53bf6c84b8b7/LICENSE
+; spdx: Apache-2.0
+
+[
+ (line_comment)
+ (block_comment)
+ (comment_environment)
+] @comment
+
+(pycode_environment
+  code: (source_code) @python
+)
+
+(minted_environment
+  (begin
+    language: (curly_group_text
+               (text) @language))
+  (source_code) @content)
+
+((generic_environment
+  (begin
+   name: (curly_group_text
+           (text) @_env))) @c
+   (#any-of? @_env "asy" "asydef"))
diff --git a/lapce-core/queries/lua/highlights.scm b/lapce-core/queries/lua/highlights.scm
new file mode 100644
index 0000000000..0f7fd62167
--- /dev/null
+++ b/lapce-core/queries/lua/highlights.scm
@@ -0,0 +1,196 @@
+;; source: https://github.com/nvim-treesitter/nvim-treesitter/blob/master/queries/lua
+;; license: https://github.com/nvim-treesitter/nvim-treesitter/blob/master/LICENSE
+;; spdx: Apache-2.0
+
+;; Keywords
+
+"return" @keyword.return
+
+[
+ "goto"
+ "in"
+ "local"
+] @keyword
+
+(label_statement) @label
+
+(break_statement) @keyword
+
+(do_statement
+[
+  "do"
+  "end"
+] @keyword)
+
+(while_statement
+[
+  "while"
+  "do"
+  "end"
+] @repeat)
+
+(repeat_statement
+[
+  "repeat"
+  "until"
+] @repeat)
+
+(if_statement
+[
+  "if"
+  "elseif"
+  "else"
+  "then"
+  "end"
+] @conditional)
+
+(elseif_statement
+[
+  "elseif"
+  "then"
+  "end"
+] @conditional)
+
+(else_statement
+[
+  "else"
+  "end"
+] @conditional)
+
+(for_statement
+[
+  "for"
+  "do"
+  "end"
+] @repeat)
+
+(function_declaration
+[
+  "function"
+  "end"
+] @keyword.function)
+
+(function_definition
+[
+  "function"
+  "end"
+] @keyword.function)
+
+;; Operators
+
+[
+ "and"
+ "not"
+ "or"
+] @keyword.operator
+
+[
+  "+"
+  "-"
+  "*"
+  "/"
+  "%"
+  "^"
+  "#"
+  "=="
+  "~="
+  "<="
+  ">="
+  "<"
+  ">"
+  "="
+  "&"
+  "~"
+  "|"
+  "<<"
+  ">>"
+  "//"
+  ".."
+] @operator
+
+;; Punctuations
+
+[
+  ";"
+  ":"
+  ","
+  "."
+] @punctuation.delimiter
+
+;; Brackets
+
+[
+ "("
+ ")"
+ "["
+ "]"
+ "{"
+ "}"
+] @punctuation.bracket
+
+;; Variables
+
+(identifier) @variable
+
+((identifier) @variable.builtin
+ (#eq? @variable.builtin "self"))
+
+;; Constants
+
+((identifier) @constant
+ (#lua-match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+(vararg_expression) @constant
+
+(nil) @constant.builtin
+
+[
+  (false)
+  (true)
+] @boolean
+
+;; Tables
+
+(field name: (identifier) @field)
+
+(dot_index_expression field: (identifier) @field)
+
+(table_constructor
+[
+  "{"
+  "}"
+] @constructor)
+
+;; Functions
+
+(parameters (identifier) @parameter)
+
+(function_call name: (identifier) @function)
+(function_declaration name: (identifier) @function)
+
+(function_call name: (dot_index_expression field: (identifier) @function))
+(function_declaration name: (dot_index_expression field: (identifier) @function))
+
+(method_index_expression method: (identifier) @method)
+
+(function_call
+  (identifier) @function.builtin
+  (#any-of? @function.builtin
+    ;; built-in functions in Lua 5.1
+    "assert" "collectgarbage" "dofile" "error" "getfenv" "getmetatable" "ipairs"
+    "load" "loadfile" "loadstring" "module" "next" "pairs" "pcall" "print"
+    "rawequal" "rawget" "rawset" "require" "select" "setfenv" "setmetatable"
+    "tonumber" "tostring" "type" "unpack" "xpcall"))
+
+;; Others
+
+(comment) @comment
+
+(hash_bang_line) @comment
+
+(number) @number
+
+(string) @string
+
+;; Error
+(ERROR) @error
\ No newline at end of file
diff --git a/lapce-core/queries/markdown.inline/highlights.scm b/lapce-core/queries/markdown.inline/highlights.scm
new file mode 100644
index 0000000000..df8fb3d0c6
--- /dev/null
+++ b/lapce-core/queries/markdown.inline/highlights.scm
@@ -0,0 +1,91 @@
+;; From MDeiml/tree-sitter-markdown
+[
+  (code_span)
+  (link_title)
+] @text.literal
+
+[
+  (emphasis_delimiter)
+  (code_span_delimiter)
+] @punctuation.delimiter
+
+(emphasis) @text.emphasis
+
+(strong_emphasis) @text.strong
+
+[
+  (link_destination)
+  (uri_autolink)
+] @text.uri
+
+[
+  (link_label)
+  (link_text)
+  (image_description)
+] @text.reference
+
+[
+  (backslash_escape)
+  (hard_line_break)
+] @string.escape
+
+; "(" not part of query because of
+; https://github.com/nvim-treesitter/nvim-treesitter/issues/2206
+; TODO: Find better fix for this
+(image ["!" "[" "]" "("] @punctuation.delimiter)
+(inline_link ["[" "]" "("] @punctuation.delimiter)
+(shortcut_link ["[" "]"] @punctuation.delimiter)
+
+([
+  (code_span_delimiter)
+  (emphasis_delimiter)
+] @conceal
+(#set! conceal ""))
+
+; Conceal inline links
+(inline_link
+  [
+    "["
+    "]"
+    "("
+    (link_destination)
+    ")"
+  ] @conceal
+  (#set! conceal ""))
+
+; Conceal image links
+(image
+  [
+    "!"
+    "["
+    "]"
+    "("
+    (link_destination)
+    ")"
+  ] @conceal
+  (#set! conceal ""))
+
+; Conceal full reference links
+(full_reference_link
+  [
+    "["
+    "]"
+    (link_label)
+  ] @conceal
+  (#set! conceal ""))
+
+; Conceal collapsed reference links
+(collapsed_reference_link
+  [
+    "["
+    "]"
+  ] @conceal
+  (#set! conceal ""))
+
+; Conceal shortcut links
+(shortcut_link
+  [
+    "["
+    "]"
+  ] @conceal
+  (#set! conceal ""))
\ No newline at end of file
diff --git a/lapce-core/queries/markdown.inline/injections.scm b/lapce-core/queries/markdown.inline/injections.scm
new file mode 100644
index 0000000000..c137a8222a
--- /dev/null
+++ b/lapce-core/queries/markdown.inline/injections.scm
@@ -0,0 +1,2 @@
+
+((html_tag) @injection.content (#set! injection.language "html"))
diff --git a/lapce-core/queries/markdown/highlights.scm b/lapce-core/queries/markdown/highlights.scm
new file mode 100644
index 0000000000..ecd0596a82
--- /dev/null
+++ b/lapce-core/queries/markdown/highlights.scm
@@ -0,0 +1,58 @@
+;From MDeiml/tree-sitter-markdown
+(atx_heading (inline) @text.title)
+(setext_heading (paragraph) @text.title)
+
+[
+  (atx_h1_marker)
+  (atx_h2_marker)
+  (atx_h3_marker)
+  (atx_h4_marker)
+  (atx_h5_marker)
+  (atx_h6_marker)
+  (setext_h1_underline)
+  (setext_h2_underline)
+] @punctuation.special
+
+[
+  (link_title)
+  (indented_code_block)
+  (fenced_code_block)
+] @text.literal
+
+[
+  (fenced_code_block_delimiter)
+] @punctuation.delimiter
+
+(code_fence_content) @none
+
+[
+  (link_destination)
+] @text.uri
+
+[
+  (link_label)
+] @text.reference
+
+[
+  (list_marker_plus)
+  (list_marker_minus)
+  (list_marker_star)
+  (list_marker_dot)
+  (list_marker_parenthesis)
+  (thematic_break)
+] @punctuation.special
+
+[
+  (block_continuation)
+  (block_quote_marker)
+] @punctuation.special
+
+[
+  (backslash_escape)
+] @string.escape
+
+([
+  (info_string)
+  (fenced_code_block_delimiter)
+] @conceal
+(#set! conceal ""))
\ No newline at end of file
diff --git a/lapce-core/queries/markdown/injections.scm b/lapce-core/queries/markdown/injections.scm
new file mode 100644
index 0000000000..16f7936bf9
--- /dev/null
+++ b/lapce-core/queries/markdown/injections.scm
@@ -0,0 +1,15 @@
+; From nvim-treesitter/nvim-treesitter
+
+(fenced_code_block
+  (info_string
+    (language) @injection.language)
+  (code_fence_content) @injection.content (#set! injection.include-unnamed-children))
+
+((html_block) @injection.content (#set! injection.language "html") (#set! injection.include-unnamed-children))
+
+([
+  (minus_metadata)
+  (plus_metadata)
+] @injection.content (#set! injection.language "yaml") (#set! injection.include-unnamed-children))
+
+((inline) @injection.content (#set! injection.language "markdown.inline") (#set! injection.include-unnamed-children))
\ No newline at end of file
diff --git a/lapce-core/queries/prisma/highlights.scm b/lapce-core/queries/prisma/highlights.scm
new file mode 100644
index 0000000000..946865c163
--- /dev/null
+++ b/lapce-core/queries/prisma/highlights.scm
@@ -0,0 +1,60 @@
+; source: https://github.com/victorhqc/tree-sitter-prisma/blob/master/queries/highlights.scm
+; https://github.com/victorhqc/tree-sitter-prisma/blob/master/LICENSE
+; spdx: MIT
+
+(string) @string
+
+(enumeral) @constant
+(number) @constant.numeric
+
+(variable) @variable
+(column_type) @type
+
+(arguments) @variable.other.member
+(model_declaration (identifier) @type)
+
+[
+ "datasource"
+ "enum"
+ "generator"
+ "model"
+ "type"
+] @keyword
+
+[
+ (comment)
+ (developer_comment)
+] @comment
+
+[
+ (attribute)
+ (block_attribute_declaration)
+ (call_expression)
+] @function.builtin
+
+[
+ (true)
+ (false)
+ (null)
+] @constant.builtin.boolean
+
+[
+ "("
+ ")"
+ "["
+ "]"
+ "{"
+ "}"
+] @punctuation.bracket
+
+[
+ ":" 
+ ","
+] @punctuation.delimiter
+
+[
+ "="
+ "@"
+ "@@"
+ (binary_expression)
+] @operator
diff --git a/lapce-core/queries/protobuf/highlights.scm b/lapce-core/queries/protobuf/highlights.scm
new file mode 100644
index 0000000000..bd15e60d4c
--- /dev/null
+++ b/lapce-core/queries/protobuf/highlights.scm
@@ -0,0 +1,62 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/protobuf/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+[
+  "syntax"
+  "package"
+  "option"
+  "import"
+  "service"
+  "rpc"
+  "returns"
+  "message"
+  "enum"
+  "oneof"
+  "repeated"
+  "reserved"
+  "to"
+  "stream"
+  "extend"
+  "optional"
+] @keyword
+
+[
+  (keyType)
+  (type)
+] @type.builtin
+
+[
+  (mapName)
+  (enumName)
+  (messageName)
+  (extendName)
+  (serviceName)
+  (rpcName)
+] @type
+
+[
+  (fieldName)
+  (optionName)
+] @variable.other.member
+(enumVariantName) @type.enum.variant
+
+(fullIdent) @namespace
+
+(intLit) @constant.numeric.integer
+(floatLit) @constant.numeric.float
+(boolLit) @constant.builtin.boolean
+(strLit) @string
+
+(constant) @constant
+
+(comment) @comment
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+]  @punctuation.bracket
\ No newline at end of file
diff --git a/lapce-core/queries/protobuf/injections.scm b/lapce-core/queries/protobuf/injections.scm
new file mode 100644
index 0000000000..8454f9fe19
--- /dev/null
+++ b/lapce-core/queries/protobuf/injections.scm
@@ -0,0 +1,6 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/protobuf/injections.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+((comment) @injection.content
+ (#set! injection.language "comment"))
\ No newline at end of file
diff --git a/lapce-core/queries/r/highlights.scm b/lapce-core/queries/r/highlights.scm
new file mode 100644
index 0000000000..6bb904386b
--- /dev/null
+++ b/lapce-core/queries/r/highlights.scm
@@ -0,0 +1,128 @@
+; source: https://raw.githubusercontent.com/r-lib/tree-sitter-r/1589b7d83441c57cd77c5188e44f2af40d45ff49/queries/highlights.scm
+; license: https://github.com/r-lib/tree-sitter-r/blob/1589b7d83441c57cd77c5188e44f2af40d45ff49/LICENSE
+; spdx: mit
+; highlights.scm
+
+
+; Literals
+
+(integer) @number
+
+(float) @float
+
+(complex) @number
+
+(string) @string
+(string (escape_sequence) @string.escape)
+
+(comment) @comment
+
+(identifier) @variable
+
+(formal_parameters (identifier) @parameter)
+
+; Operators
+[
+ "="
+ "<-"
+ "<<-"
+ "->>"
+ "->"
+] @operator
+
+(unary operator: [
+  "-"
+  "+"
+  "!"
+  "~"
+] @operator)
+
+(binary operator: [
+  "-"
+  "+"
+  "*"
+  "/"
+  "^"
+  "<"
+  ">"
+  "<="
+  ">="
+  "=="
+  "!="
+  "||"
+  "|"
+  "&&"
+  "&"
+  ":"
+  "~"
+] @operator)
+
+[
+  "|>"
+  (special)
+] @operator
+
+[
+ "("
+ ")"
+ "["
+ "]"
+ "{"
+ "}"
+] @punctuation.bracket
+
+(dollar "$" @operator)
+
+(subset2
+  "[[" @punctuation.bracket
+  "]]" @punctuation.bracket)
+
+[
+ "in"
+ (dots)
+ (break)
+ (next)
+ (inf)
+] @keyword
+
+[
+  (nan)
+  (na)
+  (null)
+] @type.builtin
+
+[
+  "if"
+  "else"
+] @conditional
+
+[
+  "while"
+  "repeat"
+  "for"
+] @repeat
+
+[
+  (true)
+  (false)
+] @boolean
+
+"function" @keyword.function
+
+(call function: (identifier) @function)
+(call arguments:
+ (arguments
+  name: (identifier) @parameter ))
+
+(lambda_function "\\" @operator)
+
+(namespace_get function: (identifier) @method)
+(namespace_get_internal function: (identifier) @method)
+
+(namespace_get namespace: (identifier) @namespace
+ "::" @operator)
+(namespace_get_internal namespace: (identifier) @namespace
+ ":::" @operator)
+
+; Error
+(ERROR) @error
diff --git a/lapce-core/queries/svelte/highlights.scm b/lapce-core/queries/svelte/highlights.scm
new file mode 100644
index 0000000000..2e30815f45
--- /dev/null
+++ b/lapce-core/queries/svelte/highlights.scm
@@ -0,0 +1,110 @@
+; src: https://github.com/helix-editor/helix/blob/master/runtime/queries/svelte/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+(tag_name) @tag
+(erroneous_end_tag_name) @error
+(comment) @comment
+(attribute_name) @tag.attribute
+(attribute
+  (quoted_attribute_value) @string)
+(text) @text @spell
+
+((element (start_tag (tag_name) @_tag) (text) @text.title)
+ (#match? @_tag "^(h[0-9]|title)$"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.strong)
+ (#match? @_tag "^(strong|b)$"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.emphasis)
+ (#match? @_tag "^(em|i)$"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.strike)
+ (#match? @_tag "^(s|del)$"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.underline)
+ (#eq? @_tag "u"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.literal)
+ (#match? @_tag "^(code|kbd)$"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.uri)
+ (#eq? @_tag "a"))
+
+((attribute
+   (attribute_name) @_attr
+   (quoted_attribute_value (attribute_value) @text.uri))
+ (#match? @_attr "^(href|src)$"))
+
+[
+ "<"
+ ">"
+ "</"
+ "/>"
+] @tag.delimiter
+
+"=" @operator
+((element (start_tag (tag_name) @_tag) (text) @text.title)
+ (#match? @_tag "^(h[0-9]|title)$"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.strong)
+ (#match? @_tag "^(strong|b)$"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.emphasis)
+ (#match? @_tag "^(em|i)$"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.strike)
+ (#match? @_tag "^(s|del)$"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.underline)
+ (#eq? @_tag "u"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.literal)
+ (#match? @_tag "^(code|kbd)$"))
+
+((element (start_tag (tag_name) @_tag) (text) @text.uri)
+ (#eq? @_tag "a"))
+
+((attribute
+   (attribute_name) @_attr
+   (quoted_attribute_value (attribute_value) @text.uri))
+ (#match? @_attr "^(href|src)$"))
+
+(tag_name) @tag
+(attribute_name) @property
+(erroneous_end_tag_name) @error
+(comment) @comment
+
+[
+  (attribute_value)
+  (quoted_attribute_value)
+] @string
+
+[
+  (text)
+  (raw_text_expr)
+] @none
+
+[
+  (special_block_keyword)
+  (then)
+  (as)
+] @keyword
+
+[
+  "{"
+  "}"
+] @punctuation.bracket
+
+"=" @operator
+
+[
+  "<"
+  ">"
+  "</"
+  "/>"
+  "#"
+  ":"
+  "/"
+  "@"
+] @tag.delimiter
diff --git a/lapce-core/queries/svelte/indents.scm b/lapce-core/queries/svelte/indents.scm
new file mode 100644
index 0000000000..716a3f2321
--- /dev/null
+++ b/lapce-core/queries/svelte/indents.scm
@@ -0,0 +1,24 @@
+;src: https://github.com/nvim-treesitter/nvim-treesitter/blob/master/queries/svelte/indents.scm
+;licence https://github.com/nvim-treesitter/nvim-treesitter/blob/master/LICENSE
+; spdx: Apache-2.0
+
+[
+  (element)
+  (if_statement)
+  (each_statement)
+  (await_statement)
+  (script_element)
+  (style_element)
+] @indent
+
+[
+  (end_tag)
+  (else_statement)
+  (if_end_expr)
+  (each_end_expr)
+  (await_end_expr)
+  ">"
+  "/>"
+] @branch
+
+(comment) @ignore
diff --git a/lapce-core/queries/svelte/injections.scm b/lapce-core/queries/svelte/injections.scm
new file mode 100644
index 0000000000..f24f89bcf8
--- /dev/null
+++ b/lapce-core/queries/svelte/injections.scm
@@ -0,0 +1,32 @@
+; src: https://github.com/helix-editor/helix/blob/master/runtime/queries/svelte/injections.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+((style_element
+  (raw_text) @injection.content)
+  (#set! injection.language "css"))
+
+((attribute
+   (attribute_name) @_attr
+   (quoted_attribute_value (attribute_value) @css))
+ (#eq? @_attr "style"))
+
+((script_element
+  (raw_text) @injection.content)
+  (#set! injection.language "javascript"))
+
+((raw_text_expr) @injection.content
+ (#set! injection.language "javascript"))
+
+(
+  (script_element
+    (start_tag
+      (attribute
+        (quoted_attribute_value (attribute_value) @_lang)))
+    (raw_text) @injection.content)
+  (#match? @_lang "(ts|typescript)")
+  (#set! injection.language "typescript")
+)
+
+((comment) @injection.content
+ (#set! injection.language "comment"))
diff --git a/lapce-core/queries/typescript/highlights.scm b/lapce-core/queries/typescript/highlights.scm
new file mode 100644
index 0000000000..e98606165e
--- /dev/null
+++ b/lapce-core/queries/typescript/highlights.scm
@@ -0,0 +1,287 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/typescript/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+; Namespaces
+
+(internal_module
+  [((identifier) @namespace) ((nested_identifier (identifier) @namespace))])
+
+(ambient_declaration "global" @namespace)
+
+
+; Variables
+
+(required_parameter (identifier) @variable.parameter)
+(optional_parameter (identifier) @variable.parameter)
+
+; Punctuation
+
+[
+  ":"
+] @punctuation.delimiter
+
+(optional_parameter "?" @punctuation.special)
+(property_signature "?" @punctuation.special)
+
+(conditional_type ["?" ":"] @operator)
+
+
+
+; Keywords
+
+[
+  "abstract"
+  "declare"
+  "export"
+  "infer"
+  "implements"
+  "keyof"
+  "namespace"
+] @keyword
+
+[
+  "type"
+  "interface"
+  "enum"
+] @keyword.storage.type
+
+[
+  "public"
+  "private"
+  "protected"
+  "readonly"
+] @keyword.storage.modifier
+
+; Special identifiers
+;--------------------
+
+([
+    (identifier)
+    (shorthand_property_identifier)
+    (shorthand_property_identifier_pattern)
+ ] @constant
+ (#match? @constant "^[A-Z_][A-Z\\d_]+$"))
+
+
+((identifier) @constructor
+ (#match? @constructor "^[A-Z]"))
+
+((identifier) @variable.builtin
+ (#match? @variable.builtin "^(arguments|module|console|window|document)$")
+ (#is-not? local))
+
+((identifier) @function.builtin
+ (#eq? @function.builtin "require")
+ (#is-not? local))
+
+; Function and method definitions
+;--------------------------------
+
+(function
+  name: (identifier) @function)
+(function_declaration
+  name: (identifier) @function)
+(method_definition
+  name: (property_identifier) @function.method)
+
+(pair
+  key: (property_identifier) @function.method
+  value: [(function) (arrow_function)])
+
+(assignment_expression
+  left: (member_expression
+    property: (property_identifier) @function.method)
+  right: [(function) (arrow_function)])
+
+(variable_declarator
+  name: (identifier) @function
+  value: [(function) (arrow_function)])
+
+(assignment_expression
+  left: (identifier) @function
+  right: [(function) (arrow_function)])
+  
+
+; Function and method calls
+;--------------------------
+
+(call_expression
+  function: (identifier) @function)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @function.method))
+
+; Variables
+;----------
+
+(identifier) @variable
+
+; Properties
+;-----------
+
+(property_identifier) @variable.other.member
+(shorthand_property_identifier) @variable.other.member
+(shorthand_property_identifier_pattern) @variable.other.member
+
+; Literals
+;---------
+
+(this) @variable.builtin
+(super) @variable.builtin
+
+[
+  (true)
+  (false)
+  (null)
+  (undefined)
+] @constant.builtin
+
+(comment) @comment
+
+[
+  (string)
+  (template_string)
+] @string
+
+(regex) @string.regexp
+(number) @constant.numeric.integer
+
+; Tokens
+;-------
+
+(template_substitution
+  "${" @punctuation.special
+  "}" @punctuation.special) @embedded
+
+[
+  ";"
+  "?."
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "-"
+  "--"
+  "-="
+  "+"
+  "++"
+  "+="
+  "*"
+  "*="
+  "**"
+  "**="
+  "/"
+  "/="
+  "%"
+  "%="
+  "<"
+  "<="
+  "<<"
+  "<<="
+  "="
+  "=="
+  "==="
+  "!"
+  "!="
+  "!=="
+  "=>"
+  ">"
+  ">="
+  ">>"
+  ">>="
+  ">>>"
+  ">>>="
+  "~"
+  "^"
+  "&"
+  "|"
+  "^="
+  "&="
+  "|="
+  "&&"
+  "||"
+  "??"
+  "&&="
+  "||="
+  "??="
+  "..."
+] @operator
+
+(ternary_expression ["?" ":"] @operator)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+]  @punctuation.bracket
+
+[
+  "as"
+  "async"
+  "debugger"
+  "delete"
+  "extends"
+  "function"
+  "get"
+  "in"
+  "instanceof"
+  "new"
+  "of"
+  "set"
+  "static"
+  "target"
+  "try"
+  "typeof"
+  "void"
+  "with"
+] @keyword
+
+[
+  "class"
+  "let"
+  "const"
+  "var"
+] @keyword.storage.type
+
+[
+  "switch"
+  "case"
+  "if"
+  "else"
+  "yield"
+  "throw"
+  "finally"
+  "return"
+  "catch"
+  "continue"
+  "while"
+  "break"
+  "for"
+  "do"
+  "await"
+] @keyword.control
+
+[
+  "import"
+  "default"
+  "from"
+  "export"
+] @keyword.control.import 
+
+; Types
+
+(type_identifier) @type
+(predefined_type) @type.builtin
+
+(type_arguments
+  "<" @punctuation.bracket
+  ">" @punctuation.bracket)
+
+((identifier) @type
+ (#match? @type "^[A-Z]"))
\ No newline at end of file
diff --git a/lapce-core/queries/zig/highlights.scm b/lapce-core/queries/zig/highlights.scm
new file mode 100644
index 0000000000..3bb5f685cd
--- /dev/null
+++ b/lapce-core/queries/zig/highlights.scm
@@ -0,0 +1,232 @@
+; source: https://github.com/helix-editor/helix/blob/master/runtime/queries/zig/highlights.scm
+; licence: https://github.com/helix-editor/helix/blob/master/LICENSE
+; spdx: MPL-2.0
+
+[
+  (container_doc_comment)
+  (doc_comment)
+] @comment.documentation
+
+[
+  (line_comment)
+] @comment.line
+
+;; assume TitleCase is a type
+(
+  [
+    variable_type_function: (IDENTIFIER)
+    field_access: (IDENTIFIER)
+    parameter: (IDENTIFIER)
+  ] @type
+  (#match? @type "^[A-Z]([a-z]+[A-Za-z0-9]*)*$")
+)
+
+;; assume camelCase is a function
+(
+  [
+    variable_type_function: (IDENTIFIER)
+    field_access: (IDENTIFIER)
+    parameter: (IDENTIFIER)
+  ] @function
+  (#match? @function "^[a-z]+([A-Z][a-z0-9]*)+$")
+)
+
+;; assume all CAPS_1 is a constant
+(
+  [
+    variable_type_function: (IDENTIFIER)
+    field_access: (IDENTIFIER)
+  ] @constant
+  (#match? @constant "^[A-Z][A-Z_0-9]+$")
+)
+
+;; _
+(
+  (IDENTIFIER) @variable.builtin
+  (#eq? @variable.builtin "_")
+)
+
+;; C Pointers [*c]T
+(PtrTypeStart "c" @variable.builtin)
+
+[
+  variable: (IDENTIFIER)
+  variable_type_function: (IDENTIFIER)
+] @variable
+
+parameter: (IDENTIFIER) @variable.parameter
+
+[
+  field_member: (IDENTIFIER)
+  field_access: (IDENTIFIER)
+] @variable.other.member
+
+[
+  function_call: (IDENTIFIER)
+  function: (IDENTIFIER)
+] @function
+
+exception: "!" @keyword.control.exception
+
+field_constant: (IDENTIFIER) @constant
+
+(BUILTINIDENTIFIER) @function.builtin
+
+((BUILTINIDENTIFIER) @keyword.control.import
+  (#any-of? @keyword.control.import "@import" "@cImport"))
+
+(INTEGER) @constant.numeric.integer
+
+(FLOAT) @constant.numeric.float
+
+[
+  (LINESTRING)
+  (STRINGLITERALSINGLE)
+] @string
+
+(CHAR_LITERAL) @constant.character
+(EscapeSequence) @constant.character.escape
+(FormatSequence) @string.special
+
+[
+  "anytype"
+  "anyframe"
+  (BuildinTypeExpr)
+] @type.builtin
+
+(BreakLabel (IDENTIFIER) @label)
+(BlockLabel (IDENTIFIER) @label)
+
+[
+  "true"
+  "false"
+] @constant.builtin.boolean
+
+[
+  "undefined"
+  "unreachable"
+  "null"
+] @constant.builtin
+
+[
+  "else"
+  "if"
+  "switch"
+] @keyword.control.conditional
+
+[
+  "for"
+  "while"
+] @keyword.control.repeat
+
+[
+  "or"
+  "and"
+  "orelse"
+] @keyword.operator
+
+[
+  "struct"
+  "enum"
+  "union"
+  "packed"
+  "opaque"
+  "export"
+  "extern"
+  "linksection"
+] @keyword.storage.type
+
+[
+  "const"
+  "var"
+  "threadlocal"
+  "allowzero"
+  "volatile"
+  "align"
+] @keyword.storage.modifier
+
+[
+  "try"
+  "error"
+  "catch"
+] @keyword.control.exception
+
+[
+  "fn"
+] @keyword.function
+
+[
+  "test"
+] @keyword
+
+[
+  "pub"
+  "usingnamespace"
+] @keyword.control.import
+
+[
+  "return"
+  "break"
+  "continue"
+] @keyword.control.return
+
+[
+  "defer"
+  "errdefer"
+  "async"
+  "nosuspend"
+  "await"
+  "suspend"
+  "resume"
+] @function.macro
+
+[
+  "comptime"
+  "inline"
+  "noinline"
+  "asm"
+  "callconv"
+  "noalias"
+] @keyword.directive
+
+[
+  (CompareOp)
+  (BitwiseOp)
+  (BitShiftOp)
+  (AdditionOp)
+  (AssignOp)
+  (MultiplyOp)
+  (PrefixOp)
+  "*"
+  "**"
+  "->"
+  ".?"
+  ".*"
+  "?"
+] @operator
+
+[
+  ";"
+  "."
+  ","
+  ":"
+] @punctuation.delimiter
+
+[
+  ".."
+  "..."
+] @punctuation.special
+
+[
+  "["
+  "]"
+  "("
+  ")"
+  "{"
+  "}"
+  (Payload "|")
+  (PtrPayload "|")
+  (PtrIndexPayload "|")
+] @punctuation.bracket
+
+(ERROR) @keyword.control.exception
\ No newline at end of file
diff --git a/lapce-core/src/buffer.rs b/lapce-core/src/buffer/mod.rs
similarity index 73%
rename from lapce-core/src/buffer.rs
rename to lapce-core/src/buffer/mod.rs
index f8cecba6f2..6b6f23ea2a 100644
--- a/lapce-core/src/buffer.rs
+++ b/lapce-core/src/buffer/mod.rs
@@ -9,23 +9,32 @@ use std::{
     },
 };
 
-use lsp_types::Position;
-use xi_rope::{
+use lapce_xi_rope::{
+    delta::InsertDelta,
     diff::{Diff, LineHashDiff},
-    multiset::Subset,
-    Cursor, Delta, DeltaBuilder, Interval, Rope, RopeDelta,
+    interval::IntervalBounds,
+    multiset::{CountMatcher, Subset},
+    tree::{Node, NodeInfo},
+    Cursor, Delta, DeltaBuilder, DeltaElement, Interval, Rope, RopeDelta, RopeInfo,
 };
+use lsp_types::Position;
 
 use crate::{
+    char_buffer::CharBuffer,
     cursor::CursorMode,
     editor::EditType,
     indent::{auto_detect_indent_style, IndentStyle},
     mode::Mode,
+    paragraph::ParagraphCursor,
     selection::Selection,
-    syntax::Syntax,
+    syntax::{self, edit::SyntaxEdit, Syntax},
     word::WordCursor,
 };
 
+pub mod rope_text;
+
+use rope_text::*;
+
 #[derive(Clone)]
 enum Contents {
     Edit {
@@ -90,6 +99,12 @@ pub struct Buffer {
     max_len_line: usize,
 }
 
+impl ToString for Buffer {
+    fn to_string(&self) -> String {
+        self.text().to_string()
+    }
+}
+
 impl Buffer {
     pub fn new(text: &str) -> Self {
         Self {
@@ -126,12 +141,14 @@ impl Buffer {
         }
     }
 
+    /// The current buffer revision
     pub fn rev(&self) -> u64 {
         self.revs.last().unwrap().num
     }
 
+    /// Mark the buffer as pristine (aka 'saved')
     pub fn set_pristine(&mut self) {
-        self.pristine_rev_id = self.rev()
+        self.pristine_rev_id = self.rev();
     }
 
     pub fn is_pristine(&self) -> bool {
@@ -179,14 +196,14 @@ impl Buffer {
     }
 
     pub fn num_lines(&self) -> usize {
-        self.line_of_offset(self.text.len()) + 1
+        RopeText::new(&self.text).num_lines()
     }
 
     fn get_max_line_len(&self) -> (usize, usize) {
         let mut pre_offset = 0;
         let mut max_len = 0;
         let mut max_len_line = 0;
-        for line in 0..self.num_lines() + 1 {
+        for line in 0..=self.num_lines() {
             let offset = self.offset_of_line(line);
             let line_len = offset - pre_offset;
             pre_offset = offset;
@@ -231,14 +248,14 @@ impl Buffer {
         self.max_len
     }
 
-    fn line_len(&self, line: usize) -> usize {
-        self.offset_of_line(line + 1) - self.offset_of_line(line)
+    pub fn line_len(&self, line: usize) -> usize {
+        RopeText::new(&self.text).line_len(line)
     }
 
     pub fn init_content(&mut self, content: Rope) {
         if !content.is_empty() {
             let delta = Delta::simple_edit(Interval::new(0, 0), content, 0);
-            let (new_rev, new_text, new_tombstones, new_deletes_from_union) =
+            let (new_rev, new_text, new_tombstones, new_deletes_from_union, _) =
                 self.mk_new_rev(0, delta.clone());
             self.apply_edit(
                 &delta,
@@ -255,14 +272,14 @@ impl Buffer {
         &mut self,
         content: Rope,
         set_pristine: bool,
-    ) -> (RopeDelta, InvalLines) {
+    ) -> (RopeDelta, InvalLines, SyntaxEdit) {
         let delta = LineHashDiff::compute_delta(&self.text, &content);
         self.this_edit_type = EditType::Other;
-        let (delta, inval_lines) = self.add_delta(delta);
+        let (delta, inval_lines, edits) = self.add_delta(delta);
         if set_pristine {
             self.set_pristine();
         }
-        (delta, inval_lines)
+        (delta, inval_lines, edits)
     }
 
     pub fn detect_indent(&mut self, syntax: Option<&Syntax>) {
@@ -279,14 +296,14 @@ impl Buffer {
     }
 
     pub fn reset_edit_type(&mut self) {
-        self.last_edit_type = EditType::Other
+        self.last_edit_type = EditType::Other;
     }
 
     pub fn edit(
         &mut self,
         edits: &[(impl AsRef<Selection>, &str)],
         edit_type: EditType,
-    ) -> (RopeDelta, InvalLines) {
+    ) -> (RopeDelta, InvalLines, SyntaxEdit) {
         let mut builder = DeltaBuilder::new(self.len());
         let mut interval_rope = Vec::new();
         for (selection, content) in edits {
@@ -312,11 +329,14 @@ impl Buffer {
         self.add_delta(delta)
     }
 
-    fn add_delta(&mut self, delta: RopeDelta) -> (RopeDelta, InvalLines) {
+    fn add_delta(
+        &mut self,
+        delta: RopeDelta,
+    ) -> (RopeDelta, InvalLines, SyntaxEdit) {
         let undo_group = self.calculate_undo_group();
         self.last_edit_type = self.this_edit_type;
 
-        let (new_rev, new_text, new_tombstones, new_deletes_from_union) =
+        let (new_rev, new_text, new_tombstones, new_deletes_from_union, edits) =
             self.mk_new_rev(undo_group, delta.clone());
 
         let inval_lines = self.apply_edit(
@@ -327,7 +347,7 @@ impl Buffer {
             new_deletes_from_union,
         );
 
-        (delta, inval_lines)
+        (delta, inval_lines, edits)
     }
 
     fn apply_edit(
@@ -380,13 +400,46 @@ impl Buffer {
         }
     }
 
+    fn generate_edits(
+        &self,
+        ins_delta: &InsertDelta<RopeInfo>,
+        deletes: &Subset,
+    ) -> SyntaxEdit {
+        let deletes = deletes.transform_expand(&ins_delta.inserted_subset());
+
+        let mut edits = Vec::new();
+
+        let mut insert_edits: Vec<tree_sitter::InputEdit> =
+            InsertsValueIter::new(ins_delta)
+                .map(|insert| {
+                    let start = insert.old_offset;
+                    let inserted = insert.node;
+                    syntax::edit::create_insert_edit(&self.text, start, inserted)
+                })
+                .collect();
+        insert_edits.reverse();
+        edits.append(&mut insert_edits);
+
+        let text = ins_delta.apply(&self.text);
+        let mut delete_edits: Vec<tree_sitter::InputEdit> = deletes
+            .range_iter(CountMatcher::NonZero)
+            .map(|(start, end)| syntax::edit::create_delete_edit(&text, start, end))
+            .collect();
+        delete_edits.reverse();
+        edits.append(&mut delete_edits);
+
+        SyntaxEdit::new(edits)
+    }
+
     fn mk_new_rev(
         &self,
         undo_group: usize,
         delta: RopeDelta,
-    ) -> (Revision, Rope, Rope, Subset) {
+    ) -> (Revision, Rope, Rope, Subset, SyntaxEdit) {
         let (ins_delta, deletes) = delta.factor();
 
+        let edits = self.generate_edits(&ins_delta, &deletes);
+
         let deletes_at_rev = &self.deletes_from_union;
 
         let union_ins_delta = ins_delta.transform_expand(deletes_at_rev, true);
@@ -416,7 +469,7 @@ impl Buffer {
             &new_deletes_from_union,
         );
 
-        let head_rev = &self.revs.last().unwrap();
+        let head_rev = self.revs.last().unwrap();
         self.atomic_rev
             .store(self.rev_counter, atomic::Ordering::Release);
         (
@@ -434,6 +487,7 @@ impl Buffer {
             new_text,
             new_tombstones,
             new_deletes_from_union,
+            edits,
         )
     }
 
@@ -567,7 +621,7 @@ impl Buffer {
                 Contents::Undo { .. } => None,
             })
             .and_then(|group| {
-                let mut cursor: Option<&CursorMode> = None;
+                let mut cursor = None;
                 for rev in &self.revs[first_candidate..] {
                     if let Contents::Edit { ref undo_group, .. } = rev.edit {
                         if group == undo_group {
@@ -605,6 +659,7 @@ impl Buffer {
     ) -> (
         RopeDelta,
         InvalLines,
+        SyntaxEdit,
         Option<CursorMode>,
         Option<CursorMode>,
     ) {
@@ -614,6 +669,10 @@ impl Buffer {
             &self.deletes_from_union,
             &new_deletes_from_union,
         );
+        let edits = {
+            let (ins_delta, deletes) = delta.clone().factor();
+            self.generate_edits(&ins_delta, &deletes)
+        };
         let new_text = delta.apply(&self.text);
         let new_tombstones = shuffle_tombstones(
             &self.text,
@@ -634,154 +693,100 @@ impl Buffer {
             new_deletes_from_union,
         );
 
-        (delta, inval_lines, cursor_before, cursor_after)
+        (delta, inval_lines, edits, cursor_before, cursor_after)
     }
 
     pub fn do_undo(
         &mut self,
-    ) -> Option<(RopeDelta, InvalLines, Option<CursorMode>)> {
-        if self.cur_undo > 1 {
-            self.cur_undo -= 1;
-            self.undos.insert(self.live_undos[self.cur_undo]);
-            self.last_edit_type = EditType::Undo;
-            let (delta, inval_lines, cursor_before, _cursor_after) =
-                self.undo(self.undos.clone());
-            Some((delta, inval_lines, cursor_before))
-        } else {
-            None
+    ) -> Option<(RopeDelta, InvalLines, SyntaxEdit, Option<CursorMode>)> {
+        if self.cur_undo <= 1 {
+            return None;
         }
+
+        self.cur_undo -= 1;
+        self.undos.insert(self.live_undos[self.cur_undo]);
+        self.last_edit_type = EditType::Undo;
+        let (delta, inval_lines, edits, cursor_before, _cursor_after) =
+            self.undo(self.undos.clone());
+
+        Some((delta, inval_lines, edits, cursor_before))
     }
 
     pub fn do_redo(
         &mut self,
-    ) -> Option<(RopeDelta, InvalLines, Option<CursorMode>)> {
-        if self.cur_undo < self.live_undos.len() {
-            self.undos.remove(&self.live_undos[self.cur_undo]);
-            self.cur_undo += 1;
-            self.last_edit_type = EditType::Redo;
-            let (delta, inval_lines, _cursor_before, cursor_after) =
-                self.undo(self.undos.clone());
-            Some((delta, inval_lines, cursor_after))
-        } else {
-            None
+    ) -> Option<(RopeDelta, InvalLines, SyntaxEdit, Option<CursorMode>)> {
+        if self.cur_undo >= self.live_undos.len() {
+            return None;
         }
+
+        self.undos.remove(&self.live_undos[self.cur_undo]);
+        self.cur_undo += 1;
+        self.last_edit_type = EditType::Redo;
+        let (delta, inval_lines, edits, _cursor_before, cursor_after) =
+            self.undo(self.undos.clone());
+
+        Some((delta, inval_lines, edits, cursor_after))
+    }
+
+    pub fn rope_text(&self) -> RopeText {
+        RopeText::new(&self.text)
     }
 
     pub fn last_line(&self) -> usize {
-        self.line_of_offset(self.text.len())
+        RopeText::new(&self.text).last_line()
     }
 
     pub fn offset_of_line(&self, line: usize) -> usize {
-        let last_line = self.last_line();
-        let line = if line > last_line + 1 {
-            last_line + 1
-        } else {
-            line
-        };
-        self.text.offset_of_line(line)
+        RopeText::new(&self.text).offset_of_line(line)
     }
 
     pub fn offset_line_end(&self, offset: usize, caret: bool) -> usize {
-        let line = self.line_of_offset(offset);
-        self.line_end_offset(line, caret)
+        RopeText::new(&self.text).offset_line_end(offset, caret)
     }
 
     pub fn line_of_offset(&self, offset: usize) -> usize {
-        let max = self.len();
-        let offset = if offset > max { max } else { offset };
-        self.text.line_of_offset(offset)
+        RopeText::new(&self.text).line_of_offset(offset)
     }
 
+    /// Converts a UTF8 offset to a UTF16 LSP position
     pub fn offset_to_position(&self, offset: usize) -> Position {
-        let (line, col) = self.offset_to_line_col(offset);
-        Position {
-            line: line as u32,
-            character: col as u32,
-        }
+        RopeText::new(&self.text).offset_to_position(offset)
     }
 
     pub fn offset_of_position(&self, pos: &Position) -> usize {
-        self.offset_of_line_col(pos.line as usize, pos.character as usize)
+        RopeText::new(&self.text).offset_of_position(pos)
     }
 
-    pub fn offset_to_line_col(&self, offset: usize) -> (usize, usize) {
-        let max = self.len();
-        let offset = if offset > max { max } else { offset };
-        let line = self.line_of_offset(offset);
-        let line_start = self.offset_of_line(line);
-        if offset == line_start {
-            return (line, 0);
-        }
+    pub fn position_to_line_col(&self, pos: &Position) -> (usize, usize) {
+        RopeText::new(&self.text).position_to_line_col(pos)
+    }
 
-        let col = offset - line_start;
-        (line, col)
+    pub fn offset_to_line_col(&self, offset: usize) -> (usize, usize) {
+        RopeText::new(&self.text).offset_to_line_col(offset)
     }
 
     pub fn offset_of_line_col(&self, line: usize, col: usize) -> usize {
-        let mut pos = 0;
-        let mut offset = self.offset_of_line(line);
-        for c in self
-            .slice_to_cow(offset..self.offset_of_line(line + 1))
-            .chars()
-        {
-            if c == '\n' {
-                return offset;
-            }
-
-            let char_len = c.len_utf8();
-            if pos + char_len > col {
-                return offset;
-            }
-            pos += char_len;
-            offset += char_len;
-        }
-        offset
+        RopeText::new(&self.text).offset_of_line_col(line, col)
     }
 
     pub fn line_end_col(&self, line: usize, caret: bool) -> usize {
-        let line_start = self.offset_of_line(line);
-        let offset = self.line_end_offset(line, caret);
-        offset - line_start
+        RopeText::new(&self.text).line_end_col(line, caret)
     }
 
     pub fn first_non_blank_character_on_line(&self, line: usize) -> usize {
-        let last_line = self.last_line();
-        let line = if line > last_line + 1 {
-            last_line
-        } else {
-            line
-        };
-        let line_start_offset = self.text.offset_of_line(line);
-        WordCursor::new(&self.text, line_start_offset).next_non_blank_char()
+        RopeText::new(&self.text).first_non_blank_character_on_line(line)
     }
 
     pub fn indent_on_line(&self, line: usize) -> String {
-        let line_start_offset = self.text.offset_of_line(line);
-        let word_boundary =
-            WordCursor::new(&self.text, line_start_offset).next_non_blank_char();
-        let indent = self.text.slice_to_cow(line_start_offset..word_boundary);
-        indent.to_string()
+        RopeText::new(&self.text).indent_on_line(line)
     }
 
     pub fn line_end_offset(&self, line: usize, caret: bool) -> usize {
-        let mut offset = self.offset_of_line(line + 1);
-        let mut line_content: &str = &self.line_content(line);
-        if line_content.ends_with("\r\n") {
-            offset -= 2;
-            line_content = &line_content[..line_content.len() - 2];
-        } else if line_content.ends_with('\n') {
-            offset -= 1;
-            line_content = &line_content[..line_content.len() - 1];
-        }
-        if !caret && !line_content.is_empty() {
-            offset = self.prev_grapheme_offset(offset, 1, 0);
-        }
-        offset
+        RopeText::new(&self.text).line_end_offset(line, caret)
     }
 
     pub fn line_content(&self, line: usize) -> Cow<str> {
-        self.text
-            .slice_to_cow(self.offset_of_line(line)..self.offset_of_line(line + 1))
+        RopeText::new(&self.text).line_content(line)
     }
 
     pub fn prev_grapheme_offset(
@@ -790,20 +795,7 @@ impl Buffer {
         count: usize,
         limit: usize,
     ) -> usize {
-        let mut cursor = Cursor::new(&self.text, offset);
-        let mut new_offset = offset;
-        for _i in 0..count {
-            if let Some(prev_offset) = cursor.prev_grapheme() {
-                if prev_offset < limit {
-                    return new_offset;
-                }
-                new_offset = prev_offset;
-                cursor.set(prev_offset);
-            } else {
-                return new_offset;
-            }
-        }
-        new_offset
+        RopeText::new(&self.text).prev_grapheme_offset(offset, count, limit)
     }
 
     pub fn prev_code_boundary(&self, offset: usize) -> usize {
@@ -815,24 +807,20 @@ impl Buffer {
     }
 
     pub fn move_left(&self, offset: usize, mode: Mode, count: usize) -> usize {
-        let line = self.line_of_offset(offset);
-        let line_start_offset = self.offset_of_line(line);
         let min_offset = if mode == Mode::Insert {
             0
         } else {
-            line_start_offset
+            let line = self.line_of_offset(offset);
+            self.offset_of_line(line)
         };
-
         self.prev_grapheme_offset(offset, count, min_offset)
     }
 
     pub fn move_right(&self, offset: usize, mode: Mode, count: usize) -> usize {
-        let line_end = self.offset_line_end(offset, mode != Mode::Normal);
-
         let max_offset = if mode == Mode::Insert {
             self.len()
         } else {
-            line_end
+            self.offset_line_end(offset, mode != Mode::Normal)
         };
 
         self.next_grapheme_offset(offset, count, max_offset)
@@ -842,8 +830,8 @@ impl Buffer {
         self.move_n_words_forward(offset, 1)
     }
 
-    pub fn move_word_backward(&self, offset: usize) -> usize {
-        self.move_n_words_backward(offset, 1)
+    pub fn move_word_backward(&self, offset: usize, mode: Mode) -> usize {
+        self.move_n_words_backward(offset, 1, mode)
     }
 
     pub fn next_grapheme_offset(
@@ -885,6 +873,7 @@ impl Buffer {
         if self.is_empty() {
             return None;
         }
+        let offset = offset.min(self.len());
         WordCursor::new(&self.text, offset)
             .inner
             .peek_next_codepoint()
@@ -897,21 +886,65 @@ impl Buffer {
         offset: usize,
     ) -> Option<usize> {
         if let Some(syntax) = syntax {
-            syntax.find_tag(offset, true, &c.to_string())
+            syntax.find_tag(offset, true, &CharBuffer::new(c))
         } else {
             WordCursor::new(&self.text, offset).previous_unmatched(c)
         }
     }
 
+    /// Get the content of the rope as a Cow string, for 'nice' ranges (small, and at the right
+    /// offsets) this will be a reference to the rope's data. Otherwise, it allocates a new string.
+    /// You should be somewhat wary of requesting large parts of the rope, as it will allocate
+    /// a new string since it isn't contiguous in memory for large chunks.
     pub fn slice_to_cow(&self, range: Range<usize>) -> Cow<str> {
         self.text
             .slice_to_cow(range.start.min(self.len())..range.end.min(self.len()))
     }
 
+    /// Iterate over (utf8_offset, char) values in the given range  
+    /// This uses `iter_chunks` and so does not allocate, compared to `slice_to_cow` which can
+    pub fn char_indices_iter<T: IntervalBounds>(
+        &self,
+        range: T,
+    ) -> impl Iterator<Item = (usize, char)> + '_ {
+        CharIndicesJoin::new(self.text.iter_chunks(range).map(str::char_indices))
+    }
+
     pub fn len(&self) -> usize {
         self.text.len()
     }
 
+    fn find_nth_paragraph<F>(
+        &self,
+        offset: usize,
+        mut count: usize,
+        mut find_next: F,
+    ) -> usize
+    where
+        F: FnMut(&mut ParagraphCursor) -> Option<usize>,
+    {
+        let mut cursor = ParagraphCursor::new(self.text(), offset);
+        let mut new_offset = offset;
+        while count != 0 {
+            // FIXME: wait for if-let-chain
+            if let Some(offset) = find_next(&mut cursor) {
+                new_offset = offset;
+            } else {
+                break;
+            }
+            count -= 1;
+        }
+        new_offset
+    }
+
+    pub fn move_n_paragraphs_forward(&self, offset: usize, count: usize) -> usize {
+        self.find_nth_paragraph(offset, count, |cursor| cursor.next_boundary())
+    }
+
+    pub fn move_n_paragraphs_backward(&self, offset: usize, count: usize) -> usize {
+        self.find_nth_paragraph(offset, count, |cursor| cursor.prev_boundary())
+    }
+
     /// Find the nth (`count`) word starting at `offset` in either direction
     /// depending on `find_next`.
     ///
@@ -960,8 +993,17 @@ impl Buffer {
         new_offset
     }
 
-    pub fn move_n_words_backward(&self, offset: usize, count: usize) -> usize {
-        self.find_nth_word(offset, count, |cursor| cursor.prev_boundary())
+    pub fn move_n_words_backward(
+        &self,
+        offset: usize,
+        count: usize,
+        mode: Mode,
+    ) -> usize {
+        self.find_nth_word(offset, count, |cursor| cursor.prev_boundary(mode))
+    }
+
+    pub fn move_word_backward_deletion(&self, offset: usize) -> usize {
+        self.find_nth_word(offset, 1, |cursor| cursor.prev_deletion_boundary())
     }
 }
 
@@ -1006,14 +1048,14 @@ fn shuffle(
     )
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum DiffResult<T> {
     Left(T),
     Both(T, T),
     Right(T),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum DiffLines {
     Left(Range<usize>),
     Both(Range<usize>, Range<usize>),
@@ -1026,6 +1068,7 @@ pub fn rope_diff(
     right_rope: Rope,
     rev: u64,
     atomic_rev: Arc<AtomicU64>,
+    context_lines: Option<usize>,
 ) -> Option<Vec<DiffLines>> {
     let left_lines = left_rope.lines(..).collect::<Vec<Cow<str>>>();
     let right_lines = right_rope.lines(..).collect::<Vec<Cow<str>>>();
@@ -1154,58 +1197,118 @@ pub fn rope_diff(
             right_count - trailing_equals..right_count,
         ));
     }
-    if !changes.is_empty() {
-        let changes_last = changes.len() - 1;
-        for (i, change) in changes.clone().iter().enumerate().rev() {
-            if atomic_rev.load(atomic::Ordering::Acquire) != rev {
-                return None;
-            }
-            if let DiffLines::Both(l, r) = change {
-                if i == 0 || i == changes_last {
-                    if r.len() > 3 {
-                        if i == 0 {
-                            changes[i] =
-                                DiffLines::Both(l.end - 3..l.end, r.end - 3..r.end);
-                            changes.insert(
-                                i,
-                                DiffLines::Skip(
-                                    l.start..l.end - 3,
-                                    r.start..r.end - 3,
-                                ),
-                            );
-                        } else {
-                            changes[i] = DiffLines::Skip(
-                                l.start + 3..l.end,
-                                r.start + 3..r.end,
-                            );
-                            changes.insert(
-                                i,
-                                DiffLines::Both(
-                                    l.start..l.start + 3,
-                                    r.start..r.start + 3,
-                                ),
-                            );
+    if let Some(context_lines) = context_lines {
+        if !changes.is_empty() {
+            let changes_last = changes.len() - 1;
+            for (i, change) in changes.clone().iter().enumerate().rev() {
+                if atomic_rev.load(atomic::Ordering::Acquire) != rev {
+                    return None;
+                }
+                if let DiffLines::Both(l, r) = change {
+                    if i == 0 || i == changes_last {
+                        if r.len() > context_lines {
+                            if i == 0 {
+                                changes[i] = DiffLines::Both(
+                                    l.end - context_lines..l.end,
+                                    r.end - context_lines..r.end,
+                                );
+                                changes.insert(
+                                    i,
+                                    DiffLines::Skip(
+                                        l.start..l.end - context_lines,
+                                        r.start..r.end - context_lines,
+                                    ),
+                                );
+                            } else {
+                                changes[i] = DiffLines::Skip(
+                                    l.start + context_lines..l.end,
+                                    r.start + context_lines..r.end,
+                                );
+                                changes.insert(
+                                    i,
+                                    DiffLines::Both(
+                                        l.start..l.start + context_lines,
+                                        r.start..r.start + context_lines,
+                                    ),
+                                );
+                            }
                         }
+                    } else if r.len() > context_lines * 2 {
+                        changes[i] = DiffLines::Both(
+                            l.end - context_lines..l.end,
+                            r.end - context_lines..r.end,
+                        );
+                        changes.insert(
+                            i,
+                            DiffLines::Skip(
+                                l.start + context_lines..l.end - context_lines,
+                                r.start + context_lines..r.end - context_lines,
+                            ),
+                        );
+                        changes.insert(
+                            i,
+                            DiffLines::Both(
+                                l.start..l.start + context_lines,
+                                r.start..r.start + context_lines,
+                            ),
+                        );
                     }
-                } else if r.len() > 6 {
-                    changes[i] = DiffLines::Both(l.end - 3..l.end, r.end - 3..r.end);
-                    changes.insert(
-                        i,
-                        DiffLines::Skip(
-                            l.start + 3..l.end - 3,
-                            r.start + 3..r.end - 3,
-                        ),
-                    );
-                    changes.insert(
-                        i,
-                        DiffLines::Both(l.start..l.start + 3, r.start..r.start + 3),
-                    );
                 }
             }
         }
     }
+
     Some(changes)
 }
 
+pub struct DeltaValueRegion<'a, N: NodeInfo + 'a> {
+    pub old_offset: usize,
+    pub new_offset: usize,
+    pub len: usize,
+    pub node: &'a Node<N>,
+}
+
+/// Modified version of `xi_rope::delta::InsertsIter` which includes the node
+pub struct InsertsValueIter<'a, N: NodeInfo + 'a> {
+    pos: usize,
+    last_end: usize,
+    els_iter: std::slice::Iter<'a, DeltaElement<N>>,
+}
+impl<'a, N: NodeInfo + 'a> InsertsValueIter<'a, N> {
+    pub fn new(delta: &'a Delta<N>) -> InsertsValueIter<'a, N> {
+        InsertsValueIter {
+            pos: 0,
+            last_end: 0,
+            els_iter: delta.els.iter(),
+        }
+    }
+}
+impl<'a, N: NodeInfo> Iterator for InsertsValueIter<'a, N> {
+    type Item = DeltaValueRegion<'a, N>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        for elem in &mut self.els_iter {
+            match *elem {
+                DeltaElement::Copy(b, e) => {
+                    self.pos += e - b;
+                    self.last_end = e;
+                }
+                DeltaElement::Insert(ref n) => {
+                    let result = Some(DeltaValueRegion {
+                        old_offset: self.last_end,
+                        new_offset: self.pos,
+                        len: n.len(),
+                        node: n,
+                    });
+                    self.pos += n.len();
+                    self.last_end += n.len();
+                    return result;
+                }
+            }
+        }
+        None
+    }
+}
+
 #[cfg(test)]
 mod test;
diff --git a/lapce-core/src/buffer/rope_text.rs b/lapce-core/src/buffer/rope_text.rs
new file mode 100644
index 0000000000..0a67c32285
--- /dev/null
+++ b/lapce-core/src/buffer/rope_text.rs
@@ -0,0 +1,461 @@
+use std::{borrow::Cow, ops::Range};
+
+use lapce_xi_rope::{interval::IntervalBounds, Cursor, Rope};
+use lsp_types::Position;
+
+use crate::{
+    encoding::{offset_utf16_to_utf8, offset_utf8_to_utf16},
+    word::WordCursor,
+};
+
+/// A wrapper around a rope that provides utility functions atop it.
+pub struct RopeText<'a> {
+    text: &'a Rope,
+}
+
+impl<'a> RopeText<'a> {
+    pub fn new(text: &'a Rope) -> Self {
+        Self { text }
+    }
+
+    pub fn len(&self) -> usize {
+        self.text.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// The last line of the held rope
+    pub fn last_line(&self) -> usize {
+        self.line_of_offset(self.len())
+    }
+
+    /// Get the offset into the rope of the start of the given line.  
+    /// If the line it out of bounds, then the last offset (the len) is returned.
+    pub fn offset_of_line(&self, line: usize) -> usize {
+        let last_line = self.last_line();
+        let line = line.min(last_line + 1);
+        self.text.offset_of_line(line)
+    }
+
+    pub fn offset_line_end(&self, offset: usize, caret: bool) -> usize {
+        let line = self.line_of_offset(offset);
+        self.line_end_offset(line, caret)
+    }
+
+    pub fn line_of_offset(&self, offset: usize) -> usize {
+        let offset = offset.min(self.len());
+        let offset = self
+            .text
+            .at_or_prev_codepoint_boundary(offset)
+            .unwrap_or(offset);
+
+        self.text.line_of_offset(offset)
+    }
+
+    /// Converts a UTF8 offset to a UTF16 LSP position  
+    /// Returns None if it is not a valid UTF16 offset
+    pub fn offset_to_position(&self, offset: usize) -> Position {
+        let (line, col) = self.offset_to_line_col(offset);
+        let line_offset = self.offset_of_line(line);
+
+        let utf16_col =
+            offset_utf8_to_utf16(self.char_indices_iter(line_offset..), col);
+
+        Position {
+            line: line as u32,
+            character: utf16_col as u32,
+        }
+    }
+
+    pub fn offset_of_position(&self, pos: &Position) -> usize {
+        let (line, column) = self.position_to_line_col(pos);
+
+        self.offset_of_line_col(line, column)
+    }
+
+    pub fn position_to_line_col(&self, pos: &Position) -> (usize, usize) {
+        let line = pos.line as usize;
+        let line_offset = self.offset_of_line(line);
+
+        let column = offset_utf16_to_utf8(
+            self.char_indices_iter(line_offset..),
+            pos.character as usize,
+        );
+
+        (line, column)
+    }
+
+    pub fn offset_to_line_col(&self, offset: usize) -> (usize, usize) {
+        let offset = offset.min(self.len());
+        let line = self.line_of_offset(offset);
+        let line_start = self.offset_of_line(line);
+        if offset == line_start {
+            return (line, 0);
+        }
+
+        let col = offset - line_start;
+        (line, col)
+    }
+
+    pub fn offset_of_line_col(&self, line: usize, col: usize) -> usize {
+        let mut pos = 0;
+        let mut offset = self.offset_of_line(line);
+        for c in self
+            .slice_to_cow(offset..self.offset_of_line(line + 1))
+            .chars()
+        {
+            if c == '\n' {
+                return offset;
+            }
+
+            let char_len = c.len_utf8();
+            if pos + char_len > col {
+                return offset;
+            }
+            pos += char_len;
+            offset += char_len;
+        }
+        offset
+    }
+
+    pub fn line_end_col(&self, line: usize, caret: bool) -> usize {
+        let line_start = self.offset_of_line(line);
+        let offset = self.line_end_offset(line, caret);
+        offset - line_start
+    }
+
+    /// Get the offset of the end of the line. The caret decides whether it is after the last
+    /// character, or before it.  
+    /// If the line is out of bounds, then the last offset (the len) is returned.
+    /// ```rust,ignore
+    /// let text = Rope::from("hello\nworld");
+    /// let text = RopeText::new(&text);
+    /// assert_eq!(text.line_end_offset(0, false), 4);  // "hell|o"
+    /// assert_eq!(text.line_end_offset(0, true), 5);   // "hello|"
+    /// assert_eq!(text.line_end_offset(1, false), 10); // "worl|d"
+    /// assert_eq!(text.line_end_offset(1, true), 11);  // "world|"
+    /// // Out of bounds
+    /// assert_eq!(text.line_end_offset(2, false), 11); // "world|"
+    /// ```
+    pub fn line_end_offset(&self, line: usize, caret: bool) -> usize {
+        let mut offset = self.offset_of_line(line + 1);
+        let mut line_content: &str = &self.line_content(line);
+        if line_content.ends_with("\r\n") {
+            offset -= 2;
+            line_content = &line_content[..line_content.len() - 2];
+        } else if line_content.ends_with('\n') {
+            offset -= 1;
+            line_content = &line_content[..line_content.len() - 1];
+        }
+        if !caret && !line_content.is_empty() {
+            offset = self.prev_grapheme_offset(offset, 1, 0);
+        }
+        offset
+    }
+
+    /// Returns the content of the given line.
+    /// Includes the line ending if it exists. (-> the last line won't have a line ending)    
+    /// Lines past the end of the document will return an empty string.
+    pub fn line_content(&self, line: usize) -> Cow<'a, str> {
+        self.text
+            .slice_to_cow(self.offset_of_line(line)..self.offset_of_line(line + 1))
+    }
+
+    /// Get the offset of the previous grapheme cluster.
+    pub fn prev_grapheme_offset(
+        &self,
+        offset: usize,
+        count: usize,
+        limit: usize,
+    ) -> usize {
+        let offset = offset.min(self.len());
+        let mut cursor = Cursor::new(self.text, offset);
+        let mut new_offset = offset;
+        for _i in 0..count {
+            if let Some(prev_offset) = cursor.prev_grapheme() {
+                if prev_offset < limit {
+                    return new_offset;
+                }
+                new_offset = prev_offset;
+                cursor.set(prev_offset);
+            } else {
+                return new_offset;
+            }
+        }
+        new_offset
+    }
+
+    /// Returns the offset of the first non-blank character on the given line.  
+    /// If the line is one past the last line, then the offset at the end of the rope is returned.
+    /// If the line is further past that, then it defaults to the last line.
+    pub fn first_non_blank_character_on_line(&self, line: usize) -> usize {
+        let last_line = self.last_line();
+        let line = if line > last_line + 1 {
+            last_line
+        } else {
+            line
+        };
+        let line_start_offset = self.text.offset_of_line(line);
+        WordCursor::new(self.text, line_start_offset).next_non_blank_char()
+    }
+
+    pub fn indent_on_line(&self, line: usize) -> String {
+        let line_start_offset = self.text.offset_of_line(line);
+        let word_boundary =
+            WordCursor::new(self.text, line_start_offset).next_non_blank_char();
+        let indent = self.text.slice_to_cow(line_start_offset..word_boundary);
+        indent.to_string()
+    }
+
+    /// Get the content of the rope as a Cow string, for 'nice' ranges (small, and at the right
+    /// offsets) this will be a reference to the rope's data. Otherwise, it allocates a new string.
+    /// You should be somewhat wary of requesting large parts of the rope, as it will allocate
+    /// a new string since it isn't contiguous in memory for large chunks.
+    pub fn slice_to_cow(&self, range: Range<usize>) -> Cow<'a, str> {
+        self.text
+            .slice_to_cow(range.start.min(self.len())..range.end.min(self.len()))
+    }
+
+    /// Iterate over (utf8_offset, char) values in the given range  
+    /// This uses `iter_chunks` and so does not allocate, compared to `slice_to_cow` which can
+    pub fn char_indices_iter<T: IntervalBounds>(
+        &self,
+        range: T,
+    ) -> impl Iterator<Item = (usize, char)> + 'a {
+        CharIndicesJoin::new(self.text.iter_chunks(range).map(str::char_indices))
+    }
+
+    /// The number of lines in the file
+    pub fn num_lines(&self) -> usize {
+        self.last_line() + 1
+    }
+
+    /// The length of the given line
+    pub fn line_len(&self, line: usize) -> usize {
+        self.offset_of_line(line + 1) - self.offset_of_line(line)
+    }
+}
+
+/// Joins an iterator of iterators over char indices `(usize, char)` into one
+/// as if they were from a single long string
+/// Assumes the iterators end after the first `None` value
+#[derive(Clone)]
+pub struct CharIndicesJoin<I: Iterator<Item = (usize, char)>, O: Iterator<Item = I>>
+{
+    /// Our iterator of iterators
+    main_iter: O,
+    /// Our current working iterator of indices
+    current_indices: Option<I>,
+    /// The amount we should shift future offsets
+    current_base: usize,
+    /// The latest base, since we don't know when the `current_indices` iterator will end
+    latest_base: usize,
+}
+
+impl<I: Iterator<Item = (usize, char)>, O: Iterator<Item = I>>
+    CharIndicesJoin<I, O>
+{
+    pub fn new(main_iter: O) -> CharIndicesJoin<I, O> {
+        CharIndicesJoin {
+            main_iter,
+            current_indices: None,
+            current_base: 0,
+            latest_base: 0,
+        }
+    }
+}
+
+impl<I: Iterator<Item = (usize, char)>, O: Iterator<Item = I>> Iterator
+    for CharIndicesJoin<I, O>
+{
+    type Item = (usize, char);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(current) = &mut self.current_indices {
+            if let Some((next_offset, next_ch)) = current.next() {
+                // Shift by the current base offset, which is the accumulated offset from previous
+                // iterators, which makes so the offset produced looks like it is from one long str
+                let next_offset = self.current_base + next_offset;
+                // Store the latest base offset, because we don't know when the current iterator
+                // will end (though technically the str iterator impl does)
+                self.latest_base = next_offset + next_ch.len_utf8();
+                return Some((next_offset, next_ch));
+            }
+        }
+
+        // Otherwise, if we didn't return something above, then we get a next iterator
+        if let Some(next_current) = self.main_iter.next() {
+            // Update our current working iterator
+            self.current_indices = Some(next_current);
+            // Update the current base offset with the previous iterators latest offset base
+            // This is what we are shifting by
+            self.current_base = self.latest_base;
+
+            // Get the next item without new current iterator
+            // As long as main_iter and the iterators it produces aren't infinite then this
+            // recursion won't be infinite either
+            // and even the non-recursion version would be infinite if those were infinite
+            self.next()
+        } else {
+            // We didn't get anything from the main iter, so we're completely done.
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use lapce_xi_rope::Rope;
+
+    use super::RopeText;
+
+    #[test]
+    fn test_line_content() {
+        let text = Rope::from("");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.line_content(0), "");
+        assert_eq!(text.line_content(1), "");
+        assert_eq!(text.line_content(2), "");
+
+        let text = Rope::from("abc\ndef\nghi");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.line_content(0), "abc\n");
+        assert_eq!(text.line_content(1), "def\n");
+        assert_eq!(text.line_content(2), "ghi");
+        assert_eq!(text.line_content(3), "");
+        assert_eq!(text.line_content(4), "");
+        assert_eq!(text.line_content(5), "");
+
+        let text = Rope::from("abc\r\ndef\r\nghi");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.line_content(0), "abc\r\n");
+        assert_eq!(text.line_content(1), "def\r\n");
+        assert_eq!(text.line_content(2), "ghi");
+        assert_eq!(text.line_content(3), "");
+        assert_eq!(text.line_content(4), "");
+        assert_eq!(text.line_content(5), "");
+    }
+
+    #[test]
+    fn test_offset_of_line() {
+        let text = Rope::from("");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.offset_of_line(0), 0);
+        assert_eq!(text.offset_of_line(1), 0);
+        assert_eq!(text.offset_of_line(2), 0);
+
+        let text = Rope::from("abc\ndef\nghi");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.offset_of_line(0), 0);
+        assert_eq!(text.offset_of_line(1), 4);
+        assert_eq!(text.offset_of_line(2), 8);
+        assert_eq!(text.offset_of_line(3), text.len()); // 11
+        assert_eq!(text.offset_of_line(4), text.len());
+        assert_eq!(text.offset_of_line(5), text.len());
+
+        let text = Rope::from("abc\r\ndef\r\nghi");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.offset_of_line(0), 0);
+        assert_eq!(text.offset_of_line(1), 5);
+        assert_eq!(text.offset_of_line(2), 10);
+        assert_eq!(text.offset_of_line(3), text.len()); // 13
+        assert_eq!(text.offset_of_line(4), text.len());
+        assert_eq!(text.offset_of_line(5), text.len());
+    }
+
+    #[test]
+    fn test_line_end_offset() {
+        let text = Rope::from("");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.line_end_offset(0, false), 0);
+        assert_eq!(text.line_end_offset(0, true), 0);
+        assert_eq!(text.line_end_offset(1, false), 0);
+        assert_eq!(text.line_end_offset(1, true), 0);
+        assert_eq!(text.line_end_offset(2, false), 0);
+        assert_eq!(text.line_end_offset(2, true), 0);
+
+        let text = Rope::from("abc\ndef\nghi");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.line_end_offset(0, false), 2);
+        assert_eq!(text.line_end_offset(0, true), 3);
+        assert_eq!(text.line_end_offset(1, false), 6);
+        assert_eq!(text.line_end_offset(1, true), 7);
+        assert_eq!(text.line_end_offset(2, false), 10);
+        assert_eq!(text.line_end_offset(2, true), text.len());
+        assert_eq!(text.line_end_offset(3, false), text.len());
+        assert_eq!(text.line_end_offset(3, true), text.len());
+        assert_eq!(text.line_end_offset(4, false), text.len());
+        assert_eq!(text.line_end_offset(4, true), text.len());
+
+        // This is equivalent to the doc test for RopeText::line_end_offset
+        // because you don't seem to be able to do a `use RopeText` in a doc test since it isn't
+        // public..
+        let text = Rope::from("hello\nworld");
+        let text = RopeText::new(&text);
+        assert_eq!(text.line_end_offset(0, false), 4); // "hell|o"
+        assert_eq!(text.line_end_offset(0, true), 5); // "hello|"
+        assert_eq!(text.line_end_offset(1, false), 10); // "worl|d"
+        assert_eq!(text.line_end_offset(1, true), 11); // "world|"
+                                                       // Out of bounds
+        assert_eq!(text.line_end_offset(2, false), 11); // "world|"
+    }
+
+    #[test]
+    fn test_prev_grapheme_offset() {
+        let text = Rope::from("");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.prev_grapheme_offset(0, 0, 0), 0);
+        assert_eq!(text.prev_grapheme_offset(0, 1, 0), 0);
+        assert_eq!(text.prev_grapheme_offset(0, 1, 1), 0);
+
+        let text = Rope::from("abc def ghi");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.prev_grapheme_offset(0, 0, 0), 0);
+        assert_eq!(text.prev_grapheme_offset(0, 1, 0), 0);
+        assert_eq!(text.prev_grapheme_offset(0, 1, 1), 0);
+        assert_eq!(text.prev_grapheme_offset(2, 1, 0), 1);
+        assert_eq!(text.prev_grapheme_offset(2, 1, 1), 1);
+    }
+
+    #[test]
+    fn test_first_non_blank_character_on_line() {
+        let text = Rope::from("");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.first_non_blank_character_on_line(0), 0);
+        assert_eq!(text.first_non_blank_character_on_line(1), 0);
+        assert_eq!(text.first_non_blank_character_on_line(2), 0);
+
+        let text = Rope::from("abc\ndef\nghi");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.first_non_blank_character_on_line(0), 0);
+        assert_eq!(text.first_non_blank_character_on_line(1), 4);
+        assert_eq!(text.first_non_blank_character_on_line(2), 8);
+        assert_eq!(text.first_non_blank_character_on_line(3), 11);
+        assert_eq!(text.first_non_blank_character_on_line(4), 8);
+        assert_eq!(text.first_non_blank_character_on_line(5), 8);
+
+        let text = Rope::from("abc\r\ndef\r\nghi");
+        let text = RopeText::new(&text);
+
+        assert_eq!(text.first_non_blank_character_on_line(0), 0);
+        assert_eq!(text.first_non_blank_character_on_line(1), 5);
+        assert_eq!(text.first_non_blank_character_on_line(2), 10);
+        assert_eq!(text.first_non_blank_character_on_line(3), 13);
+        assert_eq!(text.first_non_blank_character_on_line(4), 10);
+        assert_eq!(text.first_non_blank_character_on_line(5), 10);
+    }
+}
diff --git a/lapce-core/src/buffer/test.rs b/lapce-core/src/buffer/test.rs
index 122d9d1565..a119d59ba1 100644
--- a/lapce-core/src/buffer/test.rs
+++ b/lapce-core/src/buffer/test.rs
@@ -1,9 +1,10 @@
 use super::Buffer;
 
 mod editing {
+    use lapce_xi_rope::Rope;
+
     use super::*;
     use crate::{editor::EditType, selection::Selection};
-    use xi_rope::Rope;
 
     #[test]
     fn is_pristine() {
@@ -19,6 +20,7 @@ mod editing {
 
 mod motion {
     use super::*;
+    use crate::mode::Mode;
 
     #[test]
     fn cannot_move_in_empty_buffer() {
@@ -26,8 +28,8 @@ mod motion {
         assert_eq!(buffer.move_word_forward(0), 0);
         assert_eq!(buffer.move_n_words_forward(0, 2), 0);
 
-        assert_eq!(buffer.move_word_backward(0), 0);
-        assert_eq!(buffer.move_n_words_backward(0, 2), 0);
+        assert_eq!(buffer.move_word_backward(0, Mode::Insert), 0);
+        assert_eq!(buffer.move_n_words_backward(0, 2, Mode::Insert), 0);
 
         assert_eq!(buffer.move_n_wordends_forward(0, 2, false), 0);
         assert_eq!(buffer.move_n_wordends_forward(0, 2, true), 0);
@@ -40,15 +42,15 @@ mod motion {
 
         // 0 count does not move.
         assert_eq!(buffer.move_n_words_forward(0, 0), 0);
-        assert_eq!(buffer.move_n_words_backward(0, 0), 0);
+        assert_eq!(buffer.move_n_words_backward(0, 0, Mode::Insert), 0);
 
         for offset in 0..4 {
             assert_eq!(buffer.move_word_forward(offset), 4);
-            assert_eq!(buffer.move_word_backward(offset), 0);
+            assert_eq!(buffer.move_word_backward(offset, Mode::Insert), 0);
         }
 
         assert_eq!(buffer.move_word_forward(4), 8);
-        assert_eq!(buffer.move_word_backward(4), 0);
+        assert_eq!(buffer.move_word_backward(4, Mode::Insert), 0);
 
         let end = buffer.len() - 1;
         for offset in 0..4 {
@@ -56,14 +58,17 @@ mod motion {
         }
         assert_eq!(buffer.move_n_words_forward(4, 2), 15);
         for offset in 0..5 {
-            assert_eq!(buffer.move_n_words_backward(end - offset, 2), 8)
+            assert_eq!(
+                buffer.move_n_words_backward(end - offset, 2, Mode::Insert),
+                8
+            )
         }
-        assert_eq!(buffer.move_n_words_backward(end - 6, 2), 4);
+        assert_eq!(buffer.move_n_words_backward(end - 6, 2, Mode::Insert), 4);
 
         assert_eq!(buffer.move_n_words_forward(0, 2), 8);
         assert_eq!(buffer.move_n_words_forward(0, 3), 15);
-        assert_eq!(buffer.move_n_words_backward(end, 2), 8);
-        assert_eq!(buffer.move_n_words_backward(end, 3), 4);
+        assert_eq!(buffer.move_n_words_backward(end, 2, Mode::Insert), 8);
+        assert_eq!(buffer.move_n_words_backward(end, 3, Mode::Insert), 4);
 
         // FIXME: see #501 for possible issues in WordCursor::next_boundary()
         //
@@ -74,7 +79,10 @@ mod motion {
 
         // In the other direction.
         for offset in 0..end {
-            assert_eq!(buffer.move_n_words_backward(end - offset, 100), 0);
+            assert_eq!(
+                buffer.move_n_words_backward(end - offset, 100, Mode::Insert),
+                0
+            );
         }
     }
 
diff --git a/lapce-core/src/char_buffer.rs b/lapce-core/src/char_buffer.rs
new file mode 100644
index 0000000000..6ad777ba3e
--- /dev/null
+++ b/lapce-core/src/char_buffer.rs
@@ -0,0 +1,1083 @@
+extern crate alloc;
+
+use alloc::borrow::Cow;
+use alloc::rc::Rc;
+use alloc::sync::Arc;
+use core::borrow::Borrow;
+use core::cmp::Ordering;
+use core::convert::AsRef;
+use core::fmt;
+use core::hash;
+use core::ops::Deref;
+use core::str;
+
+/// This is a small memory buffer allocated on the stack to store a
+/// ‘string slice’ of exactly one character in length. That is, this
+/// structure stores the result of converting [`char`] to [`prim@str`]
+/// (which can be accessed as [`&str`]).
+///
+/// In other words, this struct is a helper for performing `char -> &str`
+/// type conversion without heap allocation.
+///
+/// # Note
+///
+/// In general, it is not recommended to perform `char -> CharBuffer -> char`
+/// type conversions, as this may affect performance.
+///
+/// [`&str`]: https://doc.rust-lang.org/core/primitive.str.html
+///
+/// # Examples
+///
+/// ```
+/// use lapce_core::char_buffer::CharBuffer;
+///
+/// let word = "goodbye";
+///
+/// let mut chars_buf = word.chars().map(CharBuffer::new);
+///
+/// assert_eq!("g", chars_buf.next().unwrap().as_ref());
+/// assert_eq!("o", chars_buf.next().unwrap().as_ref());
+/// assert_eq!("o", chars_buf.next().unwrap().as_ref());
+/// assert_eq!("d", chars_buf.next().unwrap().as_ref());
+/// assert_eq!("b", chars_buf.next().unwrap().as_ref());
+/// assert_eq!("y", chars_buf.next().unwrap().as_ref());
+/// assert_eq!("e", chars_buf.next().unwrap().as_ref());
+///
+/// assert_eq!(None, chars_buf.next());
+///
+/// for (char, char_buf) in word.chars().zip(word.chars().map(CharBuffer::new)) {
+///     assert_eq!(char.to_string(), char_buf);
+/// }
+/// ```
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub struct CharBuffer {
+    len: usize,
+    buf: [u8; 4],
+}
+
+/// The type of error returned when the conversion from [`prim@str`], [`String`] or their borrowed
+/// or native forms to [`CharBuffer`] fails.
+///
+/// This `structure` is created by various `CharBuffer::try_from` methods (for example,
+/// by the [`CharBuffer::try_from<&str>`] method).
+///
+/// See its documentation for more.
+///
+/// [`CharBuffer::try_from<&str>`]: CharBuffer::try_from<&str>
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct CharBufferTryFromError(());
+
+impl CharBuffer {
+    /// Creates a new `CharBuffer` from the given [`char`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let char_buf = CharBuffer::new('a');
+    /// assert_eq!("a", &char_buf);
+    ///
+    /// let string = "Some string";
+    /// let char_vec = string.chars().map(CharBuffer::new).collect::<Vec<_>>();
+    /// assert_eq!(
+    ///     ["S", "o", "m", "e", " ", "s", "t", "r", "i", "n", "g"].as_ref(),
+    ///     &char_vec
+    /// );
+    /// ```
+    #[inline]
+    pub fn new(char: char) -> Self {
+        let mut buf = [0; 4];
+        let len = char.encode_utf8(&mut buf).as_bytes().len();
+        Self { len, buf }
+    }
+
+    /// Converts a `CharBuffer` into an immutable string slice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let char_buf = CharBuffer::from('r');
+    /// assert_eq!("r", char_buf.as_str());
+    /// ```
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        self
+    }
+
+    /// Returns the length of a `&str` stored inside the `CharBuffer`, in bytes,
+    /// not [`char`]s or graphemes. In other words, it might not be what a human
+    /// considers the length of the string.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let f = CharBuffer::new('f');
+    /// assert_eq!(f.len(), 1);
+    ///
+    /// let fancy_f = CharBuffer::new('ƒ');
+    /// assert_eq!(fancy_f.len(), 2);
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Always returns `false` since this structure can only be created from
+    /// [`char`], which cannot be empty.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let c = CharBuffer::new('\0');
+    /// assert!(!c.is_empty());
+    /// assert_eq!(c.len(), 1);
+    /// ```
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        false
+    }
+}
+
+impl From<char> for CharBuffer {
+    /// Creates a new [`CharBuffer`] from the given [`char`].
+    ///
+    /// Calling this function is the same as calling [`new`](CharBuffer::new)
+    /// function.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let char_buf = CharBuffer::from('a');
+    /// assert_eq!("a", &char_buf);
+    ///
+    /// let string = "Some string";
+    /// let char_vec = string.chars().map(CharBuffer::from).collect::<Vec<_>>();
+    /// assert_eq!(
+    ///     ["S", "o", "m", "e", " ", "s", "t", "r", "i", "n", "g"].as_ref(),
+    ///     &char_vec
+    /// );
+    /// ```
+    #[inline]
+    fn from(char: char) -> Self {
+        Self::new(char)
+    }
+}
+
+impl From<&char> for CharBuffer {
+    /// Converts a `&char` into a [`CharBuffer`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let string = "Some string";
+    /// let char_vec = string.chars().collect::<Vec<_>>();
+    /// assert_eq!(
+    ///     ['S', 'o', 'm', 'e', ' ', 's', 't', 'r', 'i', 'n', 'g'].as_ref(),
+    ///     &char_vec
+    /// );
+    ///
+    /// let string_vec = char_vec.iter().map(CharBuffer::from).collect::<Vec<_>>();
+    ///
+    /// assert_eq!(
+    ///     ["S", "o", "m", "e", " ", "s", "t", "r", "i", "n", "g"].as_ref(),
+    ///     &string_vec
+    /// );
+    /// ````
+    #[inline]
+    fn from(char: &char) -> Self {
+        Self::new(*char)
+    }
+}
+
+impl From<&mut char> for CharBuffer {
+    /// Converts a `&mut char` into a [`CharBuffer`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let string = "Some string";
+    /// let mut char_vec = string.chars().collect::<Vec<_>>();
+    /// assert_eq!(
+    ///     ['S', 'o', 'm', 'e', ' ', 's', 't', 'r', 'i', 'n', 'g'].as_ref(),
+    ///     &char_vec
+    /// );
+    ///
+    /// let string_vec = char_vec
+    ///     .iter_mut()
+    ///     .map(CharBuffer::from)
+    ///     .collect::<Vec<_>>();
+    ///
+    /// assert_eq!(
+    ///     ["S", "o", "m", "e", " ", "s", "t", "r", "i", "n", "g"].as_ref(),
+    ///     &string_vec
+    /// );
+    /// ````
+    #[inline]
+    fn from(char: &mut char) -> Self {
+        Self::new(*char)
+    }
+}
+
+impl From<CharBuffer> for char {
+    /// Creates a new [`char`] from the given reference to [`CharBuffer`].
+    ///
+    /// # Note
+    ///
+    /// In general, it is not recommended to perform `char -> CharBuffer -> char`
+    /// type conversions, as this may affect performance.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let char_buf = CharBuffer::from('a');
+    /// let char: char = char_buf.into();
+    /// assert_eq!('a', char);
+    ///
+    /// let string = "Some string";
+    ///
+    /// // Such type conversions are not recommended, use `char` directly
+    /// let char_vec = string
+    ///     .chars()
+    ///     .map(CharBuffer::from)
+    ///     .map(char::from)
+    ///     .collect::<Vec<_>>();
+    ///
+    /// assert_eq!(
+    ///     ['S', 'o', 'm', 'e', ' ', 's', 't', 'r', 'i', 'n', 'g'].as_ref(),
+    ///     &char_vec
+    /// );
+    /// ````
+    #[inline]
+    fn from(char: CharBuffer) -> Self {
+        // SAFETY: The structure stores a valid utf8 character
+        unsafe { char.chars().next().unwrap_unchecked() }
+    }
+}
+
+impl From<&CharBuffer> for char {
+    /// Converts a `&CharBuffer` into a [`char`].
+    ///
+    /// # Note
+    ///
+    /// In general, it is not recommended to perform `char -> CharBuffer -> char`
+    /// type conversions, as this may affect performance.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let char_buf = CharBuffer::from('a');
+    /// let char: char = char::from(&char_buf);
+    /// assert_eq!('a', char);
+    ///
+    /// let string = "Some string";
+    ///
+    /// // Such type conversions are not recommended, use `char` directly
+    /// let char_buf_vec = string.chars().map(CharBuffer::from).collect::<Vec<_>>();
+    /// let char_vec = char_buf_vec.iter().map(char::from).collect::<Vec<_>>();
+    ///
+    /// assert_eq!(
+    ///     ['S', 'o', 'm', 'e', ' ', 's', 't', 'r', 'i', 'n', 'g'].as_ref(),
+    ///     &char_vec
+    /// );
+    /// ````
+    #[inline]
+    fn from(char: &CharBuffer) -> Self {
+        // SAFETY: The structure stores a valid utf8 character
+        unsafe { char.chars().next().unwrap_unchecked() }
+    }
+}
+
+impl From<&CharBuffer> for CharBuffer {
+    /// Converts a `&CharBuffer` into a [`CharBuffer`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let char_buf1 = CharBuffer::from('a');
+    /// let char_buf2: CharBuffer = CharBuffer::from(&char_buf1);
+    /// assert_eq!(char_buf1, char_buf2);
+    ///
+    /// let string = "Some string";
+    /// let char_vec1 = string.chars().map(CharBuffer::from).collect::<Vec<_>>();
+    /// let char_vec2 = char_vec1.iter().map(CharBuffer::from).collect::<Vec<_>>();
+    ///
+    /// assert_eq!(char_vec1, char_vec2);
+    /// ````
+    #[inline]
+    fn from(char: &CharBuffer) -> Self {
+        *char
+    }
+}
+
+impl From<CharBuffer> for String {
+    /// Allocates an owned [`String`] from a single character.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let c: CharBuffer = CharBuffer::from('a');
+    /// let s: String = String::from(c);
+    /// assert_eq!("a", &s[..]);
+    /// ```
+    #[inline]
+    fn from(char: CharBuffer) -> Self {
+        char.as_ref().to_string()
+    }
+}
+
+impl From<&CharBuffer> for String {
+    /// Allocates an owned [`String`] from a single character.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let c: CharBuffer = CharBuffer::from('a');
+    /// let s: String = String::from(&c);
+    /// assert_eq!("a", &s[..]);
+    /// ```
+    #[inline]
+    fn from(char: &CharBuffer) -> Self {
+        char.as_ref().to_string()
+    }
+}
+
+impl<'a> From<&'a CharBuffer> for &'a str {
+    /// Converts a `&CharBuffer` into a [`prim@str`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let c: CharBuffer = CharBuffer::from('a');
+    /// let s: &str = From::from(&c);
+    /// assert_eq!("a", &s[..]);
+    /// ```
+    #[inline]
+    fn from(char: &'a CharBuffer) -> Self {
+        char
+    }
+}
+
+impl<'a> From<&'a CharBuffer> for Cow<'a, str> {
+    /// Converts a `&'a CharBuffer` into a [`Cow<'a, str>`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    /// use std::borrow::Cow;
+    ///
+    /// let c: CharBuffer = CharBuffer::from('a');
+    /// let s: Cow<str> = From::from(&c);
+    /// assert_eq!("a", &s[..]);
+    /// ```
+    /// [`Cow<'a, str>`]: https://doc.rust-lang.org/std/borrow/enum.Cow.html
+    #[inline]
+    fn from(s: &'a CharBuffer) -> Self {
+        Cow::Borrowed(&**s)
+    }
+}
+
+impl From<CharBuffer> for Cow<'_, CharBuffer> {
+    /// Converts a `CharBuffer` into a [`Cow<'_, CharBuffer>`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    /// use std::borrow::Cow;
+    ///
+    /// let c: CharBuffer = CharBuffer::from('a');
+    /// let s: Cow<CharBuffer> = From::from(c);
+    /// assert_eq!("a", &s[..]);
+    /// ```
+    /// [`Cow<'_, CharBuffer>`]: https://doc.rust-lang.org/std/borrow/enum.Cow.html
+    #[inline]
+    fn from(s: CharBuffer) -> Self {
+        Cow::Owned(s)
+    }
+}
+
+macro_rules! impl_from_to_ptr {
+    (
+        $(#[$meta:meta])*
+        $ptr:ident
+    ) => {
+        $(#[$meta])*
+        impl From<CharBuffer> for $ptr<str> {
+            #[inline]
+            fn from(s: CharBuffer) -> Self {
+                Self::from(&*s)
+            }
+        }
+
+        $(#[$meta])*
+        impl From<&CharBuffer> for $ptr<str> {
+            #[inline]
+            fn from(s: &CharBuffer) -> Self {
+                Self::from(&**s)
+            }
+        }
+    }
+}
+
+impl_from_to_ptr! {
+    /// Converts a `CharBuffer` into a [`Arc<str>`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    /// use std::sync::Arc;
+    ///
+    /// let c: CharBuffer = CharBuffer::from('a');
+    /// let s1: Arc<str> = From::from(&c);
+    /// assert_eq!("a", &s1[..]);
+    ///
+    /// let s2: Arc<str> = From::from(c);
+    /// assert_eq!("a", &s2[..]);
+    /// ```
+    /// [`Arc<str>`]: https://doc.rust-lang.org/std/sync/struct.Arc.html
+    Arc
+}
+
+impl_from_to_ptr! {
+    /// Converts a `CharBuffer` into a [`Box<str>`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    ///
+    /// let c: CharBuffer = CharBuffer::from('a');
+    /// let s1: Box<str> = From::from(&c);
+    /// assert_eq!("a", &s1[..]);
+    ///
+    /// let s2: Box<str> = From::from(c);
+    /// assert_eq!("a", &s2[..]);
+    /// ```
+    /// [`Box<str>`]: https://doc.rust-lang.org/std/boxed/struct.Box.html
+    Box
+}
+
+impl_from_to_ptr! {
+    /// Converts a `CharBuffer` into a [`Rc<str>`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lapce_core::char_buffer::CharBuffer;
+    /// use std::rc::Rc;
+    ///
+    /// let c: CharBuffer = CharBuffer::from('a');
+    /// let s1: Rc<str> = From::from(&c);
+    /// assert_eq!("a", &s1[..]);
+    ///
+    /// let s2: Rc<str> = From::from(c);
+    /// assert_eq!("a", &s2[..]);
+    /// ```
+    /// [`Rc<str>`]: https://doc.rust-lang.org/std/rc/struct.Rc.html
+    Rc
+}
+
+macro_rules! impl_try_from {
+    ($lhs:ty) => {
+        impl TryFrom<$lhs> for CharBuffer {
+            type Error = CharBufferTryFromError;
+
+            fn try_from(str: $lhs) -> Result<Self, Self::Error> {
+                let mut chars = str.chars();
+                match (chars.next(), chars.next()) {
+                    (Some(char), None) => Ok(Self::new(char)),
+                    _ => Err(CharBufferTryFromError(())),
+                }
+            }
+        }
+    };
+}
+
+impl_try_from!(&str);
+impl_try_from!(&mut str);
+
+impl_try_from!(String);
+impl_try_from!(&String);
+impl_try_from!(&mut String);
+
+impl_try_from!(Box<str>);
+impl_try_from!(&Box<str>);
+impl_try_from!(&mut Box<str>);
+
+impl_try_from!(Arc<str>);
+impl_try_from!(&Arc<str>);
+impl_try_from!(&mut Arc<str>);
+
+impl_try_from!(Rc<str>);
+impl_try_from!(&Rc<str>);
+impl_try_from!(&mut Rc<str>);
+
+impl Deref for CharBuffer {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        // SAFETY:
+        // - This is the same buffer that we passed to `encode_utf8` during creating this structure,
+        //   so valid utf8 is stored there;
+        // - The length was directly calculated from the `&str` returned by the `encode_utf8` function
+        unsafe { str::from_utf8_unchecked(self.buf.get_unchecked(..self.len)) }
+    }
+}
+
+impl AsRef<str> for CharBuffer {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self
+    }
+}
+
+impl Borrow<str> for CharBuffer {
+    #[inline]
+    fn borrow(&self) -> &str {
+        self
+    }
+}
+
+#[allow(clippy::derive_hash_xor_eq)]
+impl hash::Hash for CharBuffer {
+    #[inline]
+    fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
+        (**self).hash(hasher)
+    }
+}
+
+impl fmt::Debug for CharBuffer {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
+impl fmt::Display for CharBuffer {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&**self, f)
+    }
+}
+
+impl PartialOrd for CharBuffer {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        (**self).partial_cmp(&**other)
+    }
+}
+
+impl Ord for CharBuffer {
+    #[inline]
+    fn cmp(&self, other: &Self) -> Ordering {
+        (**self).cmp(&**other)
+    }
+}
+
+macro_rules! impl_eq {
+    ($lhs:ty, $rhs: ty) => {
+        #[allow(unused_lifetimes)]
+        impl<'a, 'b> PartialEq<$rhs> for $lhs {
+            #[inline]
+            fn eq(&self, other: &$rhs) -> bool {
+                PartialEq::eq(&self[..], &other[..])
+            }
+        }
+
+        #[allow(unused_lifetimes)]
+        impl<'a, 'b> PartialEq<$lhs> for $rhs {
+            #[inline]
+            fn eq(&self, other: &$lhs) -> bool {
+                PartialEq::eq(&self[..], &other[..])
+            }
+        }
+    };
+}
+
+impl_eq! { CharBuffer, str }
+impl_eq! { CharBuffer, &'a str }
+impl_eq! { CharBuffer, &'a mut str }
+
+impl_eq! { CharBuffer, String }
+impl_eq! { CharBuffer, &'a String }
+impl_eq! { CharBuffer, &'a mut String }
+
+impl_eq! { Cow<'a, str>, CharBuffer }
+impl_eq! { Cow<'_, CharBuffer>, CharBuffer }
+
+#[allow(clippy::single_match)]
+#[test]
+fn test_char_buffer() {
+    #[cfg(miri)]
+    let mut string = String::from("
+    This is some text. Это некоторый текст. Αυτό είναι κάποιο κείμενο. 這是一些文字。"
+    );
+    #[cfg(not(miri))]
+    let mut string = String::from(
+        "
+    https://www.w3.org/2001/06/utf-8-test/UTF-8-demo.html
+
+    Original by Markus Kuhn, adapted for HTML by Martin Dürst.
+
+    UTF-8 encoded sample plain-text file
+    ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+    
+    Markus Kuhn [ˈmaʳkʊs kuːn] <mkuhn@acm.org> — 1999-08-20
+    
+    
+    The ASCII compatible UTF-8 encoding of ISO 10646 and Unicode
+    plain-text files is defined in RFC 2279 and in ISO 10646-1 Annex R.
+    
+    
+    Using Unicode/UTF-8, you can write in emails and source code things such as
+    
+    Mathematics and Sciences:
+    
+      ∮ E⋅da = Q,  n → ∞, ∑ f(i) = ∏ g(i), ∀x∈ℝ: ⌈x⌉ = −⌊−x⌋, α ∧ ¬β = ¬(¬α ∨ β),
+    
+      ℕ ⊆ ℕ₀ ⊂ ℤ ⊂ ℚ ⊂ ℝ ⊂ ℂ, ⊥ < a ≠ b ≡ c ≤ d ≪ ⊤ ⇒ (A ⇔ B),
+    
+      2H₂ + O₂ ⇌ 2H₂O, R = 4.7 kΩ, ⌀ 200 mm
+    
+    Linguistics and dictionaries:
+    
+      ði ıntəˈnæʃənəl fəˈnɛtık əsoʊsiˈeıʃn
+      Y [ˈʏpsilɔn], Yen [jɛn], Yoga [ˈjoːgɑ]
+    
+    APL:
+    
+      ((V⍳V)=⍳⍴V)/V←,V    ⌷←⍳→⍴∆∇⊃‾⍎⍕⌈
+    
+    Nicer typography in plain text files:
+    
+      ╔══════════════════════════════════════════╗
+      ║                                          ║
+      ║   • ‘single’ and “double” quotes         ║
+      ║                                          ║
+      ║   • Curly apostrophes: “We’ve been here” ║
+      ║                                          ║
+      ║   • Latin-1 apostrophe and accents: '´`  ║
+      ║                                          ║
+      ║   • ‚deutsche‘ „Anführungszeichen“       ║
+      ║                                          ║
+      ║   • †, ‡, ‰, •, 3–4, —, −5/+5, ™, …      ║
+      ║                                          ║
+      ║   • ASCII safety test: 1lI|, 0OD, 8B     ║
+      ║                      ╭─────────╮         ║
+      ║   • the euro symbol: │ 14.95 € │         ║
+      ║                      ╰─────────╯         ║
+      ╚══════════════════════════════════════════╝
+    
+    Greek (in Polytonic):
+    
+      The Greek anthem:
+    
+      Σὲ γνωρίζω ἀπὸ τὴν κόψη
+      τοῦ σπαθιοῦ τὴν τρομερή,
+      σὲ γνωρίζω ἀπὸ τὴν ὄψη
+      ποὺ μὲ βία μετράει τὴ γῆ.
+    
+      ᾿Απ᾿ τὰ κόκκαλα βγαλμένη
+      τῶν ῾Ελλήνων τὰ ἱερά
+      καὶ σὰν πρῶτα ἀνδρειωμένη
+      χαῖρε, ὦ χαῖρε, ᾿Ελευθεριά!
+    
+      From a speech of Demosthenes in the 4th century BC:
+    
+      Οὐχὶ ταὐτὰ παρίσταταί μοι γιγνώσκειν, ὦ ἄνδρες ᾿Αθηναῖοι,
+      ὅταν τ᾿ εἰς τὰ πράγματα ἀποβλέψω καὶ ὅταν πρὸς τοὺς
+      λόγους οὓς ἀκούω· τοὺς μὲν γὰρ λόγους περὶ τοῦ
+      τιμωρήσασθαι Φίλιππον ὁρῶ γιγνομένους, τὰ δὲ πράγματ᾿ 
+      εἰς τοῦτο προήκοντα,  ὥσθ᾿ ὅπως μὴ πεισόμεθ᾿ αὐτοὶ
+      πρότερον κακῶς σκέψασθαι δέον. οὐδέν οὖν ἄλλο μοι δοκοῦσιν
+      οἱ τὰ τοιαῦτα λέγοντες ἢ τὴν ὑπόθεσιν, περὶ ἧς βουλεύεσθαι,
+      οὐχὶ τὴν οὖσαν παριστάντες ὑμῖν ἁμαρτάνειν. ἐγὼ δέ, ὅτι μέν
+      ποτ᾿ ἐξῆν τῇ πόλει καὶ τὰ αὑτῆς ἔχειν ἀσφαλῶς καὶ Φίλιππον
+      τιμωρήσασθαι, καὶ μάλ᾿ ἀκριβῶς οἶδα· ἐπ᾿ ἐμοῦ γάρ, οὐ πάλαι
+      γέγονεν ταῦτ᾿ ἀμφότερα· νῦν μέντοι πέπεισμαι τοῦθ᾿ ἱκανὸν
+      προλαβεῖν ἡμῖν εἶναι τὴν πρώτην, ὅπως τοὺς συμμάχους
+      σώσομεν. ἐὰν γὰρ τοῦτο βεβαίως ὑπάρξῃ, τότε καὶ περὶ τοῦ
+      τίνα τιμωρήσεταί τις καὶ ὃν τρόπον ἐξέσται σκοπεῖν· πρὶν δὲ
+      τὴν ἀρχὴν ὀρθῶς ὑποθέσθαι, μάταιον ἡγοῦμαι περὶ τῆς
+      τελευτῆς ὁντινοῦν ποιεῖσθαι λόγον.
+    
+      Δημοσθένους, Γ´ ᾿Ολυνθιακὸς
+    
+    Georgian:
+    
+      From a Unicode conference invitation:
+    
+      გთხოვთ ახლავე გაიაროთ რეგისტრაცია Unicode-ის მეათე საერთაშორისო
+      კონფერენციაზე დასასწრებად, რომელიც გაიმართება 10-12 მარტს,
+      ქ. მაინცში, გერმანიაში. კონფერენცია შეჰკრებს ერთად მსოფლიოს
+      ექსპერტებს ისეთ დარგებში როგორიცაა ინტერნეტი და Unicode-ი,
+      ინტერნაციონალიზაცია და ლოკალიზაცია, Unicode-ის გამოყენება
+      ოპერაციულ სისტემებსა, და გამოყენებით პროგრამებში, შრიფტებში,
+      ტექსტების დამუშავებასა და მრავალენოვან კომპიუტერულ სისტემებში.
+    
+    Russian:
+    
+      From a Unicode conference invitation:
+    
+      Зарегистрируйтесь сейчас на Десятую Международную Конференцию по
+      Unicode, которая состоится 10-12 марта 1997 года в Майнце в Германии.
+      Конференция соберет широкий круг экспертов по  вопросам глобального
+      Интернета и Unicode, локализации и интернационализации, воплощению и
+      применению Unicode в различных операционных системах и программных
+      приложениях, шрифтах, верстке и многоязычных компьютерных системах.
+    
+    Thai (UCS Level 2):
+    
+      Excerpt from a poetry on The Romance of The Three Kingdoms (a Chinese
+      classic 'San Gua'):
+    
+      [----------------------------|------------------------]
+        ๏ แผ่นดินฮั่นเสื่อมโทรมแสนสังเวช  พระปกเกศกองบู๊กู้ขึ้นใหม่
+      สิบสองกษัตริย์ก่อนหน้าแลถัดไป       สององค์ไซร้โง่เขลาเบาปัญญา
+        ทรงนับถือขันทีเป็นที่พึ่ง           บ้านเมืองจึงวิปริตเป็นนักหนา
+      โฮจิ๋นเรียกทัพทั่วหัวเมืองมา         หมายจะฆ่ามดชั่วตัวสำคัญ
+        เหมือนขับไสไล่เสือจากเคหา      รับหมาป่าเข้ามาเลยอาสัญ
+      ฝ่ายอ้องอุ้นยุแยกให้แตกกัน          ใช้สาวนั้นเป็นชนวนชื่นชวนใจ
+        พลันลิฉุยกุยกีกลับก่อเหตุ          ช่างอาเพศจริงหนาฟ้าร้องไห้
+      ต้องรบราฆ่าฟันจนบรรลัย           ฤๅหาใครค้ำชูกู้บรรลังก์ ฯ
+    
+      (The above is a two-column text. If combining characters are handled
+      correctly, the lines of the second column should be aligned with the
+      | character above.)
+    
+    Ethiopian:
+    
+      Proverbs in the Amharic language:
+    
+      ሰማይ አይታረስ ንጉሥ አይከሰስ።
+      ብላ ካለኝ እንደአባቴ በቆመጠኝ።
+      ጌጥ ያለቤቱ ቁምጥና ነው።
+      ደሀ በሕልሙ ቅቤ ባይጠጣ ንጣት በገደለው።
+      የአፍ ወለምታ በቅቤ አይታሽም።
+      አይጥ በበላ ዳዋ ተመታ።
+      ሲተረጉሙ ይደረግሙ።
+      ቀስ በቀስ፥ ዕንቁላል በእግሩ ይሄዳል።
+      ድር ቢያብር አንበሳ ያስር።
+      ሰው እንደቤቱ እንጅ እንደ ጉረቤቱ አይተዳደርም።
+      እግዜር የከፈተውን ጉሮሮ ሳይዘጋው አይድርም።
+      የጎረቤት ሌባ፥ ቢያዩት ይስቅ ባያዩት ያጠልቅ።
+      ሥራ ከመፍታት ልጄን ላፋታት።
+      ዓባይ ማደሪያ የለው፥ ግንድ ይዞ ይዞራል።
+      የእስላም አገሩ መካ የአሞራ አገሩ ዋርካ።
+      ተንጋሎ ቢተፉ ተመልሶ ባፉ።
+      ወዳጅህ ማር ቢሆን ጨርስህ አትላሰው።
+      እግርህን በፍራሽህ ልክ ዘርጋ።
+    
+    Runes:
+    
+      ᚻᛖ ᚳᚹᚫᚦ ᚦᚫᛏ ᚻᛖ ᛒᚢᛞᛖ ᚩᚾ ᚦᚫᛗ ᛚᚪᚾᛞᛖ ᚾᚩᚱᚦᚹᛖᚪᚱᛞᚢᛗ ᚹᛁᚦ ᚦᚪ ᚹᛖᛥᚫ
+    
+      (Old English, which transcribed into Latin reads 'He cwaeth that he
+      bude thaem lande northweardum with tha Westsae.' and means 'He said
+      that he lived in the northern land near the Western Sea.')
+    
+    Braille:
+    
+      ⡌⠁⠧⠑ ⠼⠁⠒  ⡍⠜⠇⠑⠹⠰⠎ ⡣⠕⠌
+    
+      ⡍⠜⠇⠑⠹ ⠺⠁⠎ ⠙⠑⠁⠙⠒ ⠞⠕ ⠃⠑⠛⠔ ⠺⠊⠹⠲ ⡹⠻⠑ ⠊⠎ ⠝⠕ ⠙⠳⠃⠞
+      ⠱⠁⠞⠑⠧⠻ ⠁⠃⠳⠞ ⠹⠁⠞⠲ ⡹⠑ ⠗⠑⠛⠊⠌⠻ ⠕⠋ ⠙⠊⠎ ⠃⠥⠗⠊⠁⠇ ⠺⠁⠎
+      ⠎⠊⠛⠝⠫ ⠃⠹ ⠹⠑ ⠊⠇⠻⠛⠹⠍⠁⠝⠂ ⠹⠑ ⠊⠇⠻⠅⠂ ⠹⠑ ⠥⠝⠙⠻⠞⠁⠅⠻⠂
+      ⠁⠝⠙ ⠹⠑ ⠡⠊⠑⠋ ⠍⠳⠗⠝⠻⠲ ⡎⠊⠗⠕⠕⠛⠑ ⠎⠊⠛⠝⠫ ⠊⠞⠲ ⡁⠝⠙
+      ⡎⠊⠗⠕⠕⠛⠑⠰⠎ ⠝⠁⠍⠑ ⠺⠁⠎ ⠛⠕⠕⠙ ⠥⠏⠕⠝ ⠰⡡⠁⠝⠛⠑⠂ ⠋⠕⠗ ⠁⠝⠹⠹⠔⠛ ⠙⠑ 
+      ⠡⠕⠎⠑ ⠞⠕ ⠏⠥⠞ ⠙⠊⠎ ⠙⠁⠝⠙ ⠞⠕⠲
+    
+      ⡕⠇⠙ ⡍⠜⠇⠑⠹ ⠺⠁⠎ ⠁⠎ ⠙⠑⠁⠙ ⠁⠎ ⠁ ⠙⠕⠕⠗⠤⠝⠁⠊⠇⠲
+    
+      ⡍⠔⠙⠖ ⡊ ⠙⠕⠝⠰⠞ ⠍⠑⠁⠝ ⠞⠕ ⠎⠁⠹ ⠹⠁⠞ ⡊ ⠅⠝⠪⠂ ⠕⠋ ⠍⠹
+      ⠪⠝ ⠅⠝⠪⠇⠫⠛⠑⠂ ⠱⠁⠞ ⠹⠻⠑ ⠊⠎ ⠏⠜⠞⠊⠊⠥⠇⠜⠇⠹ ⠙⠑⠁⠙ ⠁⠃⠳⠞
+      ⠁ ⠙⠕⠕⠗⠤⠝⠁⠊⠇⠲ ⡊ ⠍⠊⠣⠞ ⠙⠁⠧⠑ ⠃⠑⠲ ⠔⠊⠇⠔⠫⠂ ⠍⠹⠎⠑⠇⠋⠂ ⠞⠕
+      ⠗⠑⠛⠜⠙ ⠁ ⠊⠕⠋⠋⠔⠤⠝⠁⠊⠇ ⠁⠎ ⠹⠑ ⠙⠑⠁⠙⠑⠌ ⠏⠊⠑⠊⠑ ⠕⠋ ⠊⠗⠕⠝⠍⠕⠝⠛⠻⠹ 
+      ⠔ ⠹⠑ ⠞⠗⠁⠙⠑⠲ ⡃⠥⠞ ⠹⠑ ⠺⠊⠎⠙⠕⠍ ⠕⠋ ⠳⠗ ⠁⠝⠊⠑⠌⠕⠗⠎ 
+      ⠊⠎ ⠔ ⠹⠑ ⠎⠊⠍⠊⠇⠑⠆ ⠁⠝⠙ ⠍⠹ ⠥⠝⠙⠁⠇⠇⠪⠫ ⠙⠁⠝⠙⠎
+      ⠩⠁⠇⠇ ⠝⠕⠞ ⠙⠊⠌⠥⠗⠃ ⠊⠞⠂ ⠕⠗ ⠹⠑ ⡊⠳⠝⠞⠗⠹⠰⠎ ⠙⠕⠝⠑ ⠋⠕⠗⠲ ⡹⠳
+      ⠺⠊⠇⠇ ⠹⠻⠑⠋⠕⠗⠑ ⠏⠻⠍⠊⠞ ⠍⠑ ⠞⠕ ⠗⠑⠏⠑⠁⠞⠂ ⠑⠍⠏⠙⠁⠞⠊⠊⠁⠇⠇⠹⠂ ⠹⠁⠞
+      ⡍⠜⠇⠑⠹ ⠺⠁⠎ ⠁⠎ ⠙⠑⠁⠙ ⠁⠎ ⠁ ⠙⠕⠕⠗⠤⠝⠁⠊⠇⠲
+    
+      (The first couple of paragraphs of \"A Christmas Carol\" by Dickens)
+    
+    Compact font selection example text:
+    
+      ABCDEFGHIJKLMNOPQRSTUVWXYZ /0123456789
+      abcdefghijklmnopqrstuvwxyz £©µÀÆÖÞßéöÿ
+      –—‘“”„†•…‰™œŠŸž€ ΑΒΓΔΩαβγδω АБВГДабвгд
+      ∀∂∈ℝ∧∪≡∞ ↑↗↨↻⇣ ┐┼╔╘░►☺♀ fi�⑀₂ἠḂӥẄɐː⍎אԱა
+    
+    Greetings in various languages:
+    
+      Hello world, Καλημέρα κόσμε, コンニチハ
+    
+    Box drawing alignment tests:                                          █
+                                                                          ▉
+      ╔══╦══╗  ┌──┬──┐  ╭──┬──╮  ╭──┬──╮  ┏━━┳━━┓  ┎┒┏┑   ╷  ╻ ┏┯┓ ┌┰┐    ▊ ╱╲╱╲╳╳╳
+      ║┌─╨─┐║  │╔═╧═╗│  │╒═╪═╕│  │╓─╁─╖│  ┃┌─╂─┐┃  ┗╃╄┙  ╶┼╴╺╋╸┠┼┨ ┝╋┥    ▋ ╲╱╲╱╳╳╳
+      ║│╲ ╱│║  │║   ║│  ││ │ ││  │║ ┃ ║│  ┃│ ╿ │┃  ┍╅╆┓   ╵  ╹ ┗┷┛ └┸┘    ▌ ╱╲╱╲╳╳╳
+      ╠╡ ╳ ╞╣  ├╢   ╟┤  ├┼─┼─┼┤  ├╫─╂─╫┤  ┣┿╾┼╼┿┫  ┕┛┖┚     ┌┄┄┐ ╎ ┏┅┅┓ ┋ ▍ ╲╱╲╱╳╳╳
+      ║│╱ ╲│║  │║   ║│  ││ │ ││  │║ ┃ ║│  ┃│ ╽ │┃  ░░▒▒▓▓██ ┊  ┆ ╎ ╏  ┇ ┋ ▎
+      ║└─╥─┘║  │╚═╤═╝│  │╘═╪═╛│  │╙─╀─╜│  ┃└─╂─┘┃  ░░▒▒▓▓██ ┊  ┆ ╎ ╏  ┇ ┋ ▏
+      ╚══╩══╝  └──┴──┘  ╰──┴──╯  ╰──┴──╯  ┗━━┻━━┛           └╌╌┘ ╎ ┗╍╍┛ ┋  ▁▂▃▄▅▆▇█
+   
+",
+    );
+
+    match CharBuffer::try_from(string.as_str()) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    match CharBuffer::try_from(string.as_mut_str()) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    match CharBuffer::try_from(&string) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    match CharBuffer::try_from(&mut string) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    match CharBuffer::try_from(string.clone()) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    let mut some_box: Box<str> = Box::from(string.clone());
+
+    match CharBuffer::try_from(&some_box) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    match CharBuffer::try_from(&mut some_box) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    match CharBuffer::try_from(some_box) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    let mut some_arc: Arc<str> = Arc::from(string.clone());
+
+    match CharBuffer::try_from(&some_arc) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    match CharBuffer::try_from(&mut some_arc) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    match CharBuffer::try_from(some_arc) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    let mut some_rc: Rc<str> = Rc::from(string.clone());
+
+    match CharBuffer::try_from(&some_rc) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    match CharBuffer::try_from(&mut some_rc) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    match CharBuffer::try_from(some_rc) {
+        Ok(_) => panic!("This should fail because of long string"),
+        Err(_) => {}
+    }
+
+    let hash_builder = std::collections::hash_map::RandomState::default();
+
+    fn make_hash<Q, S>(hash_builder: &S, val: &Q) -> u64
+    where
+        Q: std::hash::Hash + ?Sized,
+        S: core::hash::BuildHasher,
+    {
+        use core::hash::Hasher;
+        let mut state = hash_builder.build_hasher();
+        val.hash(&mut state);
+        state.finish()
+    }
+
+    for mut char in string.chars() {
+        let mut char_string = char.to_string();
+
+        assert_eq!(CharBuffer::new(char), char_string);
+        assert_eq!(CharBuffer::new(char).as_str(), char_string);
+        assert_eq!(CharBuffer::new(char).len(), char_string.len());
+        assert_eq!(CharBuffer::from(char), char_string);
+        assert_eq!(CharBuffer::from(&char), char_string);
+        assert_eq!(CharBuffer::from(&mut char), char_string);
+
+        let char_buf = CharBuffer::new(char);
+
+        assert_eq!(
+            make_hash(&hash_builder, &char_buf),
+            make_hash(&hash_builder, &char_string)
+        );
+
+        assert_eq!(CharBuffer::new(char), char_buf);
+        assert_eq!(CharBuffer::new(char), CharBuffer::from(&char_buf));
+        assert_eq!(&*char_buf, char_string.as_str());
+        assert_eq!(char_buf.as_ref(), char_string.as_str());
+        let str: &str = char_buf.borrow();
+        assert_eq!(str, char_string.as_str());
+
+        assert_eq!(char::from(&char_buf), char);
+        assert_eq!(char::from(char_buf), char);
+        assert_eq!(String::from(char_buf), char_string);
+        assert_eq!(String::from(&char_buf), char_string);
+
+        let str: &str = From::from(&char_buf);
+        assert_eq!(str, char_string);
+
+        let str: Cow<str> = From::from(&char_buf);
+        assert_eq!(str, char_string);
+
+        let str: Cow<CharBuffer> = From::from(char_buf);
+        assert_eq!(str.as_str(), char_string);
+
+        let str: Arc<str> = From::from(char_buf);
+        assert_eq!(&str[..], char_string);
+
+        let str: Arc<str> = From::from(&char_buf);
+        assert_eq!(&str[..], char_string);
+
+        let str: Box<str> = From::from(char_buf);
+        assert_eq!(&str[..], char_string);
+
+        let str: Box<str> = From::from(&char_buf);
+        assert_eq!(&str[..], char_string);
+
+        let str: Rc<str> = From::from(char_buf);
+        assert_eq!(&str[..], char_string);
+
+        let str: Rc<str> = From::from(&char_buf);
+        assert_eq!(&str[..], char_string);
+
+        match CharBuffer::try_from(char_string.as_str()) {
+            Ok(char_buf) => {
+                assert_eq!(char_buf, char_string.as_str());
+                assert_eq!(char_string.as_str(), char_buf);
+            }
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+        match CharBuffer::try_from(char_string.as_mut_str()) {
+            Ok(char_buf) => {
+                assert_eq!(char_buf, char_string.as_mut_str());
+                assert_eq!(char_string.as_mut_str(), char_buf);
+            }
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+
+        match CharBuffer::try_from(&char_string) {
+            Ok(char_buf) => {
+                assert_eq!(char_buf, &char_string);
+                assert_eq!(&char_string, char_buf);
+            }
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+        match CharBuffer::try_from(&mut char_string) {
+            Ok(char_buf) => {
+                assert_eq!(char_buf, &mut char_string);
+                assert_eq!(&mut char_string, char_buf);
+            }
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+        match CharBuffer::try_from(char_string.clone()) {
+            Ok(char_buf) => {
+                assert_eq!(char_buf, char_string);
+                assert_eq!(char_string, char_buf);
+            }
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+
+        let mut some_box: Box<str> = Box::from(char_string.clone());
+
+        match CharBuffer::try_from(&some_box) {
+            Ok(char_buf) => assert_eq!(char_buf, some_box.as_ref()),
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+        match CharBuffer::try_from(&mut some_box) {
+            Ok(char_buf) => assert_eq!(char_buf, some_box.as_ref()),
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+        match CharBuffer::try_from(some_box) {
+            Ok(char_buf) => assert_eq!(char_buf, char_string),
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+
+        let mut some_arc: Arc<str> = Arc::from(char_string.clone());
+
+        match CharBuffer::try_from(&some_arc) {
+            Ok(char_buf) => assert_eq!(char_buf, some_arc.as_ref()),
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+        match CharBuffer::try_from(&mut some_arc) {
+            Ok(char_buf) => assert_eq!(char_buf, some_arc.as_ref()),
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+        match CharBuffer::try_from(some_arc) {
+            Ok(char_buf) => assert_eq!(char_buf, char_string),
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+
+        let mut some_rc: Rc<str> = Rc::from(char_string.clone());
+
+        match CharBuffer::try_from(&some_rc) {
+            Ok(char_buf) => assert_eq!(char_buf, some_rc.as_ref()),
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+        match CharBuffer::try_from(&mut some_rc) {
+            Ok(char_buf) => assert_eq!(char_buf, some_rc.as_ref()),
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+        match CharBuffer::try_from(some_rc) {
+            Ok(char_buf) => assert_eq!(char_buf, char_string),
+            Err(_) => panic!("This should not fail because of single char"),
+        }
+    }
+}
diff --git a/lapce-core/src/command.rs b/lapce-core/src/command.rs
index 43b78390c9..ad04d40fd5 100644
--- a/lapce-core/src/command.rs
+++ b/lapce-core/src/command.rs
@@ -8,6 +8,7 @@ use crate::movement::{LinePosition, Movement};
     EnumIter,
     Clone,
     PartialEq,
+    Eq,
     Debug,
     EnumMessage,
     IntoStaticStr,
@@ -29,14 +30,25 @@ pub enum EditCommand {
     DeleteBackward,
     #[strum(serialize = "delete_forward")]
     DeleteForward,
+    #[strum(serialize = "delete_line")]
+    DeleteLine,
     #[strum(serialize = "delete_forward_and_insert")]
     DeleteForwardAndInsert,
+    #[strum(serialize = "delete_word_and_insert")]
+    DeleteWordAndInsert,
+    #[strum(serialize = "delete_line_and_insert")]
+    DeleteLineAndInsert,
     #[strum(serialize = "delete_word_forward")]
     DeleteWordForward,
     #[strum(serialize = "delete_word_backward")]
     DeleteWordBackward,
     #[strum(serialize = "delete_to_beginning_of_line")]
     DeleteToBeginningOfLine,
+    #[strum(serialize = "delete_to_end_of_line")]
+    DeleteToEndOfLine,
+
+    #[strum(serialize = "delete_to_end_and_insert")]
+    DeleteToEndOfLineAndInsert,
     #[strum(message = "Join Lines")]
     #[strum(serialize = "join_lines")]
     JoinLines,
@@ -66,6 +78,8 @@ pub enum EditCommand {
     Yank,
     #[strum(serialize = "paste")]
     Paste,
+    #[strum(serialize = "paste_before")]
+    PasteBefore,
 
     #[strum(serialize = "normal_mode")]
     NormalMode,
@@ -83,6 +97,10 @@ pub enum EditCommand {
     ToggleLinewiseVisualMode,
     #[strum(serialize = "toggle_blockwise_visual_mode")]
     ToggleBlockwiseVisualMode,
+    #[strum(serialize = "duplicate_line_up")]
+    DuplicateLineUp,
+    #[strum(serialize = "duplicate_line_down")]
+    DuplicateLineDown,
 }
 
 #[derive(
@@ -91,6 +109,7 @@ pub enum EditCommand {
     EnumIter,
     Clone,
     PartialEq,
+    Eq,
     Debug,
     EnumMessage,
     IntoStaticStr,
@@ -136,6 +155,12 @@ pub enum MoveCommand {
     NextUnmatchedRightCurlyBracket,
     #[strum(serialize = "previous_unmatched_left_curly_bracket")]
     PreviousUnmatchedLeftCurlyBracket,
+    #[strum(message = "Paragraph forward")]
+    #[strum(serialize = "paragraph_forward")]
+    ParagraphForward,
+    #[strum(message = "Paragraph backward")]
+    #[strum(serialize = "paragraph_backward")]
+    ParagraphBackward,
 }
 
 impl MoveCommand {
@@ -167,6 +192,8 @@ impl MoveCommand {
             PreviousUnmatchedLeftBracket => Movement::PreviousUnmatched('('),
             NextUnmatchedRightCurlyBracket => Movement::NextUnmatched('}'),
             PreviousUnmatchedLeftCurlyBracket => Movement::PreviousUnmatched('{'),
+            ParagraphForward => Movement::ParagraphForward,
+            ParagraphBackward => Movement::ParagraphBackward,
         }
     }
 }
@@ -177,6 +204,7 @@ impl MoveCommand {
     EnumIter,
     Clone,
     PartialEq,
+    Eq,
     Debug,
     EnumMessage,
     IntoStaticStr,
@@ -204,6 +232,8 @@ pub enum FocusCommand {
     SearchForward,
     #[strum(serialize = "search_backward")]
     SearchBackward,
+    #[strum(serialize = "toggle_case_sensitive_search")]
+    ToggleCaseSensitive,
     #[strum(serialize = "global_search_refresh")]
     GlobalSearchRefresh,
     #[strum(serialize = "clear_search")]
@@ -214,8 +244,12 @@ pub enum FocusCommand {
     ListSelect,
     #[strum(serialize = "list.next")]
     ListNext,
+    #[strum(serialize = "list.next_page")]
+    ListNextPage,
     #[strum(serialize = "list.previous")]
     ListPrevious,
+    #[strum(serialize = "list.previous_page")]
+    ListPreviousPage,
     #[strum(serialize = "list.expand")]
     ListExpand,
     #[strum(serialize = "jump_to_next_snippet_placeholder")]
@@ -240,6 +274,8 @@ pub enum FocusCommand {
     ShowCodeActions,
     #[strum(serialize = "get_completion")]
     GetCompletion,
+    #[strum(serialize = "get_signature")]
+    GetSignature,
     /// This will close a modal, such as the settings window or completion
     #[strum(message = "modalを閉じる")]
     #[strum(serialize = "modal.close")]
@@ -247,10 +283,17 @@ pub enum FocusCommand {
     #[strum(message = "定義へ移動")]
     #[strum(serialize = "goto_definition")]
     GotoDefinition,
+    #[strum(message = "Go to Type Definition")]
+    #[strum(serialize = "goto_type_definition")]
+    GotoTypeDefinition,
+    #[strum(message = "Show Hover")]
+    #[strum(serialize = "show_hover")]
+    ShowHover,
     #[strum(serialize = "jump_location_backward")]
     JumpLocationBackward,
     #[strum(serialize = "jump_location_forward")]
     JumpLocationForward,
+    #[strum(message = "Next Error in Workspace")]
     #[strum(serialize = "next_error")]
     NextError,
     #[strum(serialize = "previous_error")]
@@ -264,6 +307,9 @@ pub enum FocusCommand {
     #[strum(message = "Code-Lensの切り替え")]
     #[strum(serialize = "toggle_code_lens")]
     ToggleCodeLens,
+    #[strum(message = "Toggle History")]
+    #[strum(serialize = "toggle_history")]
+    ToggleHistory,
     #[strum(serialize = "format_document")]
     #[strum(message = "文書のformat")]
     FormatDocument,
@@ -278,10 +324,22 @@ pub enum FocusCommand {
     #[strum(message = "保存")]
     #[strum(serialize = "save")]
     Save,
+    #[strum(message = "Save Without Formatting")]
+    #[strum(serialize = "save_without_format")]
+    SaveWithoutFormatting,
     #[strum(serialize = "save_and_exit")]
     SaveAndExit,
     #[strum(serialize = "force_exit")]
     ForceExit,
+    #[strum(serialize = "rename_symbol")]
+    #[strum(message = "Rename Symbol")]
+    Rename,
+    #[strum(serialize = "confirm_rename")]
+    ConfirmRename,
+    #[strum(serialize = "select_next_syntax_item")]
+    SelectNextSyntaxItem,
+    #[strum(serialize = "select_previous_syntax_item")]
+    SelectPreviousSyntaxItem,
 }
 
 #[derive(
@@ -290,6 +348,7 @@ pub enum FocusCommand {
     EnumIter,
     Clone,
     PartialEq,
+    Eq,
     Debug,
     EnumMessage,
     IntoStaticStr,
@@ -311,6 +370,7 @@ pub enum MotionModeCommand {
     EnumIter,
     Clone,
     PartialEq,
+    Eq,
     Debug,
     EnumMessage,
     IntoStaticStr,
diff --git a/lapce-core/src/cursor.rs b/lapce-core/src/cursor.rs
index 799d7cdc0a..0a09a31b66 100644
--- a/lapce-core/src/cursor.rs
+++ b/lapce-core/src/cursor.rs
@@ -1,10 +1,12 @@
+use lapce_xi_rope::{RopeDelta, Transformer};
 use serde::{Deserialize, Serialize};
-use xi_rope::{RopeDelta, Transformer};
 
-use crate::buffer::Buffer;
-use crate::mode::{Mode, MotionMode, VisualMode};
-use crate::register::RegisterData;
-use crate::selection::{InsertDrift, SelRegion, Selection};
+use crate::{
+    buffer::Buffer,
+    mode::{Mode, MotionMode, VisualMode},
+    register::RegisterData,
+    selection::{InsertDrift, SelRegion, Selection},
+};
 
 #[derive(Clone, Copy, PartialEq, Debug, Serialize, Deserialize)]
 pub enum ColPosition {
@@ -274,6 +276,60 @@ impl Cursor {
         RegisterData { content, mode }
     }
 
+    /// Return the current selection start and end position for a
+    /// Single cursor selection
+    pub fn get_selection(&self) -> Option<(usize, usize)> {
+        match &self.mode {
+            CursorMode::Visual {
+                start,
+                end,
+                mode: _,
+            } => Some((*start, *end)),
+            CursorMode::Insert(selection) => selection
+                .regions()
+                .first()
+                .map(|region| (region.start, region.end)),
+            _ => None,
+        }
+    }
+
+    pub fn get_line_col_char(
+        &self,
+        buffer: &Buffer,
+    ) -> Option<(usize, usize, usize)> {
+        match &self.mode {
+            CursorMode::Normal(offset) => {
+                let ln_col = buffer.offset_to_line_col(*offset);
+                Some((ln_col.0, ln_col.1, *offset))
+            }
+            CursorMode::Visual {
+                start,
+                end,
+                mode: _,
+            } => {
+                let v = buffer.offset_to_line_col(*start.min(end));
+                Some((v.0, v.1, *start))
+            }
+            CursorMode::Insert(selection) => {
+                if selection.regions().len() > 1 {
+                    return None;
+                }
+
+                let x = selection.regions().get(0).unwrap();
+                let v = buffer.offset_to_line_col(x.start);
+
+                Some((v.0, v.1, x.start))
+            }
+        }
+    }
+
+    pub fn get_selection_count(&self) -> usize {
+        match &self.mode {
+            CursorMode::Insert(selection) => selection.regions().len(),
+            _ => 0,
+        }
+    }
+
     pub fn set_offset(&mut self, offset: usize, modify: bool, new_cursor: bool) {
         match &self.mode {
             CursorMode::Normal(old_offset) => {
@@ -320,8 +376,7 @@ impl Cursor {
                 } else if modify {
                     let mut new_selection = Selection::new();
                     if let Some(region) = selection.first() {
-                        let new_region =
-                            SelRegion::new(region.start(), offset, None);
+                        let new_region = SelRegion::new(region.start, offset, None);
                         new_selection.add_region(new_region);
                     } else {
                         new_selection
@@ -411,13 +466,13 @@ pub fn get_first_selection_after(
     let ins = ins.transform_shrink(&del);
     for el in ins.els.iter() {
         match el {
-            xi_rope::DeltaElement::Copy(b, e) => {
+            lapce_xi_rope::DeltaElement::Copy(b, e) => {
                 // if b == e, ins.inserted_subset() will panic
                 if b == e {
                     return None;
                 }
             }
-            xi_rope::DeltaElement::Insert(_) => {}
+            lapce_xi_rope::DeltaElement::Insert(_) => {}
         }
     }
 
@@ -443,7 +498,7 @@ pub fn get_first_selection_after(
     });
 
     positions
-        .get(0)
+        .first()
         .cloned()
         .map(Selection::caret)
         .map(|selection| {
diff --git a/lapce-core/src/directory.rs b/lapce-core/src/directory.rs
new file mode 100644
index 0000000000..01da03379b
--- /dev/null
+++ b/lapce-core/src/directory.rs
@@ -0,0 +1,128 @@
+use std::path::PathBuf;
+
+use directories::ProjectDirs;
+
+use crate::meta::NAME;
+pub struct Directory {}
+
+impl Directory {
+    fn project_dirs() -> Option<ProjectDirs> {
+        ProjectDirs::from("dev", "lapce", &NAME)
+    }
+
+    // Get path of local data directory
+    // Local data directory differs from data directory
+    // on some platforms and is not transferred across
+    // machines
+    pub fn data_local_directory() -> Option<PathBuf> {
+        match Self::project_dirs() {
+            Some(dir) => {
+                let dir = dir.data_local_dir();
+                if !dir.exists() {
+                    let _ = std::fs::create_dir_all(dir);
+                }
+                Some(dir.to_path_buf())
+            }
+            None => None,
+        }
+    }
+
+    /// Get the path to logs directory
+    /// Each log file is for individual application startup
+    pub fn logs_directory() -> Option<PathBuf> {
+        if let Some(dir) = Self::data_local_directory() {
+            let dir = dir.join("logs");
+            if !dir.exists() {
+                let _ = std::fs::create_dir(&dir);
+            }
+            Some(dir)
+        } else {
+            None
+        }
+    }
+
+    /// Get the path to cache directory
+    pub fn cache_directory() -> Option<PathBuf> {
+        if let Some(dir) = Self::data_local_directory() {
+            let dir = dir.join("cache");
+            if !dir.exists() {
+                let _ = std::fs::create_dir(&dir);
+            }
+            Some(dir)
+        } else {
+            None
+        }
+    }
+
+    /// Directory to store proxy executables used on local
+    /// host as well, as ones uploaded to remote host when
+    /// connecting
+    pub fn proxy_directory() -> Option<PathBuf> {
+        if let Some(dir) = Self::data_local_directory() {
+            let dir = dir.join("proxy");
+            if !dir.exists() {
+                let _ = std::fs::create_dir(&dir);
+            }
+            Some(dir)
+        } else {
+            None
+        }
+    }
+    /// Get the path to the themes folder
+    /// Themes are stored within as individual toml files
+    pub fn themes_directory() -> Option<PathBuf> {
+        if let Some(dir) = Self::data_local_directory() {
+            let dir = dir.join("themes");
+            if !dir.exists() {
+                let _ = std::fs::create_dir(&dir);
+            }
+            Some(dir)
+        } else {
+            None
+        }
+    }
+    // Get the path to plugins directory
+    // Each plugin has own directory that contains
+    // metadata file and plugin wasm
+    pub fn plugins_directory() -> Option<PathBuf> {
+        if let Some(dir) = Self::data_local_directory() {
+            let dir = dir.join("plugins");
+            if !dir.exists() {
+                let _ = std::fs::create_dir(&dir);
+            }
+            Some(dir)
+        } else {
+            None
+        }
+    }
+
+    // Config directory contain only configuration files
+    pub fn config_directory() -> Option<PathBuf> {
+        match Self::project_dirs() {
+            Some(dir) => {
+                let dir = dir.config_dir();
+                if !dir.exists() {
+                    let _ = std::fs::create_dir_all(dir);
+                }
+                Some(dir.to_path_buf())
+            }
+            None => None,
+        }
+    }
+
+    pub fn local_socket() -> Option<PathBuf> {
+        Self::data_local_directory().map(|dir| dir.join("local.sock"))
+    }
+
+    pub fn updates_directory() -> Option<PathBuf> {
+        if let Some(dir) = Self::data_local_directory() {
+            let dir = dir.join("updates");
+            if !dir.exists() {
+                let _ = std::fs::create_dir(&dir);
+            }
+            Some(dir)
+        } else {
+            None
+        }
+    }
+}
diff --git a/lapce-core/src/editor.rs b/lapce-core/src/editor.rs
index e8ef3dfe89..87275c833e 100644
--- a/lapce-core/src/editor.rs
+++ b/lapce-core/src/editor.rs
@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 
 use itertools::Itertools;
-use xi_rope::RopeDelta;
+use lapce_xi_rope::RopeDelta;
 
 use crate::{
     buffer::{Buffer, InvalLines},
@@ -11,26 +11,67 @@ use crate::{
     register::{Clipboard, Register, RegisterData, RegisterKind},
     selection::{InsertDrift, SelRegion, Selection},
     syntax::{
-        has_unmatched_pair, matching_char, matching_pair_direction,
-        str_is_pair_left, str_matching_pair, Syntax,
+        edit::SyntaxEdit,
+        util::{
+            has_unmatched_pair, matching_char, matching_pair_direction,
+            str_is_pair_left, str_matching_pair,
+        },
+        Syntax,
     },
-    word::{get_word_property, WordProperty},
+    word::{get_char_property, CharClassification},
 };
+fn format_start_end(
+    buffer: &Buffer,
+    start: usize,
+    end: usize,
+    is_vertical: bool,
+    first_non_blank: bool,
+) -> (usize, usize) {
+    if is_vertical {
+        let start_line = buffer.line_of_offset(start.min(end));
+        let end_line = buffer.line_of_offset(end.max(start));
+        let start = if first_non_blank {
+            buffer.first_non_blank_character_on_line(start_line)
+        } else {
+            buffer.offset_of_line(start_line)
+        };
+        let end = buffer.offset_of_line(end_line + 1);
+        (start, end)
+    } else {
+        let s = start.min(end);
+        let e = start.max(end);
+        (s, e)
+    }
+}
 
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum EditType {
-    Other,
     InsertChars,
-    InsertNewline,
     Delete,
+    DeleteSelection,
+    InsertNewline,
+    Cut,
+    Paste,
+    Indent,
+    Outdent,
+    ToggleComment,
+    MoveLine,
+    Completion,
+    DeleteWord,
+    DeleteToBeginningOfLine,
+    DeleteToEndOfLine,
+    DeleteToEndOfLineAndInsert,
+    MotionDelete,
     Undo,
     Redo,
+    Other,
 }
 
 impl EditType {
     /// Checks whether a new undo group should be created between two edits.
     pub fn breaks_undo_group(self, previous: EditType) -> bool {
-        self == EditType::Other || self != previous
+        !((self == EditType::InsertChars || self == EditType::Delete)
+            && self == previous)
     }
 }
 
@@ -42,15 +83,16 @@ impl Editor {
         buffer: &mut Buffer,
         s: &str,
         syntax: Option<&Syntax>,
-    ) -> Vec<(RopeDelta, InvalLines)> {
+        auto_closing_matching_pairs: bool,
+    ) -> Vec<(RopeDelta, InvalLines, SyntaxEdit)> {
         let mut deltas = Vec::new();
         if let CursorMode::Insert(selection) = &cursor.mode {
             if s.chars().count() != 1 {
-                let (delta, inval_lines) =
+                let (delta, inval_lines, edits) =
                     buffer.edit(&[(selection, s)], EditType::InsertChars);
                 let selection =
                     selection.apply_delta(&delta, true, InsertDrift::Default);
-                deltas.push((delta, inval_lines));
+                deltas.push((delta, inval_lines, edits));
                 cursor.mode = CursorMode::Insert(selection);
             } else {
                 let c = s.chars().next().unwrap();
@@ -66,9 +108,37 @@ impl Editor {
                 for (idx, region) in selection.regions_mut().iter_mut().enumerate() {
                     let offset = region.end;
                     let cursor_char = buffer.char_at_offset(offset);
+                    let prev_offset = buffer.move_left(offset, Mode::Normal, 1);
+                    let prev_cursor_char = if prev_offset < offset {
+                        buffer.char_at_offset(prev_offset)
+                    } else {
+                        None
+                    };
 
-                    if matching_pair_type == Some(false) {
-                        if cursor_char == Some(c) {
+                    // when text is selected, and [,{,(,'," is inserted
+                    // wrap the text with that char and its corresponding closing pair
+                    if region.start != region.end
+                        && (matching_pair_type == Some(true)
+                            || c == '"'
+                            || c == '\'')
+                    {
+                        edits.push((
+                            Selection::region(region.min(), region.min()),
+                            c.to_string(),
+                        ));
+                        edits_after.push((
+                            idx,
+                            match c {
+                                '"' => '"',
+                                '\'' => '\'',
+                                _ => matching_char(c).unwrap(),
+                            },
+                        ));
+                        continue;
+                    }
+
+                    if auto_closing_matching_pairs {
+                        if (c == '"' || c == '\'') && cursor_char == Some(c) {
                             // Skip the closing character
                             let new_offset =
                                 buffer.next_grapheme_offset(offset, 1, buffer.len());
@@ -77,49 +147,86 @@ impl Editor {
                             continue;
                         }
 
-                        let line = buffer.line_of_offset(offset);
-                        let line_start = buffer.offset_of_line(line);
-                        if buffer.slice_to_cow(line_start..offset).trim() == "" {
-                            let opening_character = matching_char(c).unwrap();
-                            if let Some(previous_offset) = buffer.previous_unmatched(
-                                syntax,
-                                opening_character,
-                                offset,
-                            ) {
-                                // Auto-indent closing character to the same level as the opening.
-                                let previous_line =
-                                    buffer.line_of_offset(previous_offset);
-                                let line_indent =
-                                    buffer.indent_on_line(previous_line);
-
-                                let current_selection =
-                                    Selection::region(line_start, offset);
-
-                                edits.push((
-                                    current_selection,
-                                    format!("{line_indent}{c}"),
-                                ));
+                        if matching_pair_type == Some(false) {
+                            if cursor_char == Some(c) {
+                                // Skip the closing character
+                                let new_offset = buffer.next_grapheme_offset(
+                                    offset,
+                                    1,
+                                    buffer.len(),
+                                );
+
+                                *region = SelRegion::caret(new_offset);
                                 continue;
                             }
-                        }
-                    }
 
-                    if matching_pair_type == Some(true) {
-                        // Create a late edit to insert the closing pair, if allowed.
-                        let is_whitespace_or_punct = cursor_char
-                            .map(|c| {
-                                let prop = get_word_property(c);
-                                prop == WordProperty::Lf
-                                    || prop == WordProperty::Space
-                                    || prop == WordProperty::Punctuation
-                            })
-                            .unwrap_or(true);
-
-                        if is_whitespace_or_punct {
-                            let insert_after = matching_char(c).unwrap();
-                            edits_after.push((idx, insert_after));
+                            let line = buffer.line_of_offset(offset);
+                            let line_start = buffer.offset_of_line(line);
+                            if buffer.slice_to_cow(line_start..offset).trim() == "" {
+                                let opening_character = matching_char(c).unwrap();
+                                if let Some(previous_offset) = buffer
+                                    .previous_unmatched(
+                                        syntax,
+                                        opening_character,
+                                        offset,
+                                    )
+                                {
+                                    // Auto-indent closing character to the same level as the opening.
+                                    let previous_line =
+                                        buffer.line_of_offset(previous_offset);
+                                    let line_indent =
+                                        buffer.indent_on_line(previous_line);
+
+                                    let current_selection =
+                                        Selection::region(line_start, offset);
+
+                                    edits.push((
+                                        current_selection,
+                                        format!("{line_indent}{c}"),
+                                    ));
+                                    continue;
+                                }
+                            }
                         }
-                    };
+
+                        if matching_pair_type == Some(true) || c == '"' || c == '\''
+                        {
+                            // Create a late edit to insert the closing pair, if allowed.
+                            let is_whitespace_or_punct = cursor_char
+                                .map(|c| {
+                                    let prop = get_char_property(c);
+                                    prop == CharClassification::Lf
+                                        || prop == CharClassification::Space
+                                        || prop == CharClassification::Punctuation
+                                })
+                                .unwrap_or(true);
+
+                            let should_insert_pair = match c {
+                                '"' | '\'' => {
+                                    is_whitespace_or_punct
+                                        && prev_cursor_char
+                                            .map(|c| {
+                                                let prop = get_char_property(c);
+                                                prop == CharClassification::Lf
+                                                    || prop == CharClassification::Space
+                                                    || prop
+                                                        == CharClassification::Punctuation
+                                            })
+                                            .unwrap_or(true)
+                                }
+                                _ => is_whitespace_or_punct,
+                            };
+
+                            if should_insert_pair {
+                                let insert_after = match c {
+                                    '"' => '"',
+                                    '\'' => '\'',
+                                    _ => matching_char(c).unwrap(),
+                                };
+                                edits_after.push((idx, insert_after));
+                            }
+                        };
+                    }
 
                     let current_selection =
                         Selection::region(region.start, region.end);
@@ -133,7 +240,7 @@ impl Editor {
                     .map(|(selection, content)| (selection, content.as_str()))
                     .collect::<Vec<_>>();
 
-                let (delta, inval_lines) =
+                let (delta, inval_lines, edits) =
                     buffer.edit(&edits, EditType::InsertChars);
 
                 buffer.set_cursor_before(CursorMode::Insert(selection.clone()));
@@ -144,14 +251,14 @@ impl Editor {
 
                 buffer.set_cursor_after(CursorMode::Insert(selection.clone()));
 
-                deltas.push((delta, inval_lines));
+                deltas.push((delta, inval_lines, edits));
                 // Apply late edits
                 let edits_after = edits_after
                     .iter()
                     .map(|(idx, content)| {
                         let region = &selection.regions()[*idx];
                         (
-                            Selection::region(region.start, region.end),
+                            Selection::region(region.max(), region.max()),
                             content.to_string(),
                         )
                     })
@@ -163,17 +270,17 @@ impl Editor {
                     .collect::<Vec<_>>();
 
                 if !edits_after.is_empty() {
-                    let (delta, inval_lines) =
+                    let (delta, inval_lines, edits) =
                         buffer.edit(&edits_after, EditType::InsertChars);
-                    deltas.push((delta, inval_lines));
+                    deltas.push((delta, inval_lines, edits));
                 }
 
                 // Adjust selection according to previous late edits
                 let mut adjustment = 0;
                 for region in selection.regions_mut().iter_mut().sorted_by(
-                    |region_a, region_b| region_a.start().cmp(&region_b.start()),
+                    |region_a, region_b| region_a.start.cmp(&region_b.start),
                 ) {
-                    *region = SelRegion::new(
+                    let new_region = SelRegion::new(
                         region.start + adjustment,
                         region.end + adjustment,
                         None,
@@ -181,8 +288,8 @@ impl Editor {
 
                     if let Some(inserted) =
                         edits_after.iter().find_map(|(selection, str)| {
-                            if selection.last_inserted().map(|r| r.start())
-                                == Some(region.start())
+                            if selection.last_inserted().map(|r| r.start)
+                                == Some(region.start)
                             {
                                 Some(str)
                             } else {
@@ -192,6 +299,8 @@ impl Editor {
                     {
                         adjustment += inserted.len();
                     }
+
+                    *region = new_region;
                 }
 
                 cursor.mode = CursorMode::Insert(selection);
@@ -232,9 +341,8 @@ impl Editor {
         buffer: &mut Buffer,
         cursor: &mut Cursor,
         selection: Selection,
-    ) -> Vec<(RopeDelta, InvalLines)> {
-        let mut deltas = Vec::new();
-        let mut edits = Vec::new();
+    ) -> Vec<(RopeDelta, InvalLines, SyntaxEdit)> {
+        let mut edits = Vec::with_capacity(selection.regions().len());
         let mut extra_edits = Vec::new();
         let mut shift = 0i32;
         for region in selection.regions() {
@@ -243,46 +351,47 @@ impl Editor {
             let line_start = buffer.offset_of_line(line);
             let line_end = buffer.line_end_offset(line, true);
             let line_indent = buffer.indent_on_line(line);
-            let first_half = buffer.slice_to_cow(line_start..offset).to_string();
-            let second_half = buffer.slice_to_cow(offset..line_end).to_string();
-
-            let indent = if has_unmatched_pair(&first_half) {
-                format!("{}{}", line_indent, buffer.indent_unit())
-            } else if second_half.trim().is_empty() {
-                let next_line_indent = buffer.indent_on_line(line + 1);
-                if next_line_indent.len() > line_indent.len() {
-                    next_line_indent
+            let first_half = buffer.slice_to_cow(line_start..offset);
+            let second_half = buffer.slice_to_cow(offset..line_end);
+            let second_half = second_half.trim();
+
+            let new_line_content = {
+                let indent_storage;
+                let indent = if has_unmatched_pair(&first_half) {
+                    indent_storage =
+                        format!("{}{}", line_indent, buffer.indent_unit());
+                    &indent_storage
+                } else if second_half.is_empty() {
+                    indent_storage = buffer.indent_on_line(line + 1);
+                    if indent_storage.len() > line_indent.len() {
+                        &indent_storage
+                    } else {
+                        &line_indent
+                    }
                 } else {
-                    line_indent.clone()
-                }
-            } else {
-                line_indent.clone()
+                    &line_indent
+                };
+                format!("\n{indent}")
             };
 
             let selection = Selection::region(region.min(), region.max());
-            let content = format!("{}{}", "\n", indent);
 
             shift -= (region.max() - region.min()) as i32;
-            shift += content.len() as i32;
-
-            edits.push((selection, content));
-
-            for c in first_half.chars().rev() {
-                if c != ' ' {
-                    if let Some(pair_start) = matching_pair_direction(c) {
-                        if pair_start {
-                            if let Some(c) = matching_char(c) {
-                                if second_half.trim().starts_with(&c.to_string()) {
-                                    let selection = Selection::caret(
-                                        (region.max() as i32 + shift) as usize,
-                                    );
-                                    let content = format!("{}{}", "\n", line_indent);
-                                    extra_edits.push((selection.clone(), content));
-                                }
-                            }
+            shift += new_line_content.len() as i32;
+
+            edits.push((selection, new_line_content));
+
+            if let Some(c) = first_half.chars().rev().find(|&c| c != ' ') {
+                if let Some(true) = matching_pair_direction(c) {
+                    if let Some(c) = matching_char(c) {
+                        if second_half.starts_with(c) {
+                            let selection = Selection::caret(
+                                (region.max() as i32 + shift) as usize,
+                            );
+                            let content = format!("\n{line_indent}");
+                            extra_edits.push((selection, content));
                         }
                     }
-                    break;
                 }
             }
         }
@@ -290,20 +399,23 @@ impl Editor {
         let edits = edits
             .iter()
             .map(|(selection, s)| (selection, s.as_str()))
-            .collect::<Vec<(&Selection, &str)>>();
-        let (delta, inval_lines) = buffer.edit(&edits, EditType::InsertNewline);
+            .collect::<Vec<_>>();
+        let (delta, inval_lines, edits) =
+            buffer.edit(&edits, EditType::InsertNewline);
         let mut selection =
             selection.apply_delta(&delta, true, InsertDrift::Default);
-        deltas.push((delta, inval_lines));
+
+        let mut deltas = vec![(delta, inval_lines, edits)];
 
         if !extra_edits.is_empty() {
             let edits = extra_edits
                 .iter()
                 .map(|(selection, s)| (selection, s.as_str()))
-                .collect::<Vec<(&Selection, &str)>>();
-            let (delta, inval_lines) = buffer.edit(&edits, EditType::InsertNewline);
+                .collect::<Vec<_>>();
+            let (delta, inval_lines, edits) =
+                buffer.edit(&edits, EditType::InsertNewline);
             selection = selection.apply_delta(&delta, false, InsertDrift::Default);
-            deltas.push((delta, inval_lines));
+            deltas.push((delta, inval_lines, edits));
         }
 
         cursor.mode = CursorMode::Insert(selection);
@@ -319,30 +431,12 @@ impl Editor {
         end: usize,
         is_vertical: bool,
         register: &mut Register,
-    ) -> Vec<(RopeDelta, InvalLines)> {
-        fn format_start_end(
-            buffer: &Buffer,
-            start: usize,
-            end: usize,
-            is_vertical: bool,
-        ) -> (usize, usize) {
-            if is_vertical {
-                let start_line = buffer.line_of_offset(start.min(end));
-                let end_line = buffer.line_of_offset(end.max(start));
-                let start = buffer.offset_of_line(start_line);
-                let end = buffer.offset_of_line(end_line + 1);
-                (start, end)
-            } else {
-                let s = start.min(end);
-                let e = start.max(end);
-                (s, e)
-            }
-        }
-
+    ) -> Vec<(RopeDelta, InvalLines, SyntaxEdit)> {
         let mut deltas = Vec::new();
         match motion_mode {
             MotionMode::Delete => {
-                let (start, end) = format_start_end(buffer, start, end, is_vertical);
+                let (start, end) =
+                    format_start_end(buffer, start, end, is_vertical, false);
                 register.add(
                     RegisterKind::Delete,
                     RegisterData {
@@ -355,13 +449,14 @@ impl Editor {
                     },
                 );
                 let selection = Selection::region(start, end);
-                let (delta, inval_lines) =
-                    buffer.edit(&[(&selection, "")], EditType::Delete);
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], EditType::MotionDelete);
                 cursor.apply_delta(&delta);
-                deltas.push((delta, inval_lines));
+                deltas.push((delta, inval_lines, edits));
             }
             MotionMode::Yank => {
-                let (start, end) = format_start_end(buffer, start, end, is_vertical);
+                let (start, end) =
+                    format_start_end(buffer, start, end, is_vertical, false);
                 register.add(
                     RegisterKind::Yank,
                     RegisterData {
@@ -376,13 +471,14 @@ impl Editor {
             }
             MotionMode::Indent => {
                 let selection = Selection::region(start, end);
-                let (delta, inval_lines) = Self::do_indent(buffer, selection);
-                deltas.push((delta, inval_lines));
+                let (delta, inval_lines, edits) = Self::do_indent(buffer, selection);
+                deltas.push((delta, inval_lines, edits));
             }
             MotionMode::Outdent => {
                 let selection = Selection::region(start, end);
-                let (delta, inval_lines) = Self::do_outdent(buffer, selection);
-                deltas.push((delta, inval_lines));
+                let (delta, inval_lines, edits) =
+                    Self::do_outdent(buffer, selection);
+                deltas.push((delta, inval_lines, edits));
             }
         }
         deltas
@@ -392,7 +488,7 @@ impl Editor {
         cursor: &mut Cursor,
         buffer: &mut Buffer,
         data: &RegisterData,
-    ) -> Vec<(RopeDelta, InvalLines)> {
+    ) -> Vec<(RopeDelta, InvalLines, SyntaxEdit)> {
         let mut deltas = Vec::new();
         match data.mode {
             VisualMode::Normal => {
@@ -407,11 +503,11 @@ impl Editor {
                     }
                 };
                 let after = cursor.is_insert() || !data.content.contains('\n');
-                let (delta, inval_lines) = buffer
-                    .edit(&[(&selection, &data.content)], EditType::InsertChars);
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, &data.content)], EditType::Paste);
                 let selection =
                     selection.apply_delta(&delta, after, InsertDrift::Default);
-                deltas.push((delta, inval_lines));
+                deltas.push((delta, inval_lines, edits));
                 if !after {
                     cursor.update_selection(buffer, selection);
                 } else {
@@ -458,14 +554,14 @@ impl Editor {
                         (selection, data)
                     }
                 };
-                let (delta, inval_lines) =
-                    buffer.edit(&[(&selection, &content)], EditType::InsertChars);
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, &content)], EditType::Paste);
                 let selection = selection.apply_delta(
                     &delta,
                     cursor.is_insert(),
                     InsertDrift::Default,
                 );
-                deltas.push((delta, inval_lines));
+                deltas.push((delta, inval_lines, edits));
                 match cursor.mode {
                     CursorMode::Normal(_) | CursorMode::Visual { .. } => {
                         let offset = selection.min_offset();
@@ -490,7 +586,7 @@ impl Editor {
     fn do_indent(
         buffer: &mut Buffer,
         selection: Selection,
-    ) -> (RopeDelta, InvalLines) {
+    ) -> (RopeDelta, InvalLines, SyntaxEdit) {
         let indent = buffer.indent_unit();
         let mut edits = Vec::new();
 
@@ -505,27 +601,25 @@ impl Editor {
                 }
             }
             for line in start_line..=end_line {
-                if lines.contains(&line) {
-                    continue;
-                }
-                lines.insert(line);
-                let line_content = buffer.line_content(line);
-                if line_content == "\n" || line_content == "\r\n" {
-                    continue;
+                if lines.insert(line) {
+                    let line_content = buffer.line_content(line);
+                    if line_content == "\n" || line_content == "\r\n" {
+                        continue;
+                    }
+                    let nonblank = buffer.first_non_blank_character_on_line(line);
+                    let edit = crate::indent::create_edit(buffer, nonblank, indent);
+                    edits.push(edit);
                 }
-                let nonblank = buffer.first_non_blank_character_on_line(line);
-                let edit = crate::indent::create_edit(buffer, nonblank, indent);
-                edits.push(edit);
             }
         }
 
-        buffer.edit(&edits, EditType::InsertChars)
+        buffer.edit(&edits, EditType::Indent)
     }
 
     fn do_outdent(
         buffer: &mut Buffer,
         selection: Selection,
-    ) -> (RopeDelta, InvalLines) {
+    ) -> (RopeDelta, InvalLines, SyntaxEdit) {
         let indent = buffer.indent_unit();
         let mut edits = Vec::new();
 
@@ -540,24 +634,68 @@ impl Editor {
                 }
             }
             for line in start_line..=end_line {
-                if lines.contains(&line) {
-                    continue;
-                }
-                lines.insert(line);
-                let line_content = buffer.line_content(line);
-                if line_content == "\n" || line_content == "\r\n" {
-                    continue;
-                }
-                let nonblank = buffer.first_non_blank_character_on_line(line);
-                if let Some(edit) =
-                    crate::indent::create_outdent(buffer, nonblank, indent)
-                {
-                    edits.push(edit);
+                if lines.insert(line) {
+                    let line_content = buffer.line_content(line);
+                    if line_content == "\n" || line_content == "\r\n" {
+                        continue;
+                    }
+                    let nonblank = buffer.first_non_blank_character_on_line(line);
+                    if let Some(edit) =
+                        crate::indent::create_outdent(buffer, nonblank, indent)
+                    {
+                        edits.push(edit);
+                    }
                 }
             }
         }
 
-        buffer.edit(&edits, EditType::Delete)
+        buffer.edit(&edits, EditType::Outdent)
+    }
+
+    fn duplicate_line(
+        cursor: &mut Cursor,
+        buffer: &mut Buffer,
+        direction: DuplicateDirection,
+    ) -> Vec<(RopeDelta, InvalLines, SyntaxEdit)> {
+        // TODO other modes
+        let selection = match cursor.mode {
+            CursorMode::Insert(ref mut sel) => sel,
+            _ => return vec![],
+        };
+
+        let mut line_ranges = HashSet::new();
+        for region in selection.regions_mut() {
+            let start_line = buffer.line_of_offset(region.start);
+            let end_line = buffer.line_of_offset(region.end) + 1;
+
+            line_ranges.insert(start_line..end_line);
+        }
+
+        let mut edits = vec![];
+        for range in line_ranges {
+            let start = buffer.offset_of_line(range.start);
+            let end = buffer.offset_of_line(range.end);
+
+            let content = buffer.slice_to_cow(start..end).into_owned();
+            edits.push((
+                match direction {
+                    DuplicateDirection::Up => Selection::caret(end),
+                    DuplicateDirection::Down => Selection::caret(start),
+                },
+                content,
+            ));
+        }
+
+        let edits = edits
+            .iter()
+            .map(|(sel, content)| (sel, content.as_str()))
+            .collect::<Vec<_>>();
+
+        let (delta, inval_lines, edits) = buffer.edit(&edits, EditType::InsertChars);
+
+        *selection = selection.apply_delta(&delta, true, InsertDrift::Default);
+
+        vec![(delta, inval_lines, edits)]
     }
 
     pub fn do_edit<T: Clipboard>(
@@ -568,7 +706,7 @@ impl Editor {
         clipboard: &mut T,
         modal: bool,
         register: &mut Register,
-    ) -> Vec<(RopeDelta, InvalLines)> {
+    ) -> Vec<(RopeDelta, InvalLines, SyntaxEdit)> {
         use crate::command::EditCommand::*;
         match cmd {
             MoveLineUp => {
@@ -585,7 +723,7 @@ impl Editor {
                             let end = buffer.offset_of_line(end_line + 1);
                             let content =
                                 buffer.slice_to_cow(start..end).to_string();
-                            let (delta, inval_lines) = buffer.edit(
+                            let (delta, inval_lines, edits) = buffer.edit(
                                 &[
                                     (&Selection::region(start, end), ""),
                                     (
@@ -595,9 +733,9 @@ impl Editor {
                                         &content,
                                     ),
                                 ],
-                                EditType::InsertChars,
+                                EditType::MoveLine,
                             );
-                            deltas.push((delta, inval_lines));
+                            deltas.push((delta, inval_lines, edits));
                             region.start -= previous_line_len;
                             region.end -= previous_line_len;
                         }
@@ -621,7 +759,7 @@ impl Editor {
                             let end = buffer.offset_of_line(end_line + 1);
                             let content =
                                 buffer.slice_to_cow(start..end).to_string();
-                            let (delta, inval_lines) = buffer.edit(
+                            let (delta, inval_lines, edits) = buffer.edit(
                                 &[
                                     (
                                         &Selection::caret(
@@ -631,9 +769,9 @@ impl Editor {
                                     ),
                                     (&Selection::region(start, end), ""),
                                 ],
-                                EditType::InsertChars,
+                                EditType::MoveLine,
                             );
-                            deltas.push((delta, inval_lines));
+                            deltas.push((delta, inval_lines, edits));
                             region.start += next_line_len;
                             region.end += next_line_len;
                         }
@@ -683,20 +821,20 @@ impl Editor {
                         }
                     }
 
-                    let (delta, inval_lines) =
+                    let (delta, inval_lines, edits) =
                         buffer.edit(&edits, EditType::InsertChars);
                     let selection =
                         selection.apply_delta(&delta, true, InsertDrift::Default);
-                    deltas.push((delta, inval_lines));
+                    deltas.push((delta, inval_lines, edits));
                     cursor.mode = CursorMode::Insert(selection);
                 }
                 deltas
             }
             IndentLine => {
                 let selection = cursor.edit_selection(buffer);
-                let (delta, inval_lines) = Self::do_indent(buffer, selection);
+                let (delta, inval_lines, edits) = Self::do_indent(buffer, selection);
                 cursor.apply_delta(&delta);
-                vec![(delta, inval_lines)]
+                vec![(delta, inval_lines, edits)]
             }
             JoinLines => {
                 let offset = cursor.offset();
@@ -714,9 +852,10 @@ impl Editor {
             }
             OutdentLine => {
                 let selection = cursor.edit_selection(buffer);
-                let (delta, inval_lines) = Self::do_outdent(buffer, selection);
+                let (delta, inval_lines, edits) =
+                    Self::do_outdent(buffer, selection);
                 cursor.apply_delta(&delta);
-                vec![(delta, inval_lines)]
+                vec![(delta, inval_lines, edits)]
             }
             ToggleLineComment => {
                 let mut lines = HashSet::new();
@@ -745,7 +884,7 @@ impl Editor {
                         if indent < smallest_indent {
                             smallest_indent = indent;
                         }
-                        if !trimmed_content.starts_with(&comment_token) {
+                        if !trimmed_content.starts_with(comment_token) {
                             had_comment = false;
                             lines.insert((line, indent, 0));
                         } else {
@@ -756,14 +895,14 @@ impl Editor {
                                 line,
                                 indent,
                                 comment_token.len()
-                                    + if had_space_after_comment { 1 } else { 0 },
+                                    + usize::from(had_space_after_comment),
                             ));
                         }
                         line += 1;
                     }
                 }
 
-                let (delta, inval_lines) = if had_comment {
+                let (delta, inval_lines, edits) = if had_comment {
                     let mut selection = Selection::new();
                     for (line, indent, len) in lines.iter() {
                         let start = buffer.offset_of_line(*line) + indent;
@@ -773,7 +912,7 @@ impl Editor {
                             None,
                         ))
                     }
-                    buffer.edit(&[(&selection, "")], EditType::Delete)
+                    buffer.edit(&[(&selection, "")], EditType::ToggleComment)
                 } else {
                     let mut selection = Selection::new();
                     for (line, _, _) in lines.iter() {
@@ -782,20 +921,26 @@ impl Editor {
                     }
                     buffer.edit(
                         &[(&selection, &format!("{comment_token} "))],
-                        EditType::InsertChars,
+                        EditType::ToggleComment,
                     )
                 };
                 cursor.apply_delta(&delta);
-                vec![(delta, inval_lines)]
+                vec![(delta, inval_lines, edits)]
             }
             Undo => {
-                if let Some((delta, inval_lines, cursor_mode)) = buffer.do_undo() {
+                if let Some((delta, inval_lines, edits, cursor_mode)) =
+                    buffer.do_undo()
+                {
                     if let Some(cursor_mode) = cursor_mode {
-                        if modal {
-                            cursor.mode = CursorMode::Normal(cursor_mode.offset());
+                        cursor.mode = if modal {
+                            CursorMode::Normal(cursor_mode.offset())
+                        } else if cursor.is_insert() {
+                            cursor_mode
                         } else {
-                            cursor.mode = cursor_mode;
-                        }
+                            CursorMode::Insert(Selection::caret(
+                                cursor_mode.offset(),
+                            ))
+                        };
                     } else if let Some(new_cursor) =
                         get_first_selection_after(cursor, buffer, &delta)
                     {
@@ -803,19 +948,25 @@ impl Editor {
                     } else {
                         cursor.apply_delta(&delta);
                     }
-                    vec![(delta, inval_lines)]
+                    vec![(delta, inval_lines, edits)]
                 } else {
                     vec![]
                 }
             }
             Redo => {
-                if let Some((delta, inval_lines, cursor_mode)) = buffer.do_redo() {
+                if let Some((delta, inval_lines, edits, cursor_mode)) =
+                    buffer.do_redo()
+                {
                     if let Some(cursor_mode) = cursor_mode {
-                        if modal {
-                            cursor.mode = CursorMode::Normal(cursor_mode.offset());
+                        cursor.mode = if modal {
+                            CursorMode::Normal(cursor_mode.offset())
+                        } else if cursor.is_insert() {
+                            cursor_mode
                         } else {
-                            cursor.mode = cursor_mode;
-                        }
+                            CursorMode::Insert(Selection::caret(
+                                cursor_mode.offset(),
+                            ))
+                        };
                     } else if let Some(new_cursor) =
                         get_first_selection_after(cursor, buffer, &delta)
                     {
@@ -823,7 +974,7 @@ impl Editor {
                     } else {
                         cursor.apply_delta(&delta);
                     }
-                    vec![(delta, inval_lines)]
+                    vec![(delta, inval_lines, edits)]
                 } else {
                     vec![]
                 }
@@ -867,12 +1018,12 @@ impl Editor {
                         cursor.edit_selection(buffer)
                     };
 
-                let (delta, inval_lines) =
-                    buffer.edit(&[(&selection, "")], EditType::Delete);
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], EditType::Cut);
                 let selection =
                     selection.apply_delta(&delta, true, InsertDrift::Default);
                 cursor.update_selection(buffer, selection);
-                vec![(delta, inval_lines)]
+                vec![(delta, inval_lines, edits)]
             }
             ClipboardPaste => {
                 if let Some(s) = clipboard.get_string() {
@@ -907,6 +1058,14 @@ impl Editor {
                 let data = register.unnamed.clone();
                 Self::do_paste(cursor, buffer, &data)
             }
+            PasteBefore => {
+                let offset = cursor.offset();
+                let data = register.unnamed.clone();
+                let mut local_cursor =
+                    Cursor::new(CursorMode::Insert(Selection::new()), None, None);
+                local_cursor.set_offset(offset, false, false);
+                Self::do_paste(&mut local_cursor, buffer, &data)
+            }
             NewLineAbove => {
                 let offset = cursor.offset();
                 let line = buffer.line_of_offset(offset);
@@ -928,13 +1087,21 @@ impl Editor {
                 Self::insert_new_line(buffer, cursor, Selection::caret(offset))
             }
             DeleteBackward => {
-                let selection = match cursor.mode {
-                    CursorMode::Normal(_) | CursorMode::Visual { .. } => {
-                        cursor.edit_selection(buffer)
+                let (selection, edit_type) = match cursor.mode {
+                    CursorMode::Normal(_) => {
+                        (cursor.edit_selection(buffer), EditType::Delete)
+                    }
+                    CursorMode::Visual { .. } => {
+                        (cursor.edit_selection(buffer), EditType::DeleteSelection)
                     }
                     CursorMode::Insert(_) => {
-                        let indent = buffer.indent_unit();
                         let selection = cursor.edit_selection(buffer);
+                        let edit_type = if selection.is_caret() {
+                            EditType::Delete
+                        } else {
+                            EditType::DeleteSelection
+                        };
+                        let indent = buffer.indent_unit();
                         let mut new_selection = Selection::new();
                         for region in selection.regions() {
                             let new_region = if region.is_caret() {
@@ -982,8 +1149,16 @@ impl Editor {
                                     selection.min_offset()..selection.max_offset(),
                                 )
                                 .to_string();
-                            if str_is_pair_left(&delete_str) {
-                                if let Some(c) = str_matching_pair(&delete_str) {
+                            if str_is_pair_left(&delete_str)
+                                || delete_str == "\""
+                                || delete_str == "'"
+                            {
+                                let matching_char = match delete_str.as_str() {
+                                    "\"" => Some('"'),
+                                    "'" => Some('\''),
+                                    _ => str_matching_pair(&delete_str),
+                                };
+                                if let Some(c) = matching_char {
                                     let offset = selection.max_offset();
                                     let line = buffer.line_of_offset(offset);
                                     let line_end =
@@ -1005,23 +1180,31 @@ impl Editor {
                                 }
                             }
                         }
-                        selection
+                        (selection, edit_type)
                     }
                 };
-                let (delta, inval_lines) =
-                    buffer.edit(&[(&selection, "")], EditType::Delete);
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], edit_type);
                 let selection =
                     selection.apply_delta(&delta, true, InsertDrift::Default);
                 cursor.update_selection(buffer, selection);
-                vec![(delta, inval_lines)]
+                vec![(delta, inval_lines, edits)]
             }
             DeleteForward => {
-                let selection = match cursor.mode {
-                    CursorMode::Normal(_) | CursorMode::Visual { .. } => {
-                        cursor.edit_selection(buffer)
+                let (selection, edit_type) = match cursor.mode {
+                    CursorMode::Normal(_) => {
+                        (cursor.edit_selection(buffer), EditType::Delete)
+                    }
+                    CursorMode::Visual { .. } => {
+                        (cursor.edit_selection(buffer), EditType::DeleteSelection)
                     }
                     CursorMode::Insert(_) => {
                         let selection = cursor.edit_selection(buffer);
+                        let edit_type = if selection.is_caret() {
+                            EditType::Delete
+                        } else {
+                            EditType::DeleteSelection
+                        };
                         let mut new_selection = Selection::new();
                         for region in selection.regions() {
                             let new_region = if region.is_caret() {
@@ -1033,15 +1216,32 @@ impl Editor {
                             };
                             new_selection.add_region(new_region);
                         }
-                        new_selection
+                        (new_selection, edit_type)
                     }
                 };
-                let (delta, inval_lines) =
-                    buffer.edit(&[(&selection, "")], EditType::Delete);
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], edit_type);
                 let selection =
                     selection.apply_delta(&delta, true, InsertDrift::Default);
                 cursor.update_selection(buffer, selection);
-                vec![(delta, inval_lines)]
+                vec![(delta, inval_lines, edits)]
+            }
+            DeleteLine => {
+                let selection = cursor.edit_selection(buffer);
+                let (start, end) = format_start_end(
+                    buffer,
+                    selection.min_offset(),
+                    selection.max_offset(),
+                    true,
+                    true,
+                );
+                let selection = Selection::region(start, end);
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], EditType::Delete);
+                let selection =
+                    selection.apply_delta(&delta, true, InsertDrift::Default);
+                cursor.mode = CursorMode::Insert(selection);
+                vec![(delta, inval_lines, edits)]
             }
             DeleteWordForward => {
                 let selection = match cursor.mode {
@@ -1061,12 +1261,12 @@ impl Editor {
                         new_selection
                     }
                 };
-                let (delta, inval_lines) =
-                    buffer.edit(&[(&selection, "")], EditType::Delete);
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], EditType::DeleteWord);
                 let selection =
                     selection.apply_delta(&delta, true, InsertDrift::Default);
                 cursor.update_selection(buffer, selection);
-                vec![(delta, inval_lines)]
+                vec![(delta, inval_lines, edits)]
             }
             DeleteWordBackward => {
                 let selection = match cursor.mode {
@@ -1078,7 +1278,7 @@ impl Editor {
                         let selection = cursor.edit_selection(buffer);
 
                         for region in selection.regions() {
-                            let end = buffer.move_word_backward(region.end);
+                            let end = buffer.move_word_backward_deletion(region.end);
                             let new_region = SelRegion::new(region.start, end, None);
                             new_selection.add_region(new_region);
                         }
@@ -1086,12 +1286,12 @@ impl Editor {
                         new_selection
                     }
                 };
-                let (delta, inval_lines) =
-                    buffer.edit(&[(&selection, "")], EditType::Delete);
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], EditType::DeleteWord);
                 let selection =
                     selection.apply_delta(&delta, true, InsertDrift::Default);
                 cursor.update_selection(buffer, selection);
-                vec![(delta, inval_lines)]
+                vec![(delta, inval_lines, edits)]
             }
             DeleteToBeginningOfLine => {
                 let selection = match cursor.mode {
@@ -1112,21 +1312,101 @@ impl Editor {
                         new_selection
                     }
                 };
-                let (delta, inval_lines) =
-                    buffer.edit(&[(&selection, "")], EditType::Delete);
+                let (delta, inval_lines, edits) = buffer
+                    .edit(&[(&selection, "")], EditType::DeleteToBeginningOfLine);
                 let selection =
                     selection.apply_delta(&delta, true, InsertDrift::Default);
                 cursor.update_selection(buffer, selection);
-                vec![(delta, inval_lines)]
+                vec![(delta, inval_lines, edits)]
+            }
+            DeleteToEndOfLine => {
+                let selection = match cursor.mode {
+                    CursorMode::Normal(_) | CursorMode::Visual { .. } => {
+                        cursor.edit_selection(buffer)
+                    }
+                    CursorMode::Insert(_) => {
+                        let mut selection = cursor.edit_selection(buffer);
+
+                        let cursor_offset = cursor.offset();
+                        let line = buffer.line_of_offset(cursor_offset);
+                        let end_of_line_offset = buffer.line_end_offset(line, true);
+                        let new_region =
+                            SelRegion::new(cursor_offset, end_of_line_offset, None);
+                        selection.add_region(new_region);
+
+                        selection
+                    }
+                };
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], EditType::DeleteToEndOfLine);
+                let selection =
+                    selection.apply_delta(&delta, true, InsertDrift::Default);
+                cursor.update_selection(buffer, selection);
+                vec![(delta, inval_lines, edits)]
             }
             DeleteForwardAndInsert => {
                 let selection = cursor.edit_selection(buffer);
-                let (delta, inval_lines) =
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], EditType::Delete);
+                let selection =
+                    selection.apply_delta(&delta, true, InsertDrift::Default);
+                cursor.mode = CursorMode::Insert(selection);
+                vec![(delta, inval_lines, edits)]
+            }
+            DeleteWordAndInsert => {
+                let selection = {
+                    let mut new_selection = Selection::new();
+                    let selection = cursor.edit_selection(buffer);
+
+                    for region in selection.regions() {
+                        let end = buffer.move_word_forward(region.end);
+                        let new_region = SelRegion::new(region.start, end, None);
+                        new_selection.add_region(new_region);
+                    }
+
+                    new_selection
+                };
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], EditType::DeleteWord);
+                let selection =
+                    selection.apply_delta(&delta, true, InsertDrift::Default);
+                cursor.mode = CursorMode::Insert(selection);
+                vec![(delta, inval_lines, edits)]
+            }
+            DeleteLineAndInsert => {
+                let selection = cursor.edit_selection(buffer);
+                let (start, end) = format_start_end(
+                    buffer,
+                    selection.min_offset(),
+                    selection.max_offset(),
+                    true,
+                    true,
+                );
+                let selection = Selection::region(start, end - 1); // -1 because we want to keep the line itself
+                let (delta, inval_lines, edits) =
+                    buffer.edit(&[(&selection, "")], EditType::Delete);
+                let selection =
+                    selection.apply_delta(&delta, true, InsertDrift::Default);
+                cursor.mode = CursorMode::Insert(selection);
+                vec![(delta, inval_lines, edits)]
+            }
+            DeleteToEndOfLineAndInsert => {
+                let mut selection = cursor.edit_selection(buffer);
+
+                let cursor_offset = cursor.offset();
+                let line = buffer.line_of_offset(cursor_offset);
+                let end_of_line_offset = buffer.line_end_offset(line, true);
+
+                let new_region =
+                    SelRegion::new(cursor_offset, end_of_line_offset, None);
+                selection.add_region(new_region);
+
+                let (delta, inval_lines, edits) =
                     buffer.edit(&[(&selection, "")], EditType::Delete);
                 let selection =
                     selection.apply_delta(&delta, true, InsertDrift::Default);
                 cursor.mode = CursorMode::Insert(selection);
-                vec![(delta, inval_lines)]
+                vec![(delta, inval_lines, edits)]
             }
             NormalMode => {
                 if !modal {
@@ -1198,7 +1478,13 @@ impl Editor {
                 vec![]
             }
             Append => {
-                let offset = buffer.move_right(cursor.offset(), Mode::Insert, 1);
+                let offset = cursor.offset();
+                let line = buffer.line_of_offset(offset);
+                let line_len = buffer.line_len(line);
+                let count = (line_len > 1
+                    || (buffer.last_line() == line && line_len > 0))
+                    as usize;
+                let offset = buffer.move_right(cursor.offset(), Mode::Insert, count);
                 cursor.mode = CursorMode::Insert(Selection::caret(offset));
                 vec![]
             }
@@ -1221,16 +1507,29 @@ impl Editor {
                 Self::toggle_visual(cursor, VisualMode::Blockwise, modal);
                 vec![]
             }
+            DuplicateLineUp => {
+                Self::duplicate_line(cursor, buffer, DuplicateDirection::Up)
+            }
+            DuplicateLineDown => {
+                Self::duplicate_line(cursor, buffer, DuplicateDirection::Down)
+            }
         }
     }
 }
 
+enum DuplicateDirection {
+    Up,
+    Down,
+}
+
 #[cfg(test)]
 mod test {
-    use crate::buffer::Buffer;
-    use crate::cursor::{Cursor, CursorMode};
-    use crate::editor::Editor;
-    use crate::selection::{SelRegion, Selection};
+    use crate::{
+        buffer::Buffer,
+        cursor::{Cursor, CursorMode},
+        editor::{DuplicateDirection, Editor},
+        selection::{SelRegion, Selection},
+    };
 
     #[test]
     fn test_insert_simple() {
@@ -1238,7 +1537,7 @@ mod test {
         let mut cursor =
             Cursor::new(CursorMode::Insert(Selection::caret(1)), None, None);
 
-        Editor::insert(&mut cursor, &mut buffer, "e", None);
+        Editor::insert(&mut cursor, &mut buffer, "e", None, true);
         assert_eq!("aebc", buffer.slice_to_cow(0..buffer.len()));
     }
 
@@ -1250,7 +1549,7 @@ mod test {
         selection.add_region(SelRegion::caret(5));
         let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
 
-        Editor::insert(&mut cursor, &mut buffer, "i", None);
+        Editor::insert(&mut cursor, &mut buffer, "i", None, true);
         assert_eq!("aibc\neifg\n", buffer.slice_to_cow(0..buffer.len()));
     }
 
@@ -1262,13 +1561,13 @@ mod test {
         selection.add_region(SelRegion::caret(5));
         let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
 
-        Editor::insert(&mut cursor, &mut buffer, "i", None);
+        Editor::insert(&mut cursor, &mut buffer, "i", None, true);
         assert_eq!("aibc\neifg\n", buffer.slice_to_cow(0..buffer.len()));
-        Editor::insert(&mut cursor, &mut buffer, "j", None);
+        Editor::insert(&mut cursor, &mut buffer, "j", None, true);
         assert_eq!("aijbc\neijfg\n", buffer.slice_to_cow(0..buffer.len()));
-        Editor::insert(&mut cursor, &mut buffer, "{", None);
+        Editor::insert(&mut cursor, &mut buffer, "{", None, true);
         assert_eq!("aij{bc\neij{fg\n", buffer.slice_to_cow(0..buffer.len()));
-        Editor::insert(&mut cursor, &mut buffer, " ", None);
+        Editor::insert(&mut cursor, &mut buffer, " ", None, true);
         assert_eq!("aij{ bc\neij{ fg\n", buffer.slice_to_cow(0..buffer.len()));
     }
 
@@ -1280,9 +1579,189 @@ mod test {
         selection.add_region(SelRegion::caret(6));
         let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
 
-        Editor::insert(&mut cursor, &mut buffer, "{", None);
+        Editor::insert(&mut cursor, &mut buffer, "{", None, true);
         assert_eq!("a{} bc\ne{} fg\n", buffer.slice_to_cow(0..buffer.len()));
-        Editor::insert(&mut cursor, &mut buffer, "}", None);
+        Editor::insert(&mut cursor, &mut buffer, "}", None, true);
+        assert_eq!("a{} bc\ne{} fg\n", buffer.slice_to_cow(0..buffer.len()));
+    }
+
+    #[test]
+    fn test_insert_pair_with_selection() {
+        let mut buffer = Buffer::new("a bc\ne fg\n");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::new(0, 4, None));
+        selection.add_region(SelRegion::new(5, 9, None));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+        Editor::insert(&mut cursor, &mut buffer, "{", None, true);
+        assert_eq!("{a bc}\n{e fg}\n", buffer.slice_to_cow(0..buffer.len()));
+    }
+
+    #[test]
+    fn test_insert_pair_without_auto_closing() {
+        let mut buffer = Buffer::new("a bc\ne fg\n");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(1));
+        selection.add_region(SelRegion::caret(6));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+
+        Editor::insert(&mut cursor, &mut buffer, "{", None, false);
+        assert_eq!("a{ bc\ne{ fg\n", buffer.slice_to_cow(0..buffer.len()));
+        Editor::insert(&mut cursor, &mut buffer, "}", None, false);
         assert_eq!("a{} bc\ne{} fg\n", buffer.slice_to_cow(0..buffer.len()));
     }
+
+    #[test]
+    fn duplicate_down_simple() {
+        let mut buffer = Buffer::new("first line\nsecond line\n");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(0));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+
+        Editor::duplicate_line(&mut cursor, &mut buffer, DuplicateDirection::Down);
+
+        assert_ne!(cursor.offset(), 0);
+        assert_eq!(
+            "first line\nfirst line\nsecond line\n",
+            buffer.slice_to_cow(0..buffer.len())
+        );
+    }
+
+    #[test]
+    fn duplicate_up_simple() {
+        let mut buffer = Buffer::new("first line\nsecond line\n");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(0));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+
+        Editor::duplicate_line(&mut cursor, &mut buffer, DuplicateDirection::Up);
+
+        assert_eq!(cursor.offset(), 0);
+        assert_eq!(
+            "first line\nfirst line\nsecond line\n",
+            buffer.slice_to_cow(0..buffer.len())
+        );
+    }
+
+    #[test]
+    fn duplicate_down_multiple_cursors_in_same_line() {
+        let mut buffer = Buffer::new("first line\nsecond line\n");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(0));
+        selection.add_region(SelRegion::caret(1));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+
+        Editor::duplicate_line(&mut cursor, &mut buffer, DuplicateDirection::Down);
+
+        assert_eq!(
+            "first line\nfirst line\nsecond line\n",
+            buffer.slice_to_cow(0..buffer.len())
+        );
+    }
+
+    #[test]
+    fn duplicate_up_multiple_cursors_in_same_line() {
+        let mut buffer = Buffer::new("first line\nsecond line\n");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(0));
+        selection.add_region(SelRegion::caret(1));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+
+        Editor::duplicate_line(&mut cursor, &mut buffer, DuplicateDirection::Up);
+
+        assert_eq!(
+            "first line\nfirst line\nsecond line\n",
+            buffer.slice_to_cow(0..buffer.len())
+        );
+    }
+
+    #[test]
+    fn duplicate_down_multiple() {
+        let mut buffer = Buffer::new("first line\nsecond line\n");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(0));
+        selection.add_region(SelRegion::caret(15));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+
+        Editor::duplicate_line(&mut cursor, &mut buffer, DuplicateDirection::Down);
+
+        assert_eq!(
+            "first line\nfirst line\nsecond line\nsecond line\n",
+            buffer.slice_to_cow(0..buffer.len())
+        );
+    }
+
+    #[test]
+    fn duplicate_up_multiple() {
+        let mut buffer = Buffer::new("first line\nsecond line\n");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(0));
+        selection.add_region(SelRegion::caret(15));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+
+        Editor::duplicate_line(&mut cursor, &mut buffer, DuplicateDirection::Up);
+
+        assert_eq!(
+            "first line\nfirst line\nsecond line\nsecond line\n",
+            buffer.slice_to_cow(0..buffer.len())
+        );
+    }
+
+    #[test]
+    fn duplicate_down_multiple_with_swapped_cursor_order() {
+        let mut buffer = Buffer::new("first line\nsecond line\n");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(15));
+        selection.add_region(SelRegion::caret(0));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+
+        Editor::duplicate_line(&mut cursor, &mut buffer, DuplicateDirection::Down);
+
+        assert_eq!(
+            "first line\nfirst line\nsecond line\nsecond line\n",
+            buffer.slice_to_cow(0..buffer.len())
+        );
+    }
+
+    #[test]
+    fn duplicate_up_multiple_with_swapped_cursor_order() {
+        let mut buffer = Buffer::new("first line\nsecond line\n");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(15));
+        selection.add_region(SelRegion::caret(0));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+
+        Editor::duplicate_line(&mut cursor, &mut buffer, DuplicateDirection::Up);
+
+        assert_eq!(
+            "first line\nfirst line\nsecond line\nsecond line\n",
+            buffer.slice_to_cow(0..buffer.len())
+        );
+    }
+
+    #[test]
+    fn check_multiple_cursor_match_insertion() {
+        let mut buffer = Buffer::new(" 123 567 9ab def");
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(0));
+        selection.add_region(SelRegion::caret(4));
+        selection.add_region(SelRegion::caret(8));
+        selection.add_region(SelRegion::caret(12));
+        let mut cursor = Cursor::new(CursorMode::Insert(selection), None, None);
+
+        Editor::insert(&mut cursor, &mut buffer, "(", None, true);
+
+        assert_eq!(
+            "() 123() 567() 9ab() def",
+            buffer.slice_to_cow(0..buffer.len())
+        );
+
+        let mut end_selection = Selection::new();
+        end_selection.add_region(SelRegion::caret(1));
+        end_selection.add_region(SelRegion::caret(7));
+        end_selection.add_region(SelRegion::caret(13));
+        end_selection.add_region(SelRegion::caret(19));
+        assert_eq!(cursor.mode, CursorMode::Insert(end_selection));
+    }
+
+    // TODO(dbuga): add tests duplicating selections (multiple line blocks)
 }
diff --git a/lapce-core/src/encoding.rs b/lapce-core/src/encoding.rs
new file mode 100644
index 0000000000..17975af394
--- /dev/null
+++ b/lapce-core/src/encoding.rs
@@ -0,0 +1,163 @@
+/// Convert a utf8 offset into a utf16 offset, if possible  
+/// `text` is what the offsets are into
+pub fn offset_utf8_to_utf16(
+    char_indices: impl Iterator<Item = (usize, char)>,
+    offset: usize,
+) -> usize {
+    if offset == 0 {
+        return 0;
+    }
+
+    let mut utf16_offset = 0;
+    let mut last_ich = None;
+    for (utf8_offset, ch) in char_indices {
+        last_ich = Some((utf8_offset, ch));
+
+        match utf8_offset.cmp(&offset) {
+            std::cmp::Ordering::Less => {}
+            // We found the right offset
+            std::cmp::Ordering::Equal => {
+                return utf16_offset;
+            }
+            // Implies that the offset was inside of a character
+            std::cmp::Ordering::Greater => return utf16_offset,
+        }
+
+        utf16_offset += ch.len_utf16();
+    }
+
+    // TODO: We could use TrustedLen when that is stabilized and it is impl'd on
+    // the iterators we use
+
+    // We did not find the offset. This means that it is either at the end
+    // or past the end.
+    let text_len = last_ich.map(|(i, c)| i + c.len_utf8());
+    if text_len == Some(offset) {
+        // Since the utf16 offset was being incremented each time, by now it is equivalent to the length
+        // but in utf16 characters
+        return utf16_offset;
+    }
+
+    utf16_offset
+}
+
+pub fn offset_utf8_to_utf16_str(text: &str, offset: usize) -> usize {
+    offset_utf8_to_utf16(text.char_indices(), offset)
+}
+
+/// Convert a utf16 offset into a utf8 offset, if possible  
+/// `char_indices` is an iterator over utf8 offsets and the characters
+/// It is cloneable so that it can be iterated multiple times. Though it should be cheaply cloneable.
+pub fn offset_utf16_to_utf8(
+    char_indices: impl Iterator<Item = (usize, char)>,
+    offset: usize,
+) -> usize {
+    if offset == 0 {
+        return 0;
+    }
+
+    // We accumulate the utf16 char lens until we find the utf8 offset that matches it
+    // or, we find out that it went into the middle of sometext
+    // We also keep track of the last offset and char in order to calculate the length of the text
+    // if we the index was at the end of the string
+    let mut utf16_offset = 0;
+    let mut last_ich = None;
+    for (utf8_offset, ch) in char_indices {
+        last_ich = Some((utf8_offset, ch));
+
+        let ch_utf16_len = ch.len_utf16();
+
+        match utf16_offset.cmp(&offset) {
+            std::cmp::Ordering::Less => {}
+            // We found the right offset
+            std::cmp::Ordering::Equal => {
+                return utf8_offset;
+            }
+            // This implies that the offset was in the middle of a character as we skipped over it
+            std::cmp::Ordering::Greater => return utf8_offset,
+        }
+
+        utf16_offset += ch_utf16_len;
+    }
+
+    // We did not find the offset, this means that it was either at the end
+    // or past the end
+    // Since we've iterated over all the char indices, the utf16_offset is now the
+    // utf16 length
+    if let Some((last_utf8_offset, last_ch)) = last_ich {
+        last_utf8_offset + last_ch.len_utf8()
+    } else {
+        0
+    }
+}
+
+pub fn offset_utf16_to_utf8_str(text: &str, offset: usize) -> usize {
+    offset_utf16_to_utf8(text.char_indices(), offset)
+}
+
+#[cfg(test)]
+mod tests {
+    // TODO: more tests with unicode characters
+
+    use crate::encoding::{offset_utf16_to_utf8_str, offset_utf8_to_utf16_str};
+
+    #[test]
+    fn utf8_to_utf16() {
+        let text = "hello world";
+
+        assert_eq!(offset_utf8_to_utf16_str(text, 0), 0);
+        assert_eq!(offset_utf8_to_utf16_str("", 0), 0);
+
+        assert_eq!(offset_utf8_to_utf16_str("", 1), 0);
+
+        assert_eq!(offset_utf8_to_utf16_str("h", 0), 0);
+        assert_eq!(offset_utf8_to_utf16_str("h", 1), 1);
+
+        assert_eq!(offset_utf8_to_utf16_str(text, text.len()), text.len());
+
+        assert_eq!(
+            offset_utf8_to_utf16_str(text, text.len() - 1),
+            text.len() - 1
+        );
+
+        assert_eq!(offset_utf8_to_utf16_str(text, text.len() + 1), text.len());
+
+        assert_eq!(offset_utf8_to_utf16_str("×", 0), 0);
+        assert_eq!(offset_utf8_to_utf16_str("×", 1), 1);
+        assert_eq!(offset_utf8_to_utf16_str("×", 2), 1);
+        assert_eq!(offset_utf8_to_utf16_str("a×", 0), 0);
+        assert_eq!(offset_utf8_to_utf16_str("a×", 1), 1);
+        assert_eq!(offset_utf8_to_utf16_str("a×", 2), 2);
+        assert_eq!(offset_utf8_to_utf16_str("a×", 3), 2);
+    }
+
+    #[test]
+    fn utf16_to_utf8() {
+        let text = "hello world";
+
+        assert_eq!(offset_utf16_to_utf8_str(text, 0), 0);
+        assert_eq!(offset_utf16_to_utf8_str("", 0), 0);
+
+        assert_eq!(offset_utf16_to_utf8_str("", 1), 0);
+
+        assert_eq!(offset_utf16_to_utf8_str("h", 0), 0);
+        assert_eq!(offset_utf16_to_utf8_str("h", 1), 1);
+
+        assert_eq!(offset_utf16_to_utf8_str(text, text.len()), text.len());
+
+        assert_eq!(
+            offset_utf16_to_utf8_str(text, text.len() - 1),
+            text.len() - 1
+        );
+
+        assert_eq!(offset_utf16_to_utf8_str(text, text.len() + 1), text.len());
+
+        assert_eq!(offset_utf16_to_utf8_str("×", 0), 0);
+        assert_eq!(offset_utf16_to_utf8_str("×", 1), 2);
+        assert_eq!(offset_utf16_to_utf8_str("a×", 0), 0);
+        assert_eq!(offset_utf16_to_utf8_str("a×", 1), 1);
+        assert_eq!(offset_utf16_to_utf8_str("a×", 2), 3);
+        assert_eq!(offset_utf16_to_utf8_str("×a", 1), 2);
+        assert_eq!(offset_utf16_to_utf8_str("×a", 2), 3);
+    }
+}
diff --git a/lapce-core/src/indent.rs b/lapce-core/src/indent.rs
index 169f7be987..1dc53fb872 100644
--- a/lapce-core/src/indent.rs
+++ b/lapce-core/src/indent.rs
@@ -1,4 +1,4 @@
-use xi_rope::Rope;
+use lapce_xi_rope::Rope;
 
 use crate::{
     buffer::Buffer,
diff --git a/lapce-core/src/language.rs b/lapce-core/src/language.rs
index f3f8af401e..5b5aa5e7e9 100644
--- a/lapce-core/src/language.rs
+++ b/lapce-core/src/language.rs
@@ -1,8 +1,9 @@
-use std::{collections::HashSet, path::Path};
+use std::{collections::HashSet, path::Path, str::FromStr};
 
-use tree_sitter::{Parser, TreeCursor};
+use strum_macros::{Display, EnumString};
+use tree_sitter::TreeCursor;
 
-use crate::style::HighlightConfiguration;
+use crate::syntax::highlight::{HighlightConfiguration, HighlightIssue};
 
 //
 // To add support for an hypothetical language called Foo, for example, using
@@ -41,6 +42,7 @@ use crate::style::HighlightConfiguration;
 //            id: LapceLanguage::Foo,
 //            language: tree_sitter_foo::language,
 //            highlight: tree_sitter_foo::HIGHLIGHT_QUERY,
+//            injection: Some(tree_sitter_foo::INJECTION_QUERY), // or None if there is no injections
 //            comment: "//",
 //            indent: "    ",
 //            code_lens: (&[/* ... */], &[/* ... */]),
@@ -48,7 +50,10 @@ use crate::style::HighlightConfiguration;
 //        },
 //    ];
 //
-// 5. Add a new feature, say "lang-foo", to the lapce-ui crate (see
+// 5. In `syntax/highlight.rs`, add `Foo: "lang-foo",` to the list in the
+//    `declare_language_highlights` macro.
+//
+// 6. Add a new feature, say "lang-foo", to the lapce-ui crate (see
 //    lapce-ui/Cargo.toml).
 //
 //    [features]
@@ -74,15 +79,27 @@ struct SyntaxProperties {
     language: fn() -> tree_sitter::Language,
     /// For most languages, it is `tree_sitter_$crate::HIGHLIGHT_QUERY`.
     highlight: &'static str,
+    /// For most languages, it is `tree_sitter_$crate::INJECTION_QUERY`.
+    /// Though, not all languages have injections.
+    injection: Option<&'static str>,
     /// The comment token.  "#" for python, "//" for rust for example.
     comment: &'static str,
-    /// The indent unit.  "\t" for python, "    " for rust, for example.
+    /// The indent unit.  "  " for javascript, "    " for rust, for example.
     indent: &'static str,
-    /// TODO: someone more knowledgeable please describe what the two lists are.
-    /// Anyway, the second element of the tuple is a "ignore list". See
-    /// `walk_tree`. If unsure, use `DEFAULT_CODE_LENS_LIST` and
+    /// Lists of tree-sitter node types that control how code lenses are built.
+    /// The first is a list of nodes that should be traversed and included in
+    /// the lens, along with thier children. The second is a list of nodes that
+    /// should be excluded from the lens, though they will still be traversed.
+    /// See `walk_tree` for more details.
+    ///
+    /// The tree-sitter playground may be useful when creating these lists:
+    /// https://tree-sitter.github.io/tree-sitter/playground
+    ///
+    /// If unsure, use `DEFAULT_CODE_LENS_LIST` and
     /// `DEFAULT_CODE_LENS_IGNORE_LIST`.
     code_lens: (&'static [&'static str], &'static [&'static str]),
+    /// the tree sitter tag names that can be put in sticky headers
+    sticky_headers: &'static [&'static str],
     /// File name extensions to determine the language.  `["py"]` for python,
     /// `["rs"]` for rust, for example.
     extensions: &'static [&'static str],
@@ -94,87 +111,350 @@ struct SyntaxProperties {
 // Do not assign values to the variants because the number of variants and
 // number of elements in the LANGUAGES array change as different features
 // selected by the cargo build command.
-#[derive(Eq, PartialEq, Hash, Clone, Copy, Debug)]
+#[derive(Eq, PartialEq, Hash, Clone, Copy, Debug, Display, EnumString)]
+#[strum(ascii_case_insensitive)]
 pub enum LapceLanguage {
-    #[cfg(feature = "lang-rust")]
-    Rust,
-    #[cfg(feature = "lang-go")]
-    Go,
-    #[cfg(feature = "lang-javascript")]
-    Javascript,
-    #[cfg(feature = "lang-javascript")]
-    Jsx,
-    #[cfg(feature = "lang-typescript")]
-    Typescript,
-    #[cfg(feature = "lang-typescript")]
-    Tsx,
-    #[cfg(feature = "lang-python")]
-    Python,
-    #[cfg(feature = "lang-toml")]
-    Toml,
-    #[cfg(feature = "lang-php")]
-    Php,
-    #[cfg(feature = "lang-elixir")]
-    Elixir,
+    #[cfg(feature = "lang-bash")]
+    #[strum(serialize = "bash", serialize = "sh")]
+    Bash,
     #[cfg(feature = "lang-c")]
     C,
+    #[cfg(feature = "lang-clojure")]
+    Clojure,
+    #[cfg(feature = "lang-cmake")]
+    Cmake,
     #[cfg(feature = "lang-cpp")]
     Cpp,
-    #[cfg(feature = "lang-json")]
-    Json,
-    #[cfg(feature = "lang-md")]
-    Markdown,
-    #[cfg(feature = "lang-ruby")]
-    Ruby,
-    #[cfg(feature = "lang-html")]
-    Html,
-    #[cfg(feature = "lang-java")]
-    Java,
+    #[cfg(feature = "lang-csharp")]
+    Csharp,
+    #[cfg(feature = "lang-css")]
+    Css,
+    #[cfg(feature = "lang-d")]
+    D,
+    #[cfg(feature = "lang-dart")]
+    Dart,
+    #[cfg(feature = "lang-dockerfile")]
+    Dockerfile,
+    #[cfg(feature = "lang-elixir")]
+    Elixir,
     #[cfg(feature = "lang-elm")]
     Elm,
-    #[cfg(feature = "lang-swift")]
-    Swift,
-    #[cfg(feature = "lang-ql")]
-    QL,
-    #[cfg(feature = "lang-haskell")]
-    Haskell,
+    #[cfg(feature = "lang-erlang")]
+    Erlang,
     #[cfg(feature = "lang-glimmer")]
     Glimmer,
+    #[cfg(feature = "lang-glsl")]
+    Glsl,
+    #[cfg(feature = "lang-go")]
+    Go,
+    #[cfg(feature = "lang-hare")]
+    Hare,
+    #[cfg(feature = "lang-haskell")]
+    Haskell,
     #[cfg(feature = "lang-haxe")]
     Haxe,
     #[cfg(feature = "lang-hcl")]
-    HCL,
+    Hcl,
+    #[cfg(feature = "lang-html")]
+    Html,
+    #[cfg(feature = "lang-java")]
+    Java,
+    #[cfg(feature = "lang-javascript")]
+    Javascript,
+    #[cfg(feature = "lang-json")]
+    Json,
+    #[cfg(feature = "lang-javascript")]
+    Jsx,
+    #[cfg(feature = "lang-julia")]
+    Julia,
+    #[cfg(feature = "lang-kotlin")]
+    Kotlin,
+    #[cfg(feature = "lang-latex")]
+    Latex,
+    #[cfg(feature = "lang-lua")]
+    Lua,
+    #[cfg(feature = "lang-markdown")]
+    Markdown,
+    // TODO: Hide this when it is shown to the user!
+    #[cfg(feature = "lang-markdown")]
+    #[strum(serialize = "markdown.inline")]
+    MarkdownInline,
+    #[cfg(feature = "lang-nix")]
+    Nix,
     #[cfg(feature = "lang-ocaml")]
-    OCaml,
+    Ocaml,
     #[cfg(feature = "lang-ocaml")]
-    OCamlInterface,
+    OcamlInterface,
+    #[cfg(feature = "lang-php")]
+    Php,
+    #[cfg(feature = "lang-prisma")]
+    Prisma,
+    #[cfg(feature = "lang-protobuf")]
+    ProtoBuf,
+    #[cfg(feature = "lang-python")]
+    Python,
+    #[cfg(feature = "lang-ql")]
+    Ql,
+    #[cfg(feature = "lang-r")]
+    R,
+    #[cfg(feature = "lang-ruby")]
+    Ruby,
+    #[cfg(feature = "lang-rust")]
+    Rust,
+    #[cfg(feature = "lang-scheme")]
+    Scheme,
     #[cfg(feature = "lang-scss")]
-    SCSS,
-    #[cfg(feature = "lang-hare")]
-    Hare,
+    Scss,
+    #[cfg(feature = "lang-sql")]
+    Sql,
+    #[cfg(feature = "lang-svelte")]
+    Svelte,
+    #[cfg(feature = "lang-swift")]
+    Swift,
+    #[cfg(feature = "lang-toml")]
+    Toml,
+    #[cfg(feature = "lang-typescript")]
+    Tsx,
+    #[cfg(feature = "lang-typescript")]
+    Typescript,
+    #[cfg(feature = "lang-vue")]
+    Vue,
+    #[cfg(feature = "lang-wgsl")]
+    Wgsl,
+    #[cfg(feature = "lang-xml")]
+    Xml,
+    #[cfg(feature = "lang-yaml")]
+    Yaml,
+    #[cfg(feature = "lang-zig")]
+    Zig,
 }
 
 // NOTE: Elements in the array must be in the same order as the enum variants of
 // `LapceLanguage` as they will be accessed using the enum variants as indices.
 const LANGUAGES: &[SyntaxProperties] = &[
-    #[cfg(feature = "lang-rust")]
+    #[cfg(feature = "lang-bash")]
     SyntaxProperties {
-        id: LapceLanguage::Rust,
-        language: tree_sitter_rust::language,
-        highlight: tree_sitter_rust::HIGHLIGHT_QUERY,
+        id: LapceLanguage::Bash,
+        language: tree_sitter_bash::language,
+        highlight: tree_sitter_bash::HIGHLIGHT_QUERY,
+        injection: None,
+        comment: "#",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["sh", "bash"],
+    },
+    #[cfg(feature = "lang-c")]
+    SyntaxProperties {
+        id: LapceLanguage::C,
+        language: tree_sitter_c::language,
+        highlight: include_str!("../queries/c/highlights.scm"),
+        injection: None,
+        comment: "//",
+        indent: "    ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &["function_definition", "struct_specifier"],
+        extensions: &["c", "h"],
+    },
+    #[cfg(feature = "lang-clojure")]
+    SyntaxProperties {
+        id: LapceLanguage::Clojure,
+        language: tree_sitter_clojure::language,
+        highlight: include_str!("../queries/clojure/highlights.scm"),
+        injection: Some(include_str!("../queries/clojure/injections.scm")),
+        comment: ";",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &[
+            "clj",
+            "edn",
+            "cljs",
+            "cljc",
+            "cljd",
+            "edn",
+            "bb",
+            "clj_kondo",
+        ],
+    },
+    #[cfg(feature = "lang-cmake")]
+    SyntaxProperties {
+        id: LapceLanguage::Cmake,
+        language: tree_sitter_cmake::language,
+        highlight: include_str!("../queries/cmake/highlights.scm"),
+        injection: Some(include_str!("../queries/cmake/injections.scm")),
+        comment: "#",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &["function_definition"],
+        extensions: &["cmake"],
+    },
+    #[cfg(feature = "lang-cpp")]
+    SyntaxProperties {
+        id: LapceLanguage::Cpp,
+        language: tree_sitter_cpp::language,
+        highlight: include_str!("../queries/cpp/highlights.scm"),
+        injection: None,
+        comment: "//",
+        indent: "    ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[
+            "function_definition",
+            "class_specifier",
+            "struct_specifier",
+        ],
+        extensions: &["cpp", "cxx", "cc", "c++", "hpp", "hxx", "hh", "h++"],
+    },
+    #[cfg(feature = "lang-csharp")]
+    SyntaxProperties {
+        id: LapceLanguage::Csharp,
+        language: tree_sitter_c_sharp::language,
+        highlight: tree_sitter_c_sharp::HIGHLIGHT_QUERY,
+        injection: None,
         comment: "//",
         indent: "    ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[
+            "interface_declaration",
+            "class_declaration",
+            "enum_declaration",
+            "struct_declaration",
+            "record_declaration",
+            "record_struct_declaration",
+            "namespace_declaration",
+            "constructor_declaration",
+            "destructor_declaration",
+            "method_declaration",
+        ],
+        extensions: &["cs", "csx"],
+    },
+    #[cfg(feature = "lang-css")]
+    SyntaxProperties {
+        id: LapceLanguage::Css,
+        language: tree_sitter_css::language,
+        highlight: include_str!("../queries/css/highlights.scm"),
+        injection: None,
+        comment: "/*",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["css"],
+    },
+    #[cfg(feature = "lang-d")]
+    SyntaxProperties {
+        id: LapceLanguage::D,
+        language: tree_sitter_d::language,
+        highlight: tree_sitter_d::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "//",
+        indent: "    ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["d", "di", "dlang"],
+    },
+    #[cfg(feature = "lang-dart")]
+    SyntaxProperties {
+        id: LapceLanguage::Dart,
+        language: tree_sitter_dart::language,
+        highlight: tree_sitter_dart::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "//",
+        indent: "  ",
         code_lens: (
-            &["source_file", "impl_item", "trait_item", "declaration_list"],
-            &["source_file", "use_declaration", "line_comment"],
+            &["program", "class_definition"],
+            &[
+                "program",
+                "import_or_export",
+                "comment",
+                "documentation_comment",
+            ],
         ),
-        extensions: &["rs"],
+        sticky_headers: &["class_definition"],
+        extensions: &["dart"],
+    },
+    #[cfg(feature = "lang-dockerfile")]
+    SyntaxProperties {
+        id: LapceLanguage::Dockerfile,
+        language: tree_sitter_dockerfile::language,
+        highlight: tree_sitter_dockerfile::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "#",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["containerfile", "dockerfile"],
+    },
+    #[cfg(feature = "lang-elixir")]
+    SyntaxProperties {
+        id: LapceLanguage::Elixir,
+        language: tree_sitter_elixir::language,
+        highlight: tree_sitter_elixir::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "#",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &["do_block"],
+        extensions: &["ex", "exs", "eex", "heex", "sface"],
+    },
+    #[cfg(feature = "lang-elm")]
+    SyntaxProperties {
+        id: LapceLanguage::Elm,
+        language: tree_sitter_elm::language,
+        highlight: include_str!("../queries/elm/highlights.scm"),
+        injection: Some(tree_sitter_elm::INJECTIONS_QUERY),
+        comment: "#",
+        indent: "    ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["elm"],
+    },
+    #[cfg(feature = "lang-erlang")]
+    SyntaxProperties {
+        id: LapceLanguage::Erlang,
+        language: tree_sitter_erlang::language,
+        highlight: include_str!("../queries/erlang/highlights.scm"),
+        injection: None,
+        comment: "%",
+        indent: "    ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["erl", "hrl"],
+    },
+    #[cfg(feature = "lang-glimmer")]
+    SyntaxProperties {
+        id: LapceLanguage::Glimmer,
+        language: tree_sitter_glimmer::language,
+        highlight: tree_sitter_glimmer::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "{{!",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["hbs"],
+    },
+    #[cfg(feature = "lang-glsl")]
+    SyntaxProperties {
+        id: LapceLanguage::Glsl,
+        language: tree_sitter_glsl::language,
+        highlight: tree_sitter_glsl::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "//",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &[
+            "glsl", "cs", "vs", "gs", "fs", "csh", "vsh", "gsh", "fsh", "cshader",
+            "vshader", "gshader", "fshader", "comp", "vert", "geom", "frag", "tesc",
+            "tese", "mesh", "task", "rgen", "rint", "rahit", "rchit", "rmiss",
+            "rcall",
+        ],
     },
     #[cfg(feature = "lang-go")]
     SyntaxProperties {
         id: LapceLanguage::Go,
         language: tree_sitter_go::language,
         highlight: tree_sitter_go::HIGHLIGHT_QUERY,
+        injection: None,
         comment: "//",
         indent: "    ",
         code_lens: (
@@ -187,278 +467,524 @@ const LANGUAGES: &[SyntaxProperties] = &[
             ],
             &["source_file", "comment", "line_comment"],
         ),
+        sticky_headers: &[],
         extensions: &["go"],
     },
+    #[cfg(feature = "lang-hare")]
+    SyntaxProperties {
+        id: LapceLanguage::Hare,
+        language: tree_sitter_hare::language,
+        highlight: tree_sitter_hare::HIGHLIGHT_QUERY,
+        injection: None,
+        comment: "//",
+        indent: "        ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["ha"],
+    },
+    #[cfg(feature = "lang-haskell")]
+    SyntaxProperties {
+        id: LapceLanguage::Haskell,
+        language: tree_sitter_haskell::language,
+        highlight: tree_sitter_haskell::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "--",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["hs"],
+    },
+    #[cfg(feature = "lang-haxe")]
+    SyntaxProperties {
+        id: LapceLanguage::Haxe,
+        language: tree_sitter_haxe::language,
+        highlight: tree_sitter_haxe::HIGHLIGHTS_QUERY,
+        injection: Some(tree_sitter_haxe::INJECTIONS_QUERY),
+        comment: "//",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["hx"],
+    },
+    #[cfg(feature = "lang-hcl")]
+    SyntaxProperties {
+        id: LapceLanguage::Hcl,
+        language: tree_sitter_hcl::language,
+        highlight: tree_sitter_hcl::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "//",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["hcl", "tf"],
+    },
+    #[cfg(feature = "lang-html")]
+    SyntaxProperties {
+        id: LapceLanguage::Html,
+        language: tree_sitter_html::language,
+        highlight: tree_sitter_html::HIGHLIGHT_QUERY,
+        injection: Some(tree_sitter_html::INJECTION_QUERY),
+        comment: "",
+        indent: "    ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["html", "htm"],
+    },
+    #[cfg(feature = "lang-java")]
+    SyntaxProperties {
+        id: LapceLanguage::Java,
+        language: tree_sitter_java::language,
+        highlight: tree_sitter_java::HIGHLIGHT_QUERY,
+        injection: None,
+        comment: "//",
+        indent: "    ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["java"],
+    },
     #[cfg(feature = "lang-javascript")]
     SyntaxProperties {
         id: LapceLanguage::Javascript,
         language: tree_sitter_javascript::language,
-        highlight: tree_sitter_javascript::HIGHLIGHT_QUERY,
+        highlight: include_str!("../queries/javascript/highlights.scm"),
+        injection: Some(tree_sitter_javascript::INJECTION_QUERY),
         comment: "//",
         indent: "  ",
         code_lens: (&["source_file", "program"], &["source_file"]),
-        extensions: &["js"],
+        sticky_headers: &[],
+        extensions: &["js", "cjs", "mjs"],
+    },
+    #[cfg(feature = "lang-json")]
+    SyntaxProperties {
+        id: LapceLanguage::Json,
+        language: tree_sitter_json::language,
+        highlight: tree_sitter_json::HIGHLIGHT_QUERY,
+        injection: None,
+        comment: "",
+        indent: "    ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &["pair"],
+        extensions: &["json"],
     },
     #[cfg(feature = "lang-javascript")]
     SyntaxProperties {
         id: LapceLanguage::Jsx,
         language: tree_sitter_javascript::language,
-        highlight: tree_sitter_javascript::JSX_HIGHLIGHT_QUERY,
+        highlight: include_str!("../queries/jsx/highlights.scm"),
+        // TODO: Does jsx use the javascript injection query too?
+        injection: Some(tree_sitter_javascript::INJECTION_QUERY),
         comment: "//",
         indent: "  ",
         code_lens: (&["source_file", "program"], &["source_file"]),
+        sticky_headers: &[],
         extensions: &["jsx"],
     },
-    #[cfg(feature = "lang-typescript")]
+    #[cfg(feature = "lang-julia")]
     SyntaxProperties {
-        id: LapceLanguage::Typescript,
-        language: tree_sitter_typescript::language_typescript,
-        highlight: tree_sitter_typescript::HIGHLIGHT_QUERY,
-        comment: "//",
+        id: LapceLanguage::Julia,
+        language: tree_sitter_julia::language,
+        highlight: include_str!("../queries/julia/highlights.scm"),
+        injection: Some(include_str!("../queries/julia/injections.scm")),
+        comment: "#",
         indent: "    ",
-        code_lens: (&["source_file", "program"], &["source_file"]),
-        extensions: &["ts"],
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[
+            "function_definition",
+            "module_definition",
+            "macro_definition",
+            "struct_definition",
+        ],
+        extensions: &["julia", "jl"],
     },
-    #[cfg(feature = "lang-typescript")]
+    #[cfg(feature = "lang-kotlin")]
     SyntaxProperties {
-        id: LapceLanguage::Tsx,
-        language: tree_sitter_typescript::language_tsx,
-        highlight: tree_sitter_typescript::HIGHLIGHT_QUERY,
+        id: LapceLanguage::Kotlin,
+        language: tree_sitter_kotlin::language,
+        highlight: include_str!("../queries/kotlin/highlights.scm"),
+        injection: Some(include_str!("../queries/kotlin/injections.scm")),
         comment: "//",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["kt", "kts"],
+    },
+    #[cfg(feature = "lang-latex")]
+    SyntaxProperties {
+        id: LapceLanguage::Latex,
+        language: tree_sitter_latex::language,
+        highlight: include_str!("../queries/latex/highlights.scm"),
+        injection: Some(include_str!("../queries/latex/injections.scm")),
+        comment: "%",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["tex"],
+    },
+    #[cfg(feature = "lang-lua")]
+    SyntaxProperties {
+        id: LapceLanguage::Lua,
+        language: tree_sitter_lua::language,
+        highlight: include_str!("../queries/lua/highlights.scm"),
+        injection: None,
+        comment: "--",
+        indent: "  ",
+        sticky_headers: &[],
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        extensions: &["lua"],
+    },
+    #[cfg(feature = "lang-markdown")]
+    SyntaxProperties {
+        id: LapceLanguage::Markdown,
+        language: tree_sitter_md::language,
+        highlight: include_str!("../queries/markdown/highlights.scm"),
+        injection: Some(include_str!("../queries/markdown/injections.scm")),
+        comment: "",
         indent: "    ",
-        code_lens: (&["source_file", "program"], &["source_file"]),
-        extensions: &["tsx"],
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["md"],
     },
-    #[cfg(feature = "lang-python")]
+    #[cfg(feature = "lang-markdown")]
     SyntaxProperties {
-        id: LapceLanguage::Python,
-        language: tree_sitter_python::language,
-        highlight: tree_sitter_python::HIGHLIGHT_QUERY,
-        comment: "#",
-        indent: "\t",
-        code_lens: (
-            &[
-                "source_file",
-                "module",
-                "class_definition",
-                "class",
-                "identifier",
-                "decorated_definition",
-                "block",
-            ],
-            &["source_file", "import_statement", "import_from_statement"],
-        ),
-        extensions: &["py"],
+        id: LapceLanguage::MarkdownInline,
+        language: tree_sitter_md::inline_language,
+        highlight: include_str!("../queries/markdown.inline/highlights.scm"),
+        injection: Some(include_str!("../queries/markdown.inline/injections.scm")),
+        comment: "",
+        indent: "    ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        // markdown inline is only used as an injection by the Markdown language
+        extensions: &[],
     },
-    #[cfg(feature = "lang-toml")]
+    #[cfg(feature = "lang-nix")]
     SyntaxProperties {
-        id: LapceLanguage::Toml,
-        language: tree_sitter_toml::language,
-        highlight: tree_sitter_toml::HIGHLIGHT_QUERY,
+        id: LapceLanguage::Nix,
+        language: tree_sitter_nix::language,
+        highlight: tree_sitter_nix::HIGHLIGHTS_QUERY,
+        injection: None,
         comment: "#",
         indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["toml"],
+        sticky_headers: &[],
+        extensions: &["nix"],
+    },
+    #[cfg(feature = "lang-ocaml")]
+    SyntaxProperties {
+        id: LapceLanguage::Ocaml,
+        language: tree_sitter_ocaml::language_ocaml,
+        highlight: tree_sitter_ocaml::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "(*",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["ml"],
+    },
+    #[cfg(feature = "lang-ocaml")]
+    SyntaxProperties {
+        id: LapceLanguage::Ocaml,
+        language: tree_sitter_ocaml::language_ocaml_interface,
+        highlight: tree_sitter_ocaml::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "(*",
+        indent: "  ",
+        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &[],
+        extensions: &["mli"],
     },
     #[cfg(feature = "lang-php")]
     SyntaxProperties {
         id: LapceLanguage::Php,
         language: tree_sitter_php::language,
         highlight: tree_sitter_php::HIGHLIGHT_QUERY,
+        injection: Some(tree_sitter_php::INJECTIONS_QUERY),
         comment: "//",
         indent: "  ",
-        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        code_lens: (
+            &[
+                "program",
+                "class_declaration",
+                "trait_declaration",
+                "interface_declaration",
+                "declaration_list",
+                "method_declaration",
+                "function_declaration",
+            ],
+            &[
+                "program",
+                "php_tag",
+                "comment",
+                "namespace_definition",
+                "namespace_use_declaration",
+                "use_declaration",
+                "const_declaration",
+                "property_declaration",
+                "expression_statement",
+            ],
+        ),
+        sticky_headers: &[
+            "class_declaration",
+            "trait_declaration",
+            "interface_declaration",
+            "method_declaration",
+            "function_declaration",
+        ],
         extensions: &["php"],
     },
-    #[cfg(feature = "lang-elixir")]
-    SyntaxProperties {
-        id: LapceLanguage::Elixir,
-        language: tree_sitter_elixir::language,
-        highlight: tree_sitter_elixir::HIGHLIGHTS_QUERY,
-        comment: "#",
-        indent: "  ",
-        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["ex", "exs", "eex", "heex", "sface"],
-    },
-    #[cfg(feature = "lang-c")]
+    #[cfg(feature = "lang-prisma")]
     SyntaxProperties {
-        id: LapceLanguage::C,
-        language: tree_sitter_c::language,
-        highlight: tree_sitter_c::HIGHLIGHT_QUERY,
+        id: LapceLanguage::Prisma,
+        language: tree_sitter_prisma_io::language,
+        highlight: include_str!("../queries/prisma/highlights.scm"),
+        injection: None,
         comment: "//",
         indent: "    ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["c"],
+        sticky_headers: &[],
+        extensions: &["prisma"],
     },
-    #[cfg(feature = "lang-cpp")]
+    #[cfg(feature = "lang-protobuf")]
     SyntaxProperties {
-        id: LapceLanguage::Cpp,
-        language: tree_sitter_cpp::language,
-        highlight: tree_sitter_cpp::HIGHLIGHT_QUERY,
+        id: LapceLanguage::ProtoBuf,
+        language: tree_sitter_protobuf::language,
+        highlight: include_str!("../queries/protobuf/highlights.scm"),
+        injection: Some(include_str!("../queries/protobuf/injections.scm")),
         comment: "//",
-        indent: "    ",
+        indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["cpp", "cxx", "cc", "c++", "hpp", "hxx", "hh", "h++"],
+        sticky_headers: &[],
+        extensions: &["proto"],
     },
-    #[cfg(feature = "lang-json")]
+    #[cfg(feature = "lang-python")]
     SyntaxProperties {
-        id: LapceLanguage::Json,
-        language: tree_sitter_json::language,
-        highlight: tree_sitter_json::HIGHLIGHT_QUERY,
-        comment: "",
+        id: LapceLanguage::Python,
+        language: tree_sitter_python::language,
+        highlight: tree_sitter_python::HIGHLIGHT_QUERY,
+        injection: None,
+        comment: "#",
         indent: "    ",
+        code_lens: (
+            &[
+                "source_file",
+                "module",
+                "class_definition",
+                "class",
+                "identifier",
+                "decorated_definition",
+                "block",
+            ],
+            &["source_file", "import_statement", "import_from_statement"],
+        ),
+        sticky_headers: &[],
+        extensions: &["py", "pyi", "pyc", "pyd", "pyw"],
+    },
+    #[cfg(feature = "lang-ql")]
+    SyntaxProperties {
+        id: LapceLanguage::Ql,
+        language: tree_sitter_ql::language,
+        highlight: tree_sitter_ql::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "//",
+        indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["json"],
+        sticky_headers: &[],
+        extensions: &["ql"],
     },
-    #[cfg(feature = "lang-md")]
+    #[cfg(feature = "lang-r")]
     SyntaxProperties {
-        id: LapceLanguage::Markdown,
-        language: tree_sitter_md::language,
-        highlight: tree_sitter_md::HIGHLIGHTS_QUERY,
-        comment: "",
-        indent: "    ",
+        id: LapceLanguage::R,
+        language: tree_sitter_r::language,
+        highlight: include_str!("../queries/r/highlights.scm"),
+        injection: None,
+        comment: "#",
+        indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["md"],
+        sticky_headers: &[],
+        extensions: &["r"],
     },
     #[cfg(feature = "lang-ruby")]
     SyntaxProperties {
         id: LapceLanguage::Ruby,
         language: tree_sitter_ruby::language,
         highlight: tree_sitter_ruby::HIGHLIGHT_QUERY,
+        injection: None,
         comment: "#",
         indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
+        sticky_headers: &["module", "class", "method", "do_block"],
         extensions: &["rb"],
     },
-    #[cfg(feature = "lang-html")]
+    #[cfg(feature = "lang-rust")]
     SyntaxProperties {
-        id: LapceLanguage::Html,
-        language: tree_sitter_html::language,
-        highlight: tree_sitter_html::HIGHLIGHT_QUERY,
-        comment: "",
+        id: LapceLanguage::Rust,
+        language: tree_sitter_rust::language,
+        highlight: tree_sitter_rust::HIGHLIGHT_QUERY,
+        injection: None,
+        comment: "//",
         indent: "    ",
+        code_lens: (
+            &["source_file", "impl_item", "trait_item", "declaration_list"],
+            &["source_file", "use_declaration", "line_comment"],
+        ),
+        sticky_headers: &["struct_item", "enum_item", "function_item", "impl_item"],
+        extensions: &["rs"],
+    },
+    #[cfg(feature = "lang-scheme")]
+    SyntaxProperties {
+        id: LapceLanguage::Scheme,
+        language: tree_sitter_scheme::language,
+        highlight: tree_sitter_scheme::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: ";",
+        indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["html", "htm"],
+        sticky_headers: &[],
+        extensions: &["scm", "ss"],
     },
-    #[cfg(feature = "lang-java")]
+    #[cfg(feature = "lang-scss")]
     SyntaxProperties {
-        id: LapceLanguage::Java,
-        language: tree_sitter_java::language,
-        highlight: tree_sitter_java::HIGHLIGHT_QUERY,
+        id: LapceLanguage::Scss,
+        language: tree_sitter_scss::language,
+        highlight: tree_sitter_scss::HIGHLIGHTS_QUERY,
+        injection: None,
         comment: "//",
         indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["java"],
+        sticky_headers: &[],
+        extensions: &["scss"],
     },
-    #[cfg(feature = "lang-elm")]
+    #[cfg(feature = "lang-sql")]
     SyntaxProperties {
-        id: LapceLanguage::Elm,
-        language: tree_sitter_elm::language,
-        highlight: tree_sitter_elm::HIGHLIGHTS_QUERY,
-        comment: "#",
-        indent: "    ",
+        id: LapceLanguage::Sql,
+        language: tree_sitter_sql::language,
+        highlight: tree_sitter_sql::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "--",
+        indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["elm"],
+        sticky_headers: &[],
+        extensions: &["sql"],
     },
-    #[cfg(feature = "lang-swift")]
+    #[cfg(feature = "lang-svelte")]
     SyntaxProperties {
-        id: LapceLanguage::Swift,
-        language: tree_sitter_swift::language,
-        highlight: tree_sitter_swift::HIGHLIGHTS_QUERY,
+        id: LapceLanguage::Svelte,
+        language: tree_sitter_svelte::language,
+        highlight: include_str!("../queries/svelte/highlights.scm"),
+        injection: Some(include_str!("../queries/svelte/injections.scm")),
         comment: "//",
         indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["swift"],
+        sticky_headers: &[],
+        extensions: &["svelte"],
     },
-    #[cfg(feature = "lang-ql")]
+    #[cfg(feature = "lang-swift")]
     SyntaxProperties {
-        id: LapceLanguage::QL,
-        language: tree_sitter_ql::language,
-        highlight: tree_sitter_ql::HIGHLIGHTS_QUERY,
+        id: LapceLanguage::Swift,
+        language: tree_sitter_swift::language,
+        highlight: tree_sitter_swift::HIGHLIGHTS_QUERY,
+        injection: None,
         comment: "//",
         indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["ql"],
+        sticky_headers: &[],
+        extensions: &["swift"],
     },
-    #[cfg(feature = "lang-haskell")]
+    #[cfg(feature = "lang-toml")]
     SyntaxProperties {
-        id: LapceLanguage::Haskell,
-        language: tree_sitter_haskell::language,
-        highlight: tree_sitter_haskell::HIGHLIGHTS_QUERY,
-        comment: "--",
+        id: LapceLanguage::Toml,
+        language: tree_sitter_toml::language,
+        highlight: tree_sitter_toml::HIGHLIGHT_QUERY,
+        injection: None,
+        comment: "#",
         indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["hs"],
+        sticky_headers: &[],
+        extensions: &["toml"],
     },
-    #[cfg(feature = "lang-glimmer")]
+    #[cfg(feature = "lang-typescript")]
     SyntaxProperties {
-        id: LapceLanguage::Glimmer,
-        language: tree_sitter_glimmer::language,
-        highlight: tree_sitter_glimmer::HIGHLIGHTS_QUERY,
-        comment: "{{!",
-        indent: "  ",
-        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["hbs"],
+        id: LapceLanguage::Tsx,
+        language: tree_sitter_typescript::language_tsx,
+        highlight: include_str!("../queries/typescript/highlights.scm"),
+        injection: None,
+        comment: "//",
+        indent: "    ",
+        code_lens: (&["source_file", "program"], &["source_file"]),
+        sticky_headers: &[],
+        extensions: &["tsx"],
     },
-    #[cfg(feature = "lang-haxe")]
+    #[cfg(feature = "lang-typescript")]
     SyntaxProperties {
-        id: LapceLanguage::Haxe,
-        language: tree_sitter_haxe::language,
-        highlight: tree_sitter_haxe::HIGHLIGHTS_QUERY,
+        id: LapceLanguage::Typescript,
+        language: tree_sitter_typescript::language_typescript,
+        highlight: include_str!("../queries/typescript/highlights.scm"),
+        injection: None,
         comment: "//",
-        indent: "  ",
-        code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["hx"],
+        indent: "    ",
+        code_lens: (&["source_file", "program"], &["source_file"]),
+        sticky_headers: &[],
+        extensions: &["ts", "cts", "mts"],
     },
-    #[cfg(feature = "lang-hcl")]
+    #[cfg(feature = "lang-vue")]
     SyntaxProperties {
-        id: LapceLanguage::HCL,
-        language: tree_sitter_hcl::language,
-        highlight: tree_sitter_hcl::HIGHLIGHTS_QUERY,
+        id: LapceLanguage::Vue,
+        language: tree_sitter_vue::language,
+        highlight: tree_sitter_vue::HIGHLIGHTS_QUERY,
+        injection: Some(tree_sitter_vue::INJECTIONS_QUERY),
         comment: "//",
         indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["hcl"],
+        sticky_headers: &[],
+        extensions: &["vue"],
     },
-    #[cfg(feature = "lang-ocaml")]
+    #[cfg(feature = "lang-wgsl")]
     SyntaxProperties {
-        id: LapceLanguage::OCaml,
-        language: tree_sitter_ocaml::language_ocaml,
-        highlight: tree_sitter_ocaml::HIGHLIGHTS_QUERY,
-        comment: "(*",
-        indent: "  ",
+        id: LapceLanguage::Wgsl,
+        language: tree_sitter_wgsl::language,
+        highlight: tree_sitter_wgsl::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "//",
+        indent: "    ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["ml"],
+        sticky_headers: &[],
+        extensions: &["wgsl"],
     },
-    #[cfg(feature = "lang-ocaml")]
+    #[cfg(feature = "lang-xml")]
     SyntaxProperties {
-        id: LapceLanguage::OCaml,
-        language: tree_sitter_ocaml::language_ocaml_interface,
-        highlight: tree_sitter_ocaml::HIGHLIGHTS_QUERY,
-        comment: "(*",
-        indent: "  ",
+        id: LapceLanguage::Xml,
+        language: tree_sitter_xml::language,
+        highlight: tree_sitter_xml::HIGHLIGHTS_QUERY,
+        injection: None,
+        comment: "//",
+        indent: "    ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["mli"],
+        sticky_headers: &[],
+        extensions: &["xml"],
     },
-    #[cfg(feature = "lang-scss")]
+    #[cfg(feature = "lang-yaml")]
     SyntaxProperties {
-        id: LapceLanguage::SCSS,
-        language: tree_sitter_scss::language,
-        highlight: tree_sitter_scss::HIGHLIGHTS_QUERY,
-        comment: "//",
+        id: LapceLanguage::Yaml,
+        language: tree_sitter_yaml::language,
+        highlight: tree_sitter_yaml::HIGHLIGHTS_QUERY,
+        injection: Some(tree_sitter_yaml::INJECTIONS_QUERY),
+        comment: "#",
         indent: "  ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["scss"],
+        sticky_headers: &[],
+        extensions: &["yml", "yaml"],
     },
-    #[cfg(feature = "lang-hare")]
+    #[cfg(feature = "lang-zig")]
     SyntaxProperties {
-        id: LapceLanguage::Hare,
-        language: tree_sitter_hare::language,
-        highlight: tree_sitter_hare::HIGHLIGHT_QUERY,
+        id: LapceLanguage::Zig,
+        language: tree_sitter_zig::language,
+        highlight: include_str!("../queries/zig/highlights.scm"),
+        injection: Some(tree_sitter_zig::INJECTIONS_QUERY),
         comment: "//",
-        indent: "        ",
+        indent: "    ",
         code_lens: (DEFAULT_CODE_LENS_LIST, DEFAULT_CODE_LENS_IGNORE_LIST),
-        extensions: &["ha"],
+        sticky_headers: &[],
+        extensions: &["zig"],
     },
 ];
 
@@ -475,6 +1001,24 @@ impl LapceLanguage {
         None
     }
 
+    pub fn from_name(name: &str) -> Option<LapceLanguage> {
+        match LapceLanguage::from_str(name.to_lowercase().as_str()) {
+            Ok(v) => Some(v),
+            Err(e) => {
+                eprintln!("failed parsing {name} LapceLanguage: {e}");
+                None
+            }
+        }
+    }
+
+    pub fn languages() -> Vec<String> {
+        let mut langs = vec![];
+        for l in LANGUAGES {
+            langs.push(format!("{}", l.id))
+        }
+        langs
+    }
+
     // NOTE: Instead of using `&LANGUAGES[*self as usize]` directly, the
     // `debug_assertion` gives better feedback should something has gone wrong
     // badly.
@@ -490,6 +1034,10 @@ impl LapceLanguage {
         l
     }
 
+    pub fn sticky_header_tags(&self) -> &[&'static str] {
+        self.properties().sticky_headers
+    }
+
     pub fn comment_token(&self) -> &str {
         self.properties().comment
     }
@@ -498,18 +1046,26 @@ impl LapceLanguage {
         self.properties().indent
     }
 
-    pub(crate) fn new_parser(&self) -> Parser {
-        let language = (self.properties().language)();
-        let mut parser = Parser::new();
-        parser.set_language(language).unwrap();
-        parser
-    }
-
-    pub(crate) fn new_highlight_config(&self) -> HighlightConfiguration {
-        let language = (self.properties().language)();
-        let query = self.properties().highlight;
-
-        HighlightConfiguration::new(language, query, "", "").unwrap()
+    pub(crate) fn new_highlight_config(
+        &self,
+    ) -> Result<HighlightConfiguration, HighlightIssue> {
+        let props = self.properties();
+        let language = (props.language)();
+        let query = props.highlight;
+        let injection = props.injection;
+        match HighlightConfiguration::new(
+            language,
+            query,
+            injection.unwrap_or(""),
+            "",
+        ) {
+            Ok(x) => Ok(x),
+            Err(x) => {
+                let str = format!("Encountered {x:?} while trying to construct HighlightConfiguration for {self}");
+                log::error!("{str}");
+                Err(HighlightIssue::Error(str))
+            }
+        }
     }
 
     pub(crate) fn walk_tree(
@@ -522,6 +1078,10 @@ impl LapceLanguage {
     }
 }
 
+/// Walk an AST and determine which lines to include in the code lens.
+///
+/// Node types listed in `list` will be walked, along with their children. All
+/// nodes encountered will be included, unless they are listed in `ignore_list`.
 fn walk_tree(
     cursor: &mut TreeCursor,
     normal_lines: &mut HashSet<usize>,
@@ -547,180 +1107,3 @@ fn walk_tree(
         cursor.goto_parent();
     }
 }
-
-#[cfg(test)]
-mod test {
-    // If none of the lang features is selected, the imports and the auxiliary
-    // function(s) in the module become unused.  Hence turning off the lints.
-    #![allow(unused, unreachable_code)]
-
-    use super::LapceLanguage;
-    use std::path::PathBuf;
-
-    fn assert_language(expected: LapceLanguage, exts: &[&str]) {
-        for ext in exts {
-            let path = PathBuf::from(&format!("a.{ext}"));
-            let lang = LapceLanguage::from_path(&path).unwrap();
-
-            assert_eq!(lang, expected);
-            // In debug build, this assertion will never set off.  It
-            // nonetheless exercises the boundary check, and the debug
-            // assertion, in the `properties()` function.
-            assert_eq!(lang.properties().id, expected);
-        }
-
-        // Hopefully there will not be such a file extension to support.
-        let path = PathBuf::from("a.___");
-        assert!(LapceLanguage::from_path(&path).is_none());
-    }
-
-    #[test]
-    #[cfg(feature = "lang-rust")]
-    fn test_rust_lang() {
-        assert_language(LapceLanguage::Rust, &["rs"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-go")]
-    fn test_go_lang() {
-        assert_language(LapceLanguage::Go, &["go"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-javascript")]
-    fn test_javascript_lang() {
-        assert_language(LapceLanguage::Javascript, &["js"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-javascript")]
-    fn test_jsx_lang() {
-        assert_language(LapceLanguage::Jsx, &["jsx"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-typescript")]
-    fn test_typescript_lang() {
-        assert_language(LapceLanguage::Typescript, &["ts"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-typescript")]
-    fn test_tsx_lang() {
-        assert_language(LapceLanguage::Tsx, &["tsx"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-python")]
-    fn test_python_lang() {
-        assert_language(LapceLanguage::Python, &["py"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-toml")]
-    fn test_toml_lang() {
-        assert_language(LapceLanguage::Toml, &["toml"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-elixir")]
-    fn test_elixir_lang() {
-        assert_language(LapceLanguage::Elixir, &["ex"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-php")]
-    fn test_php_lang() {
-        assert_language(LapceLanguage::Php, &["php"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-ruby")]
-    fn test_ruby_lang() {
-        assert_language(LapceLanguage::Ruby, &["rb"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-c")]
-    fn test_c_lang() {
-        assert_language(LapceLanguage::C, &["c"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-cpp")]
-    fn test_cpp_lang() {
-        assert_language(
-            LapceLanguage::Cpp,
-            &["cpp", "cxx", "cc", "c++", "hpp", "hxx", "hh", "h++"],
-        );
-    }
-
-    #[test]
-    #[cfg(feature = "lang-json")]
-    fn test_json_lang() {
-        assert_language(LapceLanguage::Json, &["json"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-md")]
-    fn test_md_lang() {
-        assert_language(LapceLanguage::Markdown, &["md"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-html")]
-    fn test_html_lang() {
-        assert_language(LapceLanguage::Html, &["html", "htm"]);
-    }
-
-    #[test]
-    #[cfg(feature = "lang-java")]
-    fn test_java_lang() {
-        assert_language(LapceLanguage::Java, &["java"]);
-    }
-    #[test]
-    #[cfg(feature = "lang-elm")]
-    fn test_elm_lang() {
-        assert_language(LapceLanguage::Elm, &["elm"]);
-    }
-    #[test]
-    #[cfg(feature = "lang-swift")]
-    fn test_swift_lang() {
-        assert_language(LapceLanguage::Swift, &["swift"]);
-    }
-    #[test]
-    #[cfg(feature = "lang-ql")]
-    fn test_ql_lang() {
-        assert_language(LapceLanguage::QL, &["ql"]);
-    }
-    #[test]
-    #[cfg(feature = "lang-haskell")]
-    fn test_haskell_lang() {
-        assert_language(LapceLanguage::Haskell, &["hs"]);
-    }
-    #[cfg(feature = "lang-glimmer")]
-    fn test_glimmer_lang() {
-        assert_language(LapceLanguage::Glimmer, &["hbs"]);
-    }
-    #[cfg(feature = "lang-haxe")]
-    fn test_haxe_lang() {
-        assert_language(LapceLanguage::Haxe, &["hx"]);
-    }
-    #[cfg(feature = "lang-hcl")]
-    fn test_hcl_lang() {
-        assert_language(LapceLanguage::HCL, &["hcl"]);
-    }
-    #[cfg(feature = "lang-ocaml")]
-    fn test_ocaml_lang() {
-        assert_language(LapceLanguage::OCaml, &["ml"]);
-        assert_language(LapceLanguage::OCamlInterface, &["mli"]);
-    }
-    #[cfg(feature = "lang-scss")]
-    fn test_scss_lang() {
-        assert_language(LapceLanguage::SCSS, &["scss"]);
-    }
-    #[cfg(feature = "lang-hare")]
-    fn test_hare_lang() {
-        assert_language(LapceLanguage::Hare, &["ha"]);
-    }
-}
diff --git a/lapce-core/src/lens.rs b/lapce-core/src/lens.rs
index d25fb70277..713712c194 100644
--- a/lapce-core/src/lens.rs
+++ b/lapce-core/src/lens.rs
@@ -1,6 +1,6 @@
 use std::mem;
 
-use xi_rope::{
+use lapce_xi_rope::{
     interval::IntervalBounds,
     tree::{DefaultMetric, Leaf, Node, NodeInfo, TreeBuilder},
     Cursor, Delta, Interval, Metric,
@@ -53,10 +53,7 @@ impl Lens {
     }
 
     pub fn height_of_line(&self, line: usize) -> usize {
-        let max_line = self.0.len();
-        if line >= max_line {
-            return self.0.count::<LensMetric>(self.0.len());
-        }
+        let line = self.0.len().min(line);
         self.0.count::<LensMetric>(line)
     }
 
diff --git a/lapce-core/src/lib.rs b/lapce-core/src/lib.rs
index 039c004a80..78b1d38d51 100644
--- a/lapce-core/src/lib.rs
+++ b/lapce-core/src/lib.rs
@@ -1,13 +1,20 @@
+#![allow(clippy::manual_clamp)]
+
 pub mod buffer;
+pub mod char_buffer;
 pub mod chars;
 pub mod command;
 pub mod cursor;
+pub mod directory;
 pub mod editor;
+pub mod encoding;
 pub mod indent;
 pub mod language;
 pub mod lens;
+pub mod meta;
 pub mod mode;
 pub mod movement;
+pub mod paragraph;
 pub mod register;
 pub mod selection;
 pub mod style;
diff --git a/lapce-core/src/meta.rs b/lapce-core/src/meta.rs
new file mode 100644
index 0000000000..37c7cb0f6c
--- /dev/null
+++ b/lapce-core/src/meta.rs
@@ -0,0 +1,46 @@
+use once_cell::sync::Lazy;
+
+pub static NAME: Lazy<&str> = Lazy::new(application_name);
+
+fn application_name() -> &'static str {
+    if cfg!(debug_assertions) {
+        "Lapce-Debug"
+    } else if option_env!("RELEASE_TAG_NAME")
+        .unwrap_or("")
+        .starts_with("nightly")
+    {
+        "Lapce-Nightly"
+    } else {
+        "Lapce-Stable"
+    }
+}
+
+pub static VERSION: Lazy<&str> = Lazy::new(version);
+
+fn version() -> &'static str {
+    if cfg!(debug_assertions) {
+        "debug"
+    } else if option_env!("RELEASE_TAG_NAME")
+        .unwrap_or("")
+        .starts_with("nightly")
+    {
+        option_env!("RELEASE_TAG_NAME").unwrap()
+    } else {
+        env!("CARGO_PKG_VERSION")
+    }
+}
+
+pub static RELEASE: Lazy<&str> = Lazy::new(release_type);
+
+fn release_type() -> &'static str {
+    if cfg!(debug_assertions) {
+        "Debug"
+    } else if option_env!("RELEASE_TAG_NAME")
+        .unwrap_or("")
+        .starts_with("nightly")
+    {
+        "Nightly"
+    } else {
+        "Stable"
+    }
+}
diff --git a/lapce-core/src/mode.rs b/lapce-core/src/mode.rs
index 2522c3464c..f72b96447c 100644
--- a/lapce-core/src/mode.rs
+++ b/lapce-core/src/mode.rs
@@ -3,7 +3,7 @@ use std::fmt::Write;
 use bitflags::bitflags;
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum MotionMode {
     Delete,
     Yank,
@@ -34,7 +34,7 @@ pub enum Mode {
 
 bitflags! {
     pub struct Modes: u32 {
-        const NORMAL = 0x01;
+        const NORMAL = 0x1;
         const INSERT = 0x2;
         const VISUAL = 0x4;
         const TERMINAL = 0x8;
diff --git a/lapce-core/src/movement.rs b/lapce-core/src/movement.rs
index 49ad350c6b..ab9ec842aa 100644
--- a/lapce-core/src/movement.rs
+++ b/lapce-core/src/movement.rs
@@ -24,6 +24,8 @@ pub enum Movement {
     NextUnmatched(char),
     PreviousUnmatched(char),
     MatchPairs,
+    ParagraphForward,
+    ParagraphBackward,
 }
 
 impl PartialEq for Movement {
@@ -41,6 +43,8 @@ impl Movement {
                 | Movement::Line(_)
                 | Movement::DocumentStart
                 | Movement::DocumentEnd
+                | Movement::ParagraphForward
+                | Movement::ParagraphBackward
         )
     }
 
@@ -55,6 +59,8 @@ impl Movement {
                 | Movement::Offset(_)
                 | Movement::DocumentStart
                 | Movement::DocumentEnd
+                | Movement::ParagraphForward
+                | Movement::ParagraphBackward
         )
     }
 
@@ -76,7 +82,7 @@ impl Movement {
 
             // Selects the previous entry/line
             Movement::Up if wrapping => (index + (len.saturating_sub(count))) % len,
-            Movement::Up => (index.saturating_sub(count)),
+            Movement::Up => index.saturating_sub(count),
 
             Movement::Line(position) => match position {
                 // Selects the nth line
@@ -84,6 +90,9 @@ impl Movement {
                 LinePosition::First => 0,
                 LinePosition::Last => last,
             },
+
+            Movement::ParagraphForward => 0,
+            Movement::ParagraphBackward => 0,
             _ => index,
         }
     }
diff --git a/lapce-core/src/paragraph.rs b/lapce-core/src/paragraph.rs
new file mode 100644
index 0000000000..9b57a1d087
--- /dev/null
+++ b/lapce-core/src/paragraph.rs
@@ -0,0 +1,135 @@
+use lapce_xi_rope::{Cursor, Rope, RopeInfo};
+
+/// Describe char classifications used to compose word boundaries
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum CharClassification {
+    /// Carriage Return (`r`)
+    Cr,
+    /// Line feed (`\n`)
+    Lf,
+    /// Includes letters and all of non-ascii unicode
+    Other,
+}
+
+/// A word boundary can be the start of a word, its end or both for punctuation
+#[derive(PartialEq, Eq)]
+enum ParagraphBoundary {
+    /// Denote that this is not a boundary
+    Interior,
+    /// A boundary indicating the end of a new-line sequence
+    Start,
+    /// A boundary indicating the start of a new-line sequence
+    End,
+    /// Both start and end boundaries (when we have only one empty
+    /// line)
+    Both,
+}
+
+impl ParagraphBoundary {
+    fn is_start(&self) -> bool {
+        *self == ParagraphBoundary::Start || *self == ParagraphBoundary::Both
+    }
+
+    fn is_end(&self) -> bool {
+        *self == ParagraphBoundary::End || *self == ParagraphBoundary::Both
+    }
+
+    #[allow(unused)]
+    fn is_boundary(&self) -> bool {
+        *self != ParagraphBoundary::Interior
+    }
+}
+
+/// A cursor providing utility function to navigate the rope
+/// by parahraphs boundaries.
+/// Boundaries can be the start of a word, its end, punctuation etc.
+pub struct ParagraphCursor<'a> {
+    pub(crate) inner: Cursor<'a, RopeInfo>,
+}
+
+impl<'a> ParagraphCursor<'a> {
+    pub fn new(text: &'a Rope, pos: usize) -> ParagraphCursor<'a> {
+        let inner = Cursor::new(text, pos);
+        ParagraphCursor { inner }
+    }
+
+    pub fn prev_boundary(&mut self) -> Option<usize> {
+        if let (Some(ch1), Some(ch2), Some(ch3)) = (
+            self.inner.prev_codepoint(),
+            self.inner.prev_codepoint(),
+            self.inner.prev_codepoint(),
+        ) {
+            let mut prop1 = get_char_property(ch1);
+            let mut prop2 = get_char_property(ch2);
+            let mut prop3 = get_char_property(ch3);
+            let mut candidate = self.inner.pos();
+
+            while let Some(prev) = self.inner.prev_codepoint() {
+                let prop_prev = get_char_property(prev);
+                if classify_boundary(prop_prev, prop3, prop2, prop1).is_start() {
+                    break;
+                }
+                (prop3, prop2, prop1) = (prop_prev, prop3, prop2);
+                candidate = self.inner.pos();
+            }
+
+            self.inner.set(candidate + 1);
+            return Some(candidate + 1);
+        }
+
+        None
+    }
+
+    pub fn next_boundary(&mut self) -> Option<usize> {
+        if let (Some(ch1), Some(ch2), Some(ch3)) = (
+            self.inner.next_codepoint(),
+            self.inner.next_codepoint(),
+            self.inner.next_codepoint(),
+        ) {
+            let mut prop1 = get_char_property(ch1);
+            let mut prop2 = get_char_property(ch2);
+            let mut prop3 = get_char_property(ch3);
+            let mut candidate = self.inner.pos();
+
+            while let Some(next) = self.inner.next_codepoint() {
+                let prop_next = get_char_property(next);
+                if classify_boundary(prop1, prop2, prop3, prop_next).is_end() {
+                    break;
+                }
+
+                (prop1, prop2, prop3) = (prop2, prop3, prop_next);
+                candidate = self.inner.pos();
+            }
+            self.inner.set(candidate - 1);
+            return Some(candidate - 1);
+        }
+        None
+    }
+}
+
+/// Return the [`CharClassification`] of the input character
+pub fn get_char_property(codepoint: char) -> CharClassification {
+    match codepoint {
+        '\r' => CharClassification::Cr,
+        '\n' => CharClassification::Lf,
+        _ => CharClassification::Other,
+    }
+}
+
+fn classify_boundary(
+    before_prev: CharClassification,
+    prev: CharClassification,
+    next: CharClassification,
+    after_next: CharClassification,
+) -> ParagraphBoundary {
+    use self::{CharClassification::*, ParagraphBoundary::*};
+
+    match (before_prev, prev, next, after_next) {
+        (Other, Lf, Lf, Other) => Both,
+        (_, Lf, Lf, Other) => Start,
+        (Lf, Cr, Lf, Other) => Start,
+        (Other, Lf, Lf, _) => End,
+        (Other, Cr, Lf, Cr) => End,
+        _ => Interior,
+    }
+}
diff --git a/lapce-core/src/selection.rs b/lapce-core/src/selection.rs
index 7497a6c57a..fdf4a4cb3d 100644
--- a/lapce-core/src/selection.rs
+++ b/lapce-core/src/selection.rs
@@ -1,9 +1,12 @@
-use serde::{Deserialize, Serialize};
 use std::cmp::{max, min, Ordering};
-use xi_rope::{RopeDelta, Transformer};
+
+use lapce_xi_rope::{RopeDelta, Transformer};
+use serde::{Deserialize, Serialize};
 
 use crate::cursor::ColPosition;
 
+/// Indicate whether a delta should be applied inside, outside non-caret selection or
+/// after a caret selection (see [`Selection::apply_delta`].
 #[derive(Copy, Clone)]
 pub enum InsertDrift {
     /// Indicates this edit should happen within any (non-caret) selections if possible.
@@ -16,11 +19,16 @@ pub enum InsertDrift {
 
 #[derive(Clone, Copy, PartialEq, Debug, Serialize, Deserialize)]
 pub struct SelRegion {
+    /// Region start offset
     pub start: usize,
+    /// Region end offset
     pub end: usize,
+    /// Horizontal rules for multiple selection
     pub horiz: Option<ColPosition>,
 }
 
+/// A selection holding one or more [`SelRegion`].
+/// Regions are kept in order from the leftmost selection to the rightmost selection.
 #[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
 pub struct Selection {
     regions: Vec<SelRegion>,
@@ -34,10 +42,13 @@ impl AsRef<Selection> for Selection {
 }
 
 impl SelRegion {
+    /// Creates new [`SelRegion`] from `start` and `end` offset.
     pub fn new(start: usize, end: usize, horiz: Option<ColPosition>) -> SelRegion {
         SelRegion { start, end, horiz }
     }
 
+    /// Creates a caret [`SelRegion`],
+    /// i.e. `start` and `end` position are both set to `offset` value.
     pub fn caret(offset: usize) -> SelRegion {
         SelRegion {
             start: offset,
@@ -46,35 +57,59 @@ impl SelRegion {
         }
     }
 
-    fn contains(&self, offset: usize) -> bool {
-        self.min() <= offset && offset <= self.max()
-    }
-
+    /// Return the minimum value between region's start and end position
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::SelRegion;
+    /// let  region = SelRegion::new(1, 10, None);
+    /// assert_eq!(region.min(), region.start);
+    /// let  region = SelRegion::new(42, 1, None);
+    /// assert_eq!(region.min(), region.end);
+    /// ```
     pub fn min(self) -> usize {
         min(self.start, self.end)
     }
 
+    /// Return the maximum value between region's start and end position.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::SelRegion;
+    /// let  region = SelRegion::new(1, 10, None);
+    /// assert_eq!(region.max(), region.end);
+    /// let  region = SelRegion::new(42, 1, None);
+    /// assert_eq!(region.max(), region.start);
+    /// ```
     pub fn max(self) -> usize {
         max(self.start, self.end)
     }
 
-    pub fn start(self) -> usize {
-        self.start
-    }
-
-    pub fn end(self) -> usize {
-        self.end
-    }
-
+    /// A [`SelRegion`] is considered to be a caret when its start and end position are equal.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::SelRegion;
+    /// let  region = SelRegion::new(1, 1, None);
+    /// assert!(region.is_caret());
+    /// ```
     pub fn is_caret(self) -> bool {
         self.start == self.end
     }
 
-    fn should_merge(self, other: SelRegion) -> bool {
-        other.min() < self.max()
-            || ((self.is_caret() || other.is_caret()) && other.min() == self.max())
-    }
-
+    /// Merge two [`SelRegion`] into a single one.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::SelRegion;
+    /// let  region = SelRegion::new(1, 2, None);
+    /// let  other = SelRegion::new(3, 4, None);
+    /// assert_eq!(region.merge_with(other), SelRegion::new(1, 4, None));
+    /// ```
     pub fn merge_with(self, other: SelRegion) -> SelRegion {
         let is_forward = self.end >= self.start;
         let new_min = min(self.min(), other.min());
@@ -86,9 +121,19 @@ impl SelRegion {
         };
         SelRegion::new(start, end, None)
     }
+
+    fn should_merge(self, other: SelRegion) -> bool {
+        other.min() < self.max()
+            || ((self.is_caret() || other.is_caret()) && other.min() == self.max())
+    }
+
+    fn contains(&self, offset: usize) -> bool {
+        self.min() <= offset && offset <= self.max()
+    }
 }
 
 impl Selection {
+    /// Creates a new empty [`Selection`]
     pub fn new() -> Selection {
         Selection {
             regions: Vec::new(),
@@ -96,6 +141,7 @@ impl Selection {
         }
     }
 
+    /// Creates a caret [`Selection`], i.e. a selection with a single caret [`SelRegion`]
     pub fn caret(offset: usize) -> Selection {
         Selection {
             regions: vec![SelRegion::caret(offset)],
@@ -103,6 +149,8 @@ impl Selection {
         }
     }
 
+    /// Creates a region [`Selection`], i.e. a selection with a single [`SelRegion`]
+    /// from `start` to `end` position
     pub fn region(start: usize, end: usize) -> Selection {
         Selection {
             regions: vec![SelRegion {
@@ -114,6 +162,18 @@ impl Selection {
         }
     }
 
+    /// Returns whether this [`Selection`], contains the given `offset` position or not.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::Selection;
+    /// let  selection = Selection::region(0, 2);
+    /// assert!(selection.contains(0));
+    /// assert!(selection.contains(1));
+    /// assert!(selection.contains(2));
+    /// assert!(!selection.contains(3));
+    /// ```
     pub fn contains(&self, offset: usize) -> bool {
         for region in self.regions.iter() {
             if region.contains(offset) {
@@ -123,14 +183,33 @@ impl Selection {
         false
     }
 
+    /// Returns this selection regions
     pub fn regions(&self) -> &[SelRegion] {
         &self.regions
     }
 
+    /// Returns a mutable reference to this selection regions
     pub fn regions_mut(&mut self) -> &mut [SelRegion] {
         &mut self.regions
     }
 
+    /// Returns a copy of [`self`] with all regions converted to caret region at their respective
+    /// [`SelRegion::min`] offset.
+    ///
+    /// **Examples:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::{Selection, SelRegion};
+    /// let mut selection = Selection::new();
+    /// selection.add_region(SelRegion::new(1, 3, None));
+    /// selection.add_region(SelRegion::new(6, 12, None));
+    /// selection.add_region(SelRegion::new(24, 48, None));
+    ///
+    /// assert_eq!(selection.min().regions(), vec![
+    ///     SelRegion::caret(1),
+    ///     SelRegion::caret(6),
+    ///     SelRegion::caret(24)
+    /// ]);
     pub fn min(&self) -> Selection {
         let mut selection = Self::new();
         for region in &self.regions {
@@ -140,42 +219,56 @@ impl Selection {
         selection
     }
 
+    /// Get the leftmost [`SelRegion`] in this selection if present.
     pub fn first(&self) -> Option<&SelRegion> {
-        if self.is_empty() {
-            return None;
-        }
-        Some(&self.regions[0])
+        self.regions.get(0)
     }
 
+    /// Get the rightmost [`SelRegion`] in this selection if present.
     pub fn last(&self) -> Option<&SelRegion> {
-        if self.is_empty() {
-            return None;
-        }
-        Some(&self.regions[self.len() - 1])
+        self.regions.get(self.len() - 1)
     }
 
+    /// Get the last inserted [`SelRegion`] in this selection if present.
     pub fn last_inserted(&self) -> Option<&SelRegion> {
-        if self.is_empty() {
-            return None;
-        }
-        Some(&self.regions[self.last_inserted])
+        self.regions.get(self.last_inserted)
     }
 
+    /// Get a mutable reference to the last inserted [`SelRegion`] in this selection if present.
     pub fn last_inserted_mut(&mut self) -> Option<&mut SelRegion> {
-        if self.is_empty() {
-            return None;
-        }
-        Some(&mut self.regions[self.last_inserted])
+        self.regions.get_mut(self.last_inserted)
     }
 
+    /// The number of [`SelRegion`] in this selection.
     pub fn len(&self) -> usize {
         self.regions.len()
     }
 
+    /// A [`Selection`] is considered to be a caret if it contains
+    /// only caret [`SelRegion`] (see [`SelRegion::is_caret`])
+    pub fn is_caret(&self) -> bool {
+        self.regions.iter().all(|region| region.is_caret())
+    }
+
+    /// Returns `true` if `self` has zero [`SelRegion`]
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
+    /// Returns the minimal offset across all region of this selection.
+    ///
+    /// This function panics if the selection is empty.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::{Selection, SelRegion};
+    /// let mut selection = Selection::new();
+    /// selection.add_region(SelRegion::caret(4));
+    /// selection.add_region(SelRegion::new(0, 12, None));
+    /// selection.add_region(SelRegion::new(24, 48, None));
+    /// assert_eq!(selection.min_offset(), 0);
+    /// ```
     pub fn min_offset(&self) -> usize {
         let mut offset = self.regions()[0].min();
         for region in &self.regions {
@@ -184,6 +277,20 @@ impl Selection {
         offset
     }
 
+    /// Returns the maximal offset across all region of this selection.
+    ///
+    /// This function panics if the selection is empty.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::{Selection, SelRegion};
+    /// let mut selection = Selection::new();
+    /// selection.add_region(SelRegion::caret(4));
+    /// selection.add_region(SelRegion::new(0, 12, None));
+    /// selection.add_region(SelRegion::new(24, 48, None));
+    /// assert_eq!(selection.max_offset(), 48);
+    /// ```
     pub fn max_offset(&self) -> usize {
         let mut offset = self.regions()[0].max();
         for region in &self.regions {
@@ -192,6 +299,25 @@ impl Selection {
         offset
     }
 
+    /// Returns regions in [`self`] overlapping or fully enclosed in the provided
+    /// `start` to `end` range.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::{Selection, SelRegion};
+    /// let mut selection = Selection::new();
+    /// selection.add_region(SelRegion::new(0, 3, None));
+    /// selection.add_region(SelRegion::new(3, 6, None));
+    /// selection.add_region(SelRegion::new(7, 8, None));
+    /// selection.add_region(SelRegion::new(9, 11, None));
+    /// let regions = selection.regions_in_range(5, 10);
+    /// assert_eq!(regions, vec![
+    ///     SelRegion::new(3, 6, None),
+    ///     SelRegion::new(7, 8, None),
+    ///     SelRegion::new(9, 11, None)
+    /// ]);
+    /// ```
     pub fn regions_in_range(&self, start: usize, end: usize) -> &[SelRegion] {
         let first = self.search(start);
         let mut last = self.search(end);
@@ -201,29 +327,23 @@ impl Selection {
         &self.regions[first..last]
     }
 
-    pub fn search(&self, offset: usize) -> usize {
-        if self.regions.is_empty() || offset > self.regions.last().unwrap().max() {
-            return self.regions.len();
-        }
-        match self.regions.binary_search_by(|r| r.max().cmp(&offset)) {
-            Ok(ix) => ix,
-            Err(ix) => ix,
-        }
-    }
-
-    pub fn search_min(&self, offset: usize) -> usize {
-        if self.regions.is_empty() || offset > self.regions.last().unwrap().max() {
-            return self.regions.len();
-        }
-        match self
-            .regions
-            .binary_search_by(|r| r.min().cmp(&(offset + 1)))
-        {
-            Ok(ix) => ix,
-            Err(ix) => ix,
-        }
-    }
-
+    /// Returns regions in [`self`] starting between `start` to `end` range.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::{Selection, SelRegion};
+    /// let mut selection = Selection::new();
+    /// selection.add_region(SelRegion::new(0, 3, None));
+    /// selection.add_region(SelRegion::new(3, 6, None));
+    /// selection.add_region(SelRegion::new(7, 8, None));
+    /// selection.add_region(SelRegion::new(9, 11, None));
+    /// let regions = selection.full_regions_in_range(5, 10);
+    /// assert_eq!(regions, vec![
+    ///     SelRegion::new(7, 8, None),
+    ///     SelRegion::new(9, 11, None)
+    /// ]);
+    /// ```
     pub fn full_regions_in_range(&self, start: usize, end: usize) -> &[SelRegion] {
         let first = self.search_min(start);
         let mut last = self.search_min(end);
@@ -233,24 +353,56 @@ impl Selection {
         &self.regions[first..last]
     }
 
-    pub fn delete_range(&mut self, start: usize, end: usize, delete_adjacent: bool) {
+    /// Deletes regions in [`self`] overlapping or enclosing in `start` to `end` range.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::{Selection, SelRegion};
+    /// let mut selection = Selection::new();
+    /// selection.add_region(SelRegion::new(0, 3, None));
+    /// selection.add_region(SelRegion::new(3, 6, None));
+    /// selection.add_region(SelRegion::new(7, 8, None));
+    /// selection.add_region(SelRegion::new(9, 11, None));
+    /// selection.delete_range(5, 10);
+    /// assert_eq!(selection.regions(), vec![SelRegion::new(0, 3, None)]);
+    /// ```
+    pub fn delete_range(&mut self, start: usize, end: usize) {
         let mut first = self.search(start);
         let mut last = self.search(end);
         if first >= self.regions.len() {
             return;
         }
-        if !delete_adjacent && self.regions[first].max() == start {
+        if self.regions[first].max() == start {
             first += 1;
         }
-        if last < self.regions.len()
-            && ((delete_adjacent && self.regions[last].min() <= end)
-                || (!delete_adjacent && self.regions[last].min() < end))
-        {
+        if last < self.regions.len() && self.regions[last].min() < end {
             last += 1;
         }
         remove_n_at(&mut self.regions, first, last - first);
     }
 
+    /// Add a regions to [`self`]. Note that if provided region overlap
+    /// on of the selection regions they will be merged in a single region.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::selection::{Selection, SelRegion};
+    /// let mut selection = Selection::new();
+    /// // Overlapping
+    /// selection.add_region(SelRegion::new(0, 4, None));
+    /// selection.add_region(SelRegion::new(3, 6, None));
+    /// assert_eq!(selection.regions(), vec![SelRegion::new(0, 6, None)]);
+    /// // Non-overlapping
+    /// let mut selection = Selection::new();
+    /// selection.add_region(SelRegion::new(0, 3, None));
+    /// selection.add_region(SelRegion::new(3, 6, None));
+    /// assert_eq!(selection.regions(), vec![
+    ///     SelRegion::new(0, 3, None),
+    ///     SelRegion::new(3, 6, None)
+    /// ]);
+    /// ```
     pub fn add_region(&mut self, region: SelRegion) {
         let mut ix = self.search(region.min());
         if ix == self.regions.len() {
@@ -283,6 +435,12 @@ impl Selection {
         }
     }
 
+    /// Apply [`xi_rope::RopeDelta`] to this selection.
+    /// Typically used to apply an edit to a buffer and update its selections
+    /// **Parameters*:*
+    /// - `delta`[`xi_rope::RopeDelta`]
+    /// - `after` parameter indicate if the delta should be applied before or after the selection
+    /// - `drift` see [`InsertDrift`]
     pub fn apply_delta(
         &self,
         delta: &RopeDelta,
@@ -292,10 +450,9 @@ impl Selection {
         let mut result = Selection::new();
         let mut transformer = Transformer::new(delta);
         for region in self.regions() {
-            let is_caret = region.start == region.end;
             let is_region_forward = region.start < region.end;
 
-            let (start_after, end_after) = match (drift, is_caret) {
+            let (start_after, end_after) = match (drift, region.is_caret()) {
                 (InsertDrift::Inside, false) => {
                     (!is_region_forward, is_region_forward)
                 }
@@ -315,6 +472,7 @@ impl Selection {
         result
     }
 
+    /// Returns cursor position, which corresponds to last inserted region `end` offset,
     pub fn get_cursor_offset(&self) -> usize {
         if self.is_empty() {
             return 0;
@@ -322,6 +480,7 @@ impl Selection {
         self.regions[self.last_inserted].end
     }
 
+    /// Replaces last inserted [`SelRegion`] of this selection with the provided one.
     pub fn replace_last_inserted_region(&mut self, region: SelRegion) {
         if self.is_empty() {
             self.add_region(region);
@@ -331,6 +490,29 @@ impl Selection {
         self.regions.remove(self.last_inserted);
         self.add_region(region);
     }
+
+    fn search(&self, offset: usize) -> usize {
+        if self.regions.is_empty() || offset > self.regions.last().unwrap().max() {
+            return self.regions.len();
+        }
+        match self.regions.binary_search_by(|r| r.max().cmp(&offset)) {
+            Ok(ix) => ix,
+            Err(ix) => ix,
+        }
+    }
+
+    fn search_min(&self, offset: usize) -> usize {
+        if self.regions.is_empty() || offset > self.regions.last().unwrap().max() {
+            return self.regions.len();
+        }
+        match self
+            .regions
+            .binary_search_by(|r| r.min().cmp(&(offset + 1)))
+        {
+            Ok(ix) => ix,
+            Err(ix) => ix,
+        }
+    }
 }
 
 impl Default for Selection {
@@ -350,3 +532,196 @@ fn remove_n_at<T>(v: &mut Vec<T>, index: usize, n: usize) {
         _ => (),
     };
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{
+        buffer::Buffer,
+        editor::EditType,
+        selection::{InsertDrift, SelRegion, Selection},
+    };
+
+    #[test]
+    fn should_return_selection_region_min() {
+        let region = SelRegion::new(1, 10, None);
+        assert_eq!(region.min(), region.start);
+
+        let region = SelRegion::new(42, 1, None);
+        assert_eq!(region.min(), region.end);
+    }
+
+    #[test]
+    fn should_return_selection_region_max() {
+        let region = SelRegion::new(1, 10, None);
+        assert_eq!(region.max(), region.end);
+
+        let region = SelRegion::new(42, 1, None);
+        assert_eq!(region.max(), region.start);
+    }
+
+    #[test]
+    fn is_caret_should_return_true() {
+        let region = SelRegion::new(1, 10, None);
+        assert!(!region.is_caret());
+    }
+
+    #[test]
+    fn is_caret_should_return_false() {
+        let region = SelRegion::new(1, 1, None);
+        assert!(region.is_caret());
+    }
+
+    #[test]
+    fn should_merge_regions() {
+        let region = SelRegion::new(1, 2, None);
+        let other = SelRegion::new(3, 4, None);
+        assert_eq!(region.merge_with(other), SelRegion::new(1, 4, None));
+
+        let region = SelRegion::new(2, 1, None);
+        let other = SelRegion::new(4, 3, None);
+        assert_eq!(region.merge_with(other), SelRegion::new(4, 1, None));
+
+        let region = SelRegion::new(1, 1, None);
+        let other = SelRegion::new(6, 6, None);
+        assert_eq!(region.merge_with(other), SelRegion::new(1, 6, None));
+    }
+
+    #[test]
+    fn selection_should_be_caret() {
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(1));
+        selection.add_region(SelRegion::caret(6));
+        assert!(selection.is_caret());
+    }
+
+    #[test]
+    fn selection_should_not_be_caret() {
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::caret(1));
+        selection.add_region(SelRegion::new(4, 6, None));
+        assert!(!selection.is_caret());
+    }
+
+    #[test]
+    fn should_return_min_selection() {
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::new(1, 3, None));
+        selection.add_region(SelRegion::new(4, 6, None));
+        assert_eq!(
+            selection.min().regions,
+            vec![SelRegion::caret(1), SelRegion::caret(4)]
+        );
+    }
+
+    #[test]
+    fn selection_should_contains_region() {
+        let selection = Selection::region(0, 2);
+        assert!(selection.contains(0));
+        assert!(selection.contains(1));
+        assert!(selection.contains(2));
+        assert!(!selection.contains(3));
+    }
+
+    #[test]
+    fn should_return_last_inserted_region() {
+        let mut selection = Selection::region(5, 6);
+        selection.add_region(SelRegion::caret(1));
+        assert_eq!(selection.last_inserted(), Some(&SelRegion::caret(1)));
+    }
+
+    #[test]
+    fn should_return_last_region() {
+        let mut selection = Selection::region(5, 6);
+        selection.add_region(SelRegion::caret(1));
+        assert_eq!(selection.last(), Some(&SelRegion::new(5, 6, None)));
+    }
+
+    #[test]
+    fn should_return_first_region() {
+        let mut selection = Selection::region(5, 6);
+        selection.add_region(SelRegion::caret(1));
+        assert_eq!(selection.first(), Some(&SelRegion::caret(1)));
+    }
+
+    #[test]
+    fn should_return_regions_in_range() {
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::new(0, 3, None));
+        selection.add_region(SelRegion::new(3, 6, None));
+        selection.add_region(SelRegion::new(7, 8, None));
+        selection.add_region(SelRegion::new(9, 11, None));
+
+        let regions = selection.regions_in_range(5, 10);
+
+        assert_eq!(
+            regions,
+            vec![
+                SelRegion::new(3, 6, None),
+                SelRegion::new(7, 8, None),
+                SelRegion::new(9, 11, None),
+            ]
+        );
+    }
+
+    #[test]
+    fn should_return_regions_in_full_range() {
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::new(0, 3, None));
+        selection.add_region(SelRegion::new(3, 6, None));
+        selection.add_region(SelRegion::new(7, 8, None));
+        selection.add_region(SelRegion::new(9, 11, None));
+
+        let regions = selection.full_regions_in_range(5, 10);
+
+        assert_eq!(
+            regions,
+            vec![SelRegion::new(7, 8, None), SelRegion::new(9, 11, None),]
+        );
+    }
+
+    #[test]
+    fn should_delete_regions() {
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::new(0, 3, None));
+        selection.add_region(SelRegion::new(3, 6, None));
+        selection.add_region(SelRegion::new(7, 8, None));
+        selection.add_region(SelRegion::new(9, 11, None));
+        selection.delete_range(5, 10);
+        assert_eq!(selection.regions(), vec![SelRegion::new(0, 3, None)]);
+    }
+
+    #[test]
+    fn should_add_regions() {
+        let mut selection = Selection::new();
+        selection.add_region(SelRegion::new(0, 3, None));
+        selection.add_region(SelRegion::new(3, 6, None));
+        assert_eq!(
+            selection.regions(),
+            vec![SelRegion::new(0, 3, None), SelRegion::new(3, 6, None),]
+        );
+    }
+
+    #[test]
+    fn should_add_and_merge_regions() {
+        let mut selection = Selection::new();
+
+        selection.add_region(SelRegion::new(0, 4, None));
+        selection.add_region(SelRegion::new(3, 6, None));
+        assert_eq!(selection.regions(), vec![SelRegion::new(0, 6, None)]);
+    }
+
+    #[test]
+    fn should_apply_delta_after_insertion() {
+        let selection = Selection::caret(0);
+
+        let (mock_delta, _, _) = {
+            let mut buffer = Buffer::new("");
+            buffer.edit(&[(selection.clone(), "Hello")], EditType::InsertChars)
+        };
+
+        assert_eq!(
+            selection.apply_delta(&mock_delta, true, InsertDrift::Inside),
+            Selection::caret(5)
+        );
+    }
+}
diff --git a/lapce-core/src/style.rs b/lapce-core/src/style.rs
index 959d1e9548..8a295fa9a8 100644
--- a/lapce-core/src/style.rs
+++ b/lapce-core/src/style.rs
@@ -1,19 +1,8 @@
-use std::{
-    iter, mem, ops, str,
-    sync::atomic::{AtomicUsize, Ordering},
-};
+use std::str;
 
 use lapce_rpc::style::{LineStyle, Style};
-use thiserror::Error;
-use tree_sitter::{
-    Language, LossyUtf8, Node, Point, Query, QueryCaptures, QueryCursor, QueryError,
-    QueryMatch, Range, Tree,
-};
-use xi_rope::{spans::Spans, Rope};
+use lapce_xi_rope::{spans::Spans, LinesMetric, Rope};
 
-const CANCELLATION_CHECK_INTERVAL: usize = 100;
-const BUFFER_HTML_RESERVE_CAPACITY: usize = 10 * 1024;
-const BUFFER_LINES_RESERVE_CAPACITY: usize = 1000;
 pub const SCOPES: &[&str] = &[
     "constant",
     "type",
@@ -24,6 +13,7 @@ pub const SCOPES: &[&str] = &[
     "function",
     "label",
     "keyword",
+    "keyword.control",
     "string",
     "variable",
     "variable.other.member",
@@ -31,928 +21,32 @@ pub const SCOPES: &[&str] = &[
     "attribute",
     "escape",
     "embedded",
+    "symbol",
+    "punctuation",
+    "punctuation.special",
+    "punctuation.delimiter",
+    "text",
+    "text.literal",
+    "text.title",
+    "text.uri",
+    "text.reference",
+    "string.escape",
+    "conceal",
+    "none",
+    "tag",
 ];
 
-/// Indicates which highlight should be applied to a region of source code.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct Highlight(pub usize);
-
-/// Represents the reason why syntax highlighting failed.
-#[derive(Debug, Error, PartialEq, Eq)]
-pub enum Error {
-    #[error("Cancelled")]
-    Cancelled,
-    #[error("Invalid language")]
-    InvalidLanguage,
-    #[error("Unknown error")]
-    Unknown,
-}
-
-/// Represents a single step in rendering a syntax-highlighted document.
-#[derive(Copy, Clone, Debug)]
-pub enum HighlightEvent {
-    Source { start: usize, end: usize },
-    HighlightStart(Highlight),
-    HighlightEnd,
-}
-
-/// Contains the data needed to highlight code written in a particular language.
-///
-/// This struct is immutable and can be shared between threads.
-pub struct HighlightConfiguration {
-    pub language: Language,
-    pub query: Query,
-    combined_injections_query: Option<Query>,
-    locals_pattern_index: usize,
-    highlights_pattern_index: usize,
-    highlight_indices: Vec<Option<Highlight>>,
-    non_local_variable_patterns: Vec<bool>,
-    injection_content_capture_index: Option<u32>,
-    injection_language_capture_index: Option<u32>,
-    local_scope_capture_index: Option<u32>,
-    local_def_capture_index: Option<u32>,
-    local_def_value_capture_index: Option<u32>,
-    local_ref_capture_index: Option<u32>,
-}
-
-/// Performs syntax highlighting, recognizing a given list of highlight names.
-///
-/// For the best performance `Highlighter` values should be reused between
-/// syntax highlighting calls. A separate highlighter is needed for each thread that
-/// is performing highlighting.
-pub struct Highlighter {
-    cursors: Vec<QueryCursor>,
-}
-
-/// Converts a general-purpose syntax highlighting iterator into a sequence of lines of HTML.
-pub struct HtmlRenderer {
-    pub html: Vec<u8>,
-    pub line_offsets: Vec<u32>,
-    carriage_return_highlight: Option<Highlight>,
-}
-
-#[derive(Debug)]
-struct LocalDef<'a> {
-    name: &'a str,
-    value_range: ops::Range<usize>,
-    highlight: Option<Highlight>,
-}
-
-#[derive(Debug)]
-struct LocalScope<'a> {
-    inherits: bool,
-    range: ops::Range<usize>,
-    local_defs: Vec<LocalDef<'a>>,
-}
-
-struct HighlightIter<'a, F>
-where
-    F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a,
-{
-    tree: Tree,
-    source: &'a [u8],
-    byte_offset: usize,
-    highlighter: &'a mut Highlighter,
-    injection_callback: F,
-    cancellation_flag: Option<&'a AtomicUsize>,
-    layers: Vec<HighlightIterLayer<'a>>,
-    iter_count: usize,
-    next_event: Option<HighlightEvent>,
-    last_highlight_range: Option<(usize, usize, usize)>,
-}
-
-struct HighlightIterLayer<'a> {
-    _tree: Tree,
-    cursor: QueryCursor,
-    captures: iter::Peekable<QueryCaptures<'a, 'a, &'a [u8]>>,
-    config: &'a HighlightConfiguration,
-    highlight_end_stack: Vec<usize>,
-    scope_stack: Vec<LocalScope<'a>>,
-    ranges: Vec<Range>,
-    depth: usize,
-}
-
-impl Highlight {
-    pub fn str(&self) -> &str {
-        SCOPES[self.0]
-    }
-}
-
-impl Highlighter {
-    pub fn new() -> Self {
-        Highlighter {
-            cursors: Vec::new(),
-        }
-    }
-
-    /// Iterate over the highlighted regions for a given slice of source code.
-    pub fn highlight<'a>(
-        &'a mut self,
-        tree: Tree,
-        config: &'a HighlightConfiguration,
-        source: &'a [u8],
-        cancellation_flag: Option<&'a AtomicUsize>,
-        mut injection_callback: impl FnMut(&str) -> Option<&'a HighlightConfiguration>
-            + 'a,
-    ) -> impl Iterator<Item = Result<HighlightEvent, Error>> + 'a {
-        let layers = HighlightIterLayer::new(
-            tree.clone(),
-            source,
-            self,
-            &mut injection_callback,
-            config,
-            0,
-            vec![Range {
-                start_byte: 0,
-                end_byte: usize::MAX,
-                start_point: Point::new(0, 0),
-                end_point: Point::new(usize::MAX, usize::MAX),
-            }],
-        );
-        assert_ne!(layers.len(), 0);
-        let mut result = HighlightIter {
-            tree,
-            source,
-            byte_offset: 0,
-            injection_callback,
-            cancellation_flag,
-            highlighter: self,
-            iter_count: 0,
-            layers,
-            next_event: None,
-            last_highlight_range: None,
-        };
-        result.sort_layers();
-        result
-    }
-}
-
-impl Default for Highlighter {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl HighlightConfiguration {
-    /// Creates a `HighlightConfiguration` for a given `Language` and set of highlighting
-    /// queries.
-    ///
-    /// # Parameters
-    ///
-    /// * `language`  - The Tree-sitter `Language` that should be used for parsing.
-    /// * `highlights_query` - A string containing tree patterns for syntax highlighting. This
-    ///   should be non-empty, otherwise no syntax highlights will be added.
-    /// * `injections_query` -  A string containing tree patterns for injecting other languages
-    ///   into the document. This can be empty if no injections are desired.
-    /// * `locals_query` - A string containing tree patterns for tracking local variable
-    ///   definitions and references. This can be empty if local variable tracking is not needed.
-    ///
-    /// Returns a `HighlightConfiguration` that can then be used with the `highlight` method.
-    pub fn new(
-        language: Language,
-        highlights_query: &str,
-        injection_query: &str,
-        locals_query: &str,
-    ) -> Result<Self, QueryError> {
-        // Concatenate the query strings, keeping track of the start offset of each section.
-        let mut query_source = String::new();
-        query_source.push_str(injection_query);
-        let locals_query_offset = query_source.len();
-        query_source.push_str(locals_query);
-        let highlights_query_offset = query_source.len();
-        query_source.push_str(highlights_query);
-
-        // Construct a single query by concatenating the three query strings, but record the
-        // range of pattern indices that belong to each individual string.
-        let mut query = Query::new(language, &query_source)?;
-        let mut locals_pattern_index = 0;
-        let mut highlights_pattern_index = 0;
-        for i in 0..(query.pattern_count()) {
-            let pattern_offset = query.start_byte_for_pattern(i);
-            if pattern_offset < highlights_query_offset {
-                if pattern_offset < highlights_query_offset {
-                    highlights_pattern_index += 1;
-                }
-                if pattern_offset < locals_query_offset {
-                    locals_pattern_index += 1;
-                }
-            }
-        }
-
-        // Construct a separate query just for dealing with the 'combined injections'.
-        // Disable the combined injection patterns in the main query.
-        let mut combined_injections_query = Query::new(language, injection_query)?;
-        let mut has_combined_queries = false;
-        for pattern_index in 0..locals_pattern_index {
-            let settings = query.property_settings(pattern_index);
-            if settings.iter().any(|s| &*s.key == "injection.combined") {
-                has_combined_queries = true;
-                query.disable_pattern(pattern_index);
-            } else {
-                combined_injections_query.disable_pattern(pattern_index);
-            }
-        }
-        let combined_injections_query = if has_combined_queries {
-            Some(combined_injections_query)
-        } else {
-            None
-        };
-
-        // Find all of the highlighting patterns that are disabled for nodes that
-        // have been identified as local variables.
-        let non_local_variable_patterns = (0..query.pattern_count())
-            .map(|i| {
-                query.property_predicates(i).iter().any(|(prop, positive)| {
-                    !*positive && prop.key.as_ref() == "local"
-                })
-            })
-            .collect();
-
-        // Store the numeric ids for all of the special captures.
-        let mut injection_content_capture_index = None;
-        let mut injection_language_capture_index = None;
-        let mut local_def_capture_index = None;
-        let mut local_def_value_capture_index = None;
-        let mut local_ref_capture_index = None;
-        let mut local_scope_capture_index = None;
-        for (i, name) in query.capture_names().iter().enumerate() {
-            let i = Some(i as u32);
-            match name.as_str() {
-                "injection.content" => injection_content_capture_index = i,
-                "injection.language" => injection_language_capture_index = i,
-                "local.definition" => local_def_capture_index = i,
-                "local.definition-value" => local_def_value_capture_index = i,
-                "local.reference" => local_ref_capture_index = i,
-                "local.scope" => local_scope_capture_index = i,
-                _ => {}
-            }
-        }
-
-        let highlight_indices = vec![None; query.capture_names().len()];
-        let mut conf = HighlightConfiguration {
-            language,
-            query,
-            combined_injections_query,
-            locals_pattern_index,
-            highlights_pattern_index,
-            highlight_indices,
-            non_local_variable_patterns,
-            injection_content_capture_index,
-            injection_language_capture_index,
-            local_def_capture_index,
-            local_def_value_capture_index,
-            local_ref_capture_index,
-            local_scope_capture_index,
-        };
-        conf.configure(SCOPES);
-        Ok(conf)
-    }
-
-    /// Get a slice containing all of the highlight names used in the configuration.
-    pub fn names(&self) -> &[String] {
-        self.query.capture_names()
-    }
-
-    /// Set the list of recognized highlight names.
-    ///
-    /// Tree-sitter syntax-highlighting queries specify highlights in the form of dot-separated
-    /// highlight names like `punctuation.bracket` and `function.method.builtin`. Consumers of
-    /// these queries can choose to recognize highlights with different levels of specificity.
-    /// For example, the string `function.builtin` will match against `function.method.builtin`
-    /// and `function.builtin.constructor`, but will not match `function.method`.
-    ///
-    /// When highlighting, results are returned as `Highlight` values, which contain the index
-    /// of the matched highlight this list of highlight names.
-    fn configure(&mut self, recognized_names: &[impl AsRef<str>]) {
-        let mut capture_parts = Vec::new();
-        self.highlight_indices.clear();
-        self.highlight_indices
-            .extend(self.query.capture_names().iter().map(move |capture_name| {
-                capture_parts.clear();
-                capture_parts.extend(capture_name.split('.'));
-
-                let mut best_index = None;
-                let mut best_match_len = 0;
-                for (i, recognized_name) in recognized_names.iter().enumerate() {
-                    let mut len = 0;
-                    let mut matches = true;
-                    for part in recognized_name.as_ref().split('.') {
-                        len += 1;
-                        if !capture_parts.contains(&part) {
-                            matches = false;
-                            break;
-                        }
-                    }
-                    if matches && len > best_match_len {
-                        best_index = Some(i);
-                        best_match_len = len;
-                    }
-                }
-                best_index.map(Highlight)
-            }));
-    }
-}
-
-impl<'a> HighlightIterLayer<'a> {
-    /// Create a new 'layer' of highlighting for this document.
-    ///
-    /// In the even that the new layer contains "combined injections" (injections where multiple
-    /// disjoint ranges are parsed as one syntax tree), these will be eagerly processed and
-    /// added to the returned vector.
-    fn new<F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a>(
-        tree: Tree,
-        source: &'a [u8],
-        highlighter: &mut Highlighter,
-        injection_callback: &mut F,
-        mut config: &'a HighlightConfiguration,
-        mut depth: usize,
-        mut ranges: Vec<Range>,
-    ) -> Vec<Self> {
-        let mut result = Vec::with_capacity(1);
-        let mut queue = Vec::new();
-        loop {
-            let tree = tree.clone();
-            let mut cursor =
-                highlighter.cursors.pop().unwrap_or_else(QueryCursor::new);
-
-            // Process combined injections.
-            if let Some(combined_injections_query) =
-                &config.combined_injections_query
-            {
-                let mut injections_by_pattern_index = vec![
-                    (None, Vec::new(), false);
-                    combined_injections_query
-                        .pattern_count()
-                ];
-                let matches = cursor.matches(
-                    combined_injections_query,
-                    tree.root_node(),
-                    source,
-                );
-                for mat in matches {
-                    let entry = &mut injections_by_pattern_index[mat.pattern_index];
-                    let (language_name, content_node, include_children) =
-                        injection_for_match(
-                            config,
-                            combined_injections_query,
-                            &mat,
-                            source,
-                        );
-                    if language_name.is_some() {
-                        entry.0 = language_name;
-                    }
-                    if let Some(content_node) = content_node {
-                        entry.1.push(content_node);
-                    }
-                    entry.2 = include_children;
-                }
-                for (lang_name, content_nodes, includes_children) in
-                    injections_by_pattern_index
-                {
-                    if let (Some(lang_name), false) =
-                        (lang_name, content_nodes.is_empty())
-                    {
-                        if let Some(next_config) = (injection_callback)(lang_name) {
-                            let ranges = Self::intersect_ranges(
-                                &ranges,
-                                &content_nodes,
-                                includes_children,
-                            );
-                            if !ranges.is_empty() {
-                                queue.push((next_config, depth + 1, ranges));
-                            }
-                        }
-                    }
-                }
-            }
-
-            // The `captures` iterator borrows the `Tree` and the `QueryCursor`, which
-            // prevents them from being moved. But both of these values are really just
-            // pointers, so it's actually ok to move them.
-            let tree_ref = unsafe { mem::transmute::<_, &'static Tree>(&tree) };
-            let cursor_ref = unsafe {
-                mem::transmute::<_, &'static mut QueryCursor>(&mut cursor)
-            };
-            let captures = cursor_ref
-                .captures(&config.query, tree_ref.root_node(), source)
-                .peekable();
-
-            result.push(HighlightIterLayer {
-                highlight_end_stack: Vec::new(),
-                scope_stack: vec![LocalScope {
-                    inherits: false,
-                    range: 0..usize::MAX,
-                    local_defs: Vec::new(),
-                }],
-                cursor,
-                depth,
-                _tree: tree,
-                captures,
-                config,
-                ranges,
-            });
-
-            if queue.is_empty() {
-                break;
-            } else {
-                let (next_config, next_depth, next_ranges) = queue.remove(0);
-                config = next_config;
-                depth = next_depth;
-                ranges = next_ranges;
-            }
-        }
-
-        result
-    }
-
-    // Compute the ranges that should be included when parsing an injection.
-    // This takes into account three things:
-    // * `parent_ranges` - The ranges must all fall within the *current* layer's ranges.
-    // * `nodes` - Every injection takes place within a set of nodes. The injection ranges
-    //   are the ranges of those nodes.
-    // * `includes_children` - For some injections, the content nodes' children should be
-    //   excluded from the nested document, so that only the content nodes' *own* content
-    //   is reparsed. For other injections, the content nodes' entire ranges should be
-    //   reparsed, including the ranges of their children.
-    fn intersect_ranges(
-        parent_ranges: &[Range],
-        nodes: &[Node],
-        includes_children: bool,
-    ) -> Vec<Range> {
-        let mut cursor = nodes[0].walk();
-        let mut result = Vec::new();
-        let mut parent_range_iter = parent_ranges.iter();
-        let mut parent_range = parent_range_iter.next().expect(
-            "Layers should only be constructed with non-empty ranges vectors",
-        );
-        for node in nodes.iter() {
-            let mut preceding_range = Range {
-                start_byte: 0,
-                start_point: Point::new(0, 0),
-                end_byte: node.start_byte(),
-                end_point: node.start_position(),
-            };
-            let following_range = Range {
-                start_byte: node.end_byte(),
-                start_point: node.end_position(),
-                end_byte: usize::MAX,
-                end_point: Point::new(usize::MAX, usize::MAX),
-            };
-
-            for excluded_range in node
-                .children(&mut cursor)
-                .filter_map(|child| {
-                    if includes_children {
-                        None
-                    } else {
-                        Some(child.range())
-                    }
-                })
-                .chain([following_range].iter().cloned())
-            {
-                let mut range = Range {
-                    start_byte: preceding_range.end_byte,
-                    start_point: preceding_range.end_point,
-                    end_byte: excluded_range.start_byte,
-                    end_point: excluded_range.start_point,
-                };
-                preceding_range = excluded_range;
-
-                if range.end_byte < parent_range.start_byte {
-                    continue;
-                }
-
-                while parent_range.start_byte <= range.end_byte {
-                    if parent_range.end_byte > range.start_byte {
-                        if range.start_byte < parent_range.start_byte {
-                            range.start_byte = parent_range.start_byte;
-                            range.start_point = parent_range.start_point;
-                        }
-
-                        if parent_range.end_byte < range.end_byte {
-                            if range.start_byte < parent_range.end_byte {
-                                result.push(Range {
-                                    start_byte: range.start_byte,
-                                    start_point: range.start_point,
-                                    end_byte: parent_range.end_byte,
-                                    end_point: parent_range.end_point,
-                                });
-                            }
-                            range.start_byte = parent_range.end_byte;
-                            range.start_point = parent_range.end_point;
-                        } else {
-                            if range.start_byte < range.end_byte {
-                                result.push(range);
-                            }
-                            break;
-                        }
-                    }
-
-                    if let Some(next_range) = parent_range_iter.next() {
-                        parent_range = next_range;
-                    } else {
-                        return result;
-                    }
-                }
-            }
-        }
-        result
-    }
-
-    // First, sort scope boundaries by their byte offset in the document. At a
-    // given position, emit scope endings before scope beginnings. Finally, emit
-    // scope boundaries from deeper layers first.
-    fn sort_key(&mut self) -> Option<(usize, bool, isize)> {
-        let depth = -(self.depth as isize);
-        let next_start = self
-            .captures
-            .peek()
-            .map(|(m, i)| m.captures[*i].node.start_byte());
-        let next_end = self.highlight_end_stack.last().cloned();
-        match (next_start, next_end) {
-            (Some(start), Some(end)) => {
-                if start < end {
-                    Some((start, true, depth))
-                } else {
-                    Some((end, false, depth))
-                }
-            }
-            (Some(i), None) => Some((i, true, depth)),
-            (None, Some(j)) => Some((j, false, depth)),
-            _ => None,
-        }
-    }
-}
-
-impl<'a, F> HighlightIter<'a, F>
-where
-    F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a,
-{
-    fn emit_event(
-        &mut self,
-        offset: usize,
-        event: Option<HighlightEvent>,
-    ) -> Option<Result<HighlightEvent, Error>> {
-        let result;
-        if self.byte_offset < offset {
-            result = Some(Ok(HighlightEvent::Source {
-                start: self.byte_offset,
-                end: offset,
-            }));
-            self.byte_offset = offset;
-            self.next_event = event;
-        } else {
-            result = event.map(Ok);
-        }
-        self.sort_layers();
-        result
-    }
-
-    fn sort_layers(&mut self) {
-        while !self.layers.is_empty() {
-            if let Some(sort_key) = self.layers[0].sort_key() {
-                let mut i = 0;
-                while i + 1 < self.layers.len() {
-                    if let Some(next_offset) = self.layers[i + 1].sort_key() {
-                        if next_offset < sort_key {
-                            i += 1;
-                            continue;
-                        }
-                    }
-                    break;
-                }
-                if i > 0 {
-                    self.layers[0..(i + 1)].rotate_left(1);
-                }
-                break;
-            } else {
-                let layer = self.layers.remove(0);
-                self.highlighter.cursors.push(layer.cursor);
-            }
-        }
-    }
-
-    fn insert_layer(&mut self, mut layer: HighlightIterLayer<'a>) {
-        if let Some(sort_key) = layer.sort_key() {
-            let mut i = 1;
-            while i < self.layers.len() {
-                if let Some(sort_key_i) = self.layers[i].sort_key() {
-                    if sort_key_i > sort_key {
-                        self.layers.insert(i, layer);
-                        return;
-                    }
-                    i += 1;
-                } else {
-                    self.layers.remove(i);
-                }
-            }
-            self.layers.push(layer);
-        }
-    }
-}
-
-impl<'a, F> Iterator for HighlightIter<'a, F>
-where
-    F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a,
-{
-    type Item = Result<HighlightEvent, Error>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        'main: loop {
-            // If we've already determined the next highlight boundary, just return it.
-            if let Some(e) = self.next_event.take() {
-                return Some(Ok(e));
-            }
-
-            // Periodically check for cancellation, returning `Cancelled` error if the
-            // cancellation flag was flipped.
-            if let Some(cancellation_flag) = self.cancellation_flag {
-                self.iter_count += 1;
-                if self.iter_count >= CANCELLATION_CHECK_INTERVAL {
-                    self.iter_count = 0;
-                    if cancellation_flag.load(Ordering::Relaxed) != 0 {
-                        return Some(Err(Error::Cancelled));
-                    }
-                }
-            }
-
-            // If none of the layers have any more highlight boundaries, terminate.
-            if self.layers.is_empty() {
-                return if self.byte_offset < self.source.len() {
-                    let result = Some(Ok(HighlightEvent::Source {
-                        start: self.byte_offset,
-                        end: self.source.len(),
-                    }));
-                    self.byte_offset = self.source.len();
-                    result
-                } else {
-                    None
-                };
-            }
-
-            // Get the next capture from whichever layer has the earliest highlight boundary.
-            let range;
-            let layer = &mut self.layers[0];
-            if let Some((next_match, capture_index)) = layer.captures.peek() {
-                let next_capture = next_match.captures[*capture_index];
-                range = next_capture.node.byte_range();
-
-                // If any previous highlight ends before this node starts, then before
-                // processing this capture, emit the source code up until the end of the
-                // previous highlight, and an end event for that highlight.
-                if let Some(end_byte) = layer.highlight_end_stack.last().cloned() {
-                    if end_byte <= range.start {
-                        layer.highlight_end_stack.pop();
-                        return self.emit_event(
-                            end_byte,
-                            Some(HighlightEvent::HighlightEnd),
-                        );
-                    }
-                }
-            }
-            // If there are no more captures, then emit any remaining highlight end events.
-            // And if there are none of those, then just advance to the end of the document.
-            else if let Some(end_byte) = layer.highlight_end_stack.last().cloned()
-            {
-                layer.highlight_end_stack.pop();
-                return self
-                    .emit_event(end_byte, Some(HighlightEvent::HighlightEnd));
-            } else {
-                return self.emit_event(self.source.len(), None);
-            };
-
-            let (mut match_, capture_index) = layer.captures.next().unwrap();
-            let mut capture = match_.captures[capture_index];
-
-            // If this capture represents an injection, then process the injection.
-            if match_.pattern_index < layer.config.locals_pattern_index {
-                let (language_name, content_node, include_children) =
-                    injection_for_match(
-                        layer.config,
-                        &layer.config.query,
-                        &match_,
-                        self.source,
-                    );
-
-                // Explicitly remove this match so that none of its other captures will remain
-                // in the stream of captures.
-                match_.remove();
-
-                // If a language is found with the given name, then add a new language layer
-                // to the highlighted document.
-                if let (Some(language_name), Some(content_node)) =
-                    (language_name, content_node)
-                {
-                    if let Some(config) = (self.injection_callback)(language_name) {
-                        let ranges = HighlightIterLayer::intersect_ranges(
-                            &self.layers[0].ranges,
-                            &[content_node],
-                            include_children,
-                        );
-                        if !ranges.is_empty() {
-                            for layer in HighlightIterLayer::new(
-                                self.tree.clone(),
-                                self.source,
-                                self.highlighter,
-                                &mut self.injection_callback,
-                                config,
-                                self.layers[0].depth + 1,
-                                ranges,
-                            ) {
-                                self.insert_layer(layer);
-                            }
-                        }
-                    }
-                }
-
-                self.sort_layers();
-                continue 'main;
-            }
-
-            // Remove from the local scope stack any local scopes that have already ended.
-            while range.start > layer.scope_stack.last().unwrap().range.end {
-                layer.scope_stack.pop();
-            }
-
-            // If this capture is for tracking local variables, then process the
-            // local variable info.
-            let mut reference_highlight = None;
-            let mut definition_highlight = None;
-            while match_.pattern_index < layer.config.highlights_pattern_index {
-                // If the node represents a local scope, push a new local scope onto
-                // the scope stack.
-                if Some(capture.index) == layer.config.local_scope_capture_index {
-                    definition_highlight = None;
-                    let mut scope = LocalScope {
-                        inherits: true,
-                        range: range.clone(),
-                        local_defs: Vec::new(),
-                    };
-                    for prop in
-                        layer.config.query.property_settings(match_.pattern_index)
-                    {
-                        if prop.key.as_ref() == "local.scope-inherits" {
-                            scope.inherits = prop
-                                .value
-                                .as_ref()
-                                .map_or(true, |r| r.as_ref() == "true");
-                        }
-                    }
-                    layer.scope_stack.push(scope);
-                }
-                // If the node represents a definition, add a new definition to the
-                // local scope at the top of the scope stack.
-                else if Some(capture.index) == layer.config.local_def_capture_index
-                {
-                    reference_highlight = None;
-                    definition_highlight = None;
-                    let scope = layer.scope_stack.last_mut().unwrap();
-
-                    let mut value_range = 0..0;
-                    for capture in match_.captures {
-                        if Some(capture.index)
-                            == layer.config.local_def_value_capture_index
-                        {
-                            value_range = capture.node.byte_range();
-                        }
-                    }
-
-                    if let Ok(name) = str::from_utf8(&self.source[range.clone()]) {
-                        scope.local_defs.push(LocalDef {
-                            name,
-                            value_range,
-                            highlight: None,
-                        });
-                        definition_highlight =
-                            scope.local_defs.last_mut().map(|s| &mut s.highlight);
-                    }
-                }
-                // If the node represents a reference, then try to find the corresponding
-                // definition in the scope stack.
-                else if Some(capture.index) == layer.config.local_ref_capture_index
-                    && definition_highlight.is_none()
-                {
-                    definition_highlight = None;
-                    if let Ok(name) = str::from_utf8(&self.source[range.clone()]) {
-                        for scope in layer.scope_stack.iter().rev() {
-                            if let Some(highlight) =
-                                scope.local_defs.iter().rev().find_map(|def| {
-                                    if def.name == name
-                                        && range.start >= def.value_range.end
-                                    {
-                                        Some(def.highlight)
-                                    } else {
-                                        None
-                                    }
-                                })
-                            {
-                                reference_highlight = highlight;
-                                break;
-                            }
-                            if !scope.inherits {
-                                break;
-                            }
-                        }
-                    }
-                }
-
-                // Continue processing any additional matches for the same node.
-                if let Some((next_match, next_capture_index)) = layer.captures.peek()
-                {
-                    let next_capture = next_match.captures[*next_capture_index];
-                    if next_capture.node == capture.node {
-                        capture = next_capture;
-                        match_ = layer.captures.next().unwrap().0;
-                        continue;
-                    }
-                }
-
-                self.sort_layers();
-                continue 'main;
-            }
-
-            // Otherwise, this capture must represent a highlight.
-            // If this exact range has already been highlighted by an earlier pattern, or by
-            // a different layer, then skip over this one.
-            if let Some((last_start, last_end, last_depth)) =
-                self.last_highlight_range
-            {
-                if range.start == last_start
-                    && range.end == last_end
-                    && layer.depth < last_depth
-                {
-                    self.sort_layers();
-                    continue 'main;
-                }
-            }
-
-            // If the current node was found to be a local variable, then skip over any
-            // highlighting patterns that are disabled for local variables.
-            if definition_highlight.is_some() || reference_highlight.is_some() {
-                while layer.config.non_local_variable_patterns[match_.pattern_index]
-                {
-                    match_.remove();
-                    if let Some((next_match, next_capture_index)) =
-                        layer.captures.peek()
-                    {
-                        let next_capture = next_match.captures[*next_capture_index];
-                        if next_capture.node == capture.node {
-                            capture = next_capture;
-                            match_ = layer.captures.next().unwrap().0;
-                            continue;
-                        }
-                    }
-
-                    self.sort_layers();
-                    continue 'main;
-                }
-            }
-
-            // Once a highlighting pattern is found for the current node, skip over
-            // any later highlighting patterns that also match this node. Captures
-            // for a given node are ordered by pattern index, so these subsequent
-            // captures are guaranteed to be for highlighting, not injections or
-            // local variables.
-            while let Some((next_match, next_capture_index)) = layer.captures.peek()
-            {
-                let next_capture = next_match.captures[*next_capture_index];
-                if next_capture.node == capture.node {
-                    layer.captures.next();
-                } else {
-                    break;
-                }
-            }
-
-            let current_highlight =
-                layer.config.highlight_indices[capture.index as usize];
-
-            // If this node represents a local definition, then store the current
-            // highlight value on the local scope entry representing this node.
-            if let Some(definition_highlight) = definition_highlight {
-                *definition_highlight = current_highlight;
-            }
-
-            // Emit a scope start event and push the node's end position to the stack.
-            if let Some(highlight) = reference_highlight.or(current_highlight) {
-                self.last_highlight_range =
-                    Some((range.start, range.end, layer.depth));
-                layer.highlight_end_stack.push(range.end);
-                return self.emit_event(
-                    range.start,
-                    Some(HighlightEvent::HighlightStart(highlight)),
-                );
-            }
-
-            self.sort_layers();
-        }
-    }
-}
-
 pub fn line_styles(
     text: &Rope,
     line: usize,
     styles: &Spans<Style>,
 ) -> Vec<LineStyle> {
+    let max_line = text.measure::<LinesMetric>() + 1;
+
+    if line >= max_line {
+        return Vec::new();
+    }
+
     let start_offset = text.offset_of_line(line);
     let end_offset = text.offset_of_line(line + 1);
     let line_styles: Vec<LineStyle> = styles
@@ -976,218 +70,3 @@ pub fn line_styles(
         .collect();
     line_styles
 }
-
-impl HtmlRenderer {
-    pub fn new() -> Self {
-        let mut result = HtmlRenderer {
-            html: Vec::with_capacity(BUFFER_HTML_RESERVE_CAPACITY),
-            line_offsets: Vec::with_capacity(BUFFER_LINES_RESERVE_CAPACITY),
-            carriage_return_highlight: None,
-        };
-        result.line_offsets.push(0);
-        result
-    }
-
-    pub fn set_carriage_return_highlight(&mut self, highlight: Option<Highlight>) {
-        self.carriage_return_highlight = highlight;
-    }
-
-    pub fn reset(&mut self) {
-        shrink_and_clear(&mut self.html, BUFFER_HTML_RESERVE_CAPACITY);
-        shrink_and_clear(&mut self.line_offsets, BUFFER_LINES_RESERVE_CAPACITY);
-        self.line_offsets.push(0);
-    }
-
-    pub fn render<'a, F>(
-        &mut self,
-        highlighter: impl Iterator<Item = Result<HighlightEvent, Error>>,
-        source: &'a [u8],
-        attribute_callback: &F,
-    ) -> Result<(), Error>
-    where
-        F: Fn(Highlight) -> &'a [u8],
-    {
-        let mut highlights = Vec::new();
-        for event in highlighter {
-            match event {
-                Ok(HighlightEvent::HighlightStart(s)) => {
-                    highlights.push(s);
-                    self.start_highlight(s, attribute_callback);
-                }
-                Ok(HighlightEvent::HighlightEnd) => {
-                    highlights.pop();
-                    self.end_highlight();
-                }
-                Ok(HighlightEvent::Source { start, end }) => {
-                    self.add_text(
-                        &source[start..end],
-                        &highlights,
-                        attribute_callback,
-                    );
-                }
-                Err(a) => return Err(a),
-            }
-        }
-        if self.html.last() != Some(&b'\n') {
-            self.html.push(b'\n');
-        }
-        if self.line_offsets.last() == Some(&(self.html.len() as u32)) {
-            self.line_offsets.pop();
-        }
-        Ok(())
-    }
-
-    pub fn lines(&self) -> impl Iterator<Item = &str> {
-        self.line_offsets
-            .iter()
-            .enumerate()
-            .map(move |(i, line_start)| {
-                let line_start = *line_start as usize;
-                let line_end = if i + 1 == self.line_offsets.len() {
-                    self.html.len()
-                } else {
-                    self.line_offsets[i + 1] as usize
-                };
-                str::from_utf8(&self.html[line_start..line_end]).unwrap()
-            })
-    }
-
-    fn add_carriage_return<'a, F>(&mut self, attribute_callback: &F)
-    where
-        F: Fn(Highlight) -> &'a [u8],
-    {
-        if let Some(highlight) = self.carriage_return_highlight {
-            let attribute_string = (attribute_callback)(highlight);
-            if !attribute_string.is_empty() {
-                self.html.extend(b"<span ");
-                self.html.extend(attribute_string);
-                self.html.extend(b"></span>");
-            }
-        }
-    }
-
-    fn start_highlight<'a, F>(&mut self, h: Highlight, attribute_callback: &F)
-    where
-        F: Fn(Highlight) -> &'a [u8],
-    {
-        let attribute_string = (attribute_callback)(h);
-        self.html.extend(b"<span");
-        if !attribute_string.is_empty() {
-            self.html.extend(b" ");
-            self.html.extend(attribute_string);
-        }
-        self.html.extend(b">");
-    }
-
-    fn end_highlight(&mut self) {
-        self.html.extend(b"</span>");
-    }
-
-    fn add_text<'a, F>(
-        &mut self,
-        src: &[u8],
-        highlights: &[Highlight],
-        attribute_callback: &F,
-    ) where
-        F: Fn(Highlight) -> &'a [u8],
-    {
-        let mut last_char_was_cr = false;
-        for c in LossyUtf8::new(src).flat_map(|p| p.bytes()) {
-            // Don't render carriage return characters, but allow lone carriage returns (not
-            // followed by line feeds) to be styled via the attribute callback.
-            if c == b'\r' {
-                last_char_was_cr = true;
-                continue;
-            }
-            if last_char_was_cr {
-                if c != b'\n' {
-                    self.add_carriage_return(attribute_callback);
-                }
-                last_char_was_cr = false;
-            }
-
-            // At line boundaries, close and re-open all of the open tags.
-            if c == b'\n' {
-                highlights.iter().for_each(|_| self.end_highlight());
-                self.html.push(c);
-                self.line_offsets.push(self.html.len() as u32);
-                highlights.iter().for_each(|scope| {
-                    self.start_highlight(*scope, attribute_callback)
-                });
-            } else if let Some(escape) = html_escape(c) {
-                self.html.extend_from_slice(escape);
-            } else {
-                self.html.push(c);
-            }
-        }
-    }
-}
-
-impl Default for HtmlRenderer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-fn injection_for_match<'a>(
-    config: &HighlightConfiguration,
-    query: &'a Query,
-    query_match: &QueryMatch<'a, 'a>,
-    source: &'a [u8],
-) -> (Option<&'a str>, Option<Node<'a>>, bool) {
-    let content_capture_index = config.injection_content_capture_index;
-    let language_capture_index = config.injection_language_capture_index;
-
-    let mut language_name = None;
-    let mut content_node = None;
-    for capture in query_match.captures {
-        let index = Some(capture.index);
-        if index == language_capture_index {
-            language_name = capture.node.utf8_text(source).ok();
-        } else if index == content_capture_index {
-            content_node = Some(capture.node);
-        }
-    }
-
-    let mut include_children = false;
-    for prop in query.property_settings(query_match.pattern_index) {
-        match prop.key.as_ref() {
-            // In addition to specifying the language name via the text of a
-            // captured node, it can also be hard-coded via a `#set!` predicate
-            // that sets the injection.language key.
-            "injection.language" => {
-                if language_name.is_none() {
-                    language_name = prop.value.as_ref().map(|s| s.as_ref())
-                }
-            }
-
-            // By default, injections do not include the *children* of an
-            // `injection.content` node - only the ranges that belong to the
-            // node itself. This can be changed using a `#set!` predicate that
-            // sets the `injection.include-children` key.
-            "injection.include-children" => include_children = true,
-            _ => {}
-        }
-    }
-
-    (language_name, content_node, include_children)
-}
-
-fn shrink_and_clear<T>(vec: &mut Vec<T>, capacity: usize) {
-    if vec.len() > capacity {
-        vec.truncate(capacity);
-        vec.shrink_to_fit();
-    }
-    vec.clear();
-}
-
-fn html_escape(c: u8) -> Option<&'static [u8]> {
-    match c as char {
-        '>' => Some(b"&gt;"),
-        '<' => Some(b"&lt;"),
-        '&' => Some(b"&amp;"),
-        '\'' => Some(b"&#39;"),
-        '"' => Some(b"&quot;"),
-        _ => None,
-    }
-}
diff --git a/lapce-core/src/syntax.rs b/lapce-core/src/syntax.rs
deleted file mode 100644
index cc6142c11f..0000000000
--- a/lapce-core/src/syntax.rs
+++ /dev/null
@@ -1,476 +0,0 @@
-use std::{
-    cell::RefCell,
-    collections::{HashMap, HashSet},
-    path::Path,
-    sync::Arc,
-};
-
-use itertools::Itertools;
-use lapce_rpc::style::Style;
-use tree_sitter::{Node, Parser, Point, Tree};
-use xi_rope::{
-    spans::{Spans, SpansBuilder},
-    Interval, Rope, RopeDelta,
-};
-
-use crate::{
-    language::LapceLanguage,
-    lens::{Lens, LensBuilder},
-    style::{Highlight, HighlightEvent, Highlighter, SCOPES},
-};
-
-thread_local! {
-   static PARSER: RefCell<HashMap<LapceLanguage, Parser>> = RefCell::new(HashMap::new());
-   static HIGHLIGHTS: RefCell<HashMap<LapceLanguage, crate::style::HighlightConfiguration>> = RefCell::new(HashMap::new());
-}
-
-#[derive(Clone)]
-pub struct Syntax {
-    rev: u64,
-    pub language: LapceLanguage,
-    pub text: Rope,
-    tree: Option<Tree>,
-    pub lens: Lens,
-    pub normal_lines: Vec<usize>,
-    pub line_height: usize,
-    pub lens_height: usize,
-    pub styles: Option<Arc<Spans<Style>>>,
-}
-
-impl std::fmt::Debug for Syntax {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Syntax")
-            .field("rev", &self.rev)
-            .field("language", &self.language)
-            .field("text", &self.text)
-            .field("tree", &self.tree)
-            .field("normal_lines", &self.normal_lines)
-            .field("line_height", &self.line_height)
-            .field("lens_height", &self.lens_height)
-            .field("styles", &self.styles)
-            .finish()
-    }
-}
-
-impl Syntax {
-    pub fn init(path: &Path) -> Option<Syntax> {
-        LapceLanguage::from_path(path).map(|l| Syntax {
-            rev: 0,
-            language: l,
-            text: Rope::from(""),
-            tree: None,
-            lens: Self::lens_from_normal_lines(0, 0, 0, &Vec::new()),
-            line_height: 0,
-            lens_height: 0,
-            normal_lines: Vec::new(),
-            styles: None,
-        })
-    }
-
-    pub fn from_language(language: LapceLanguage) -> Syntax {
-        Syntax {
-            rev: 0,
-            language,
-            text: Rope::from(""),
-            tree: None,
-            lens: Self::lens_from_normal_lines(0, 0, 0, &Vec::new()),
-            line_height: 0,
-            lens_height: 0,
-            normal_lines: Vec::new(),
-            styles: None,
-        }
-    }
-
-    pub fn parse(
-        &self,
-        new_rev: u64,
-        new_text: Rope,
-        delta: Option<RopeDelta>,
-    ) -> Syntax {
-        let mut old_tree = None;
-        if new_rev == self.rev + 1 {
-            if let Some(delta) = delta {
-                fn point_at_offset(text: &Rope, offset: usize) -> Point {
-                    let line = text.line_of_offset(offset);
-                    let col = text.offset_of_line(line + 1) - offset;
-                    Point::new(line, col)
-                }
-                let (interval, _) = delta.summary();
-                let (start, end) = interval.start_end();
-                if let Some(inserted) = delta.as_simple_insert() {
-                    fn traverse(point: Point, text: &str) -> Point {
-                        let Point {
-                            mut row,
-                            mut column,
-                        } = point;
-
-                        for ch in text.chars() {
-                            if ch == '\n' {
-                                row += 1;
-                                column = 0;
-                            } else {
-                                column += 1;
-                            }
-                        }
-                        Point { row, column }
-                    }
-
-                    let start_position = point_at_offset(&self.text, start);
-
-                    let edit = tree_sitter::InputEdit {
-                        start_byte: start,
-                        old_end_byte: start,
-                        new_end_byte: start + inserted.len(),
-                        start_position,
-                        old_end_position: start_position,
-                        new_end_position: traverse(
-                            start_position,
-                            &inserted.slice_to_cow(0..inserted.len()),
-                        ),
-                    };
-                    old_tree = self.tree.as_ref().map(|tree| {
-                        let mut tree = tree.clone();
-                        tree.edit(&edit);
-                        tree
-                    });
-                } else if delta.is_simple_delete() {
-                    let start_position = point_at_offset(&self.text, start);
-                    let end_position = point_at_offset(&self.text, end);
-                    let edit = tree_sitter::InputEdit {
-                        start_byte: start,
-                        old_end_byte: end,
-                        new_end_byte: start,
-                        start_position,
-                        old_end_position: end_position,
-                        new_end_position: start_position,
-                    };
-                    old_tree = self.tree.as_ref().map(|tree| {
-                        let mut tree = tree.clone();
-                        tree.edit(&edit);
-                        tree
-                    });
-                };
-            }
-        }
-
-        let new_tree = PARSER.with(|parsers| {
-            let mut parsers = parsers.borrow_mut();
-            parsers
-                .entry(self.language)
-                .or_insert_with(|| self.language.new_parser());
-            let parser = parsers.get_mut(&self.language).unwrap();
-
-            parser.parse_with(
-                &mut |byte, _| {
-                    if byte <= new_text.len() {
-                        new_text
-                            .iter_chunks(byte..)
-                            .next()
-                            .map(|s| s.as_bytes())
-                            .unwrap_or(&[])
-                    } else {
-                        &[]
-                    }
-                },
-                old_tree.as_ref(),
-            )
-        });
-
-        let styles = if let Some(tree) = new_tree.as_ref() {
-            let styles = HIGHLIGHTS.with(|configs| {
-                let mut configs = configs.borrow_mut();
-                configs
-                    .entry(self.language)
-                    .or_insert_with(|| self.language.new_highlight_config());
-                let config = configs.get(&self.language).unwrap();
-                let mut current_hl: Option<Highlight> = None;
-                let mut highlights = SpansBuilder::new(new_text.len());
-                let mut highlighter = Highlighter::new();
-                for highlight in highlighter
-                    .highlight(
-                        tree.clone(),
-                        config,
-                        new_text.slice_to_cow(0..new_text.len()).as_bytes(),
-                        None,
-                        |_| None,
-                    )
-                    .flatten()
-                {
-                    match highlight {
-                        HighlightEvent::Source { start, end } => {
-                            if let Some(hl) = current_hl {
-                                if let Some(hl) = SCOPES.get(hl.0) {
-                                    highlights.add_span(
-                                        Interval::new(start, end),
-                                        Style {
-                                            fg_color: Some(hl.to_string()),
-                                        },
-                                    );
-                                }
-                            }
-                        }
-                        HighlightEvent::HighlightStart(hl) => {
-                            current_hl = Some(hl);
-                        }
-                        HighlightEvent::HighlightEnd => current_hl = None,
-                    }
-                }
-                highlights.build()
-            });
-            Some(Arc::new(styles))
-        } else {
-            None
-        };
-
-        let normal_lines = if let Some(tree) = new_tree.as_ref() {
-            let mut cursor = tree.walk();
-            let mut normal_lines = HashSet::new();
-            self.language.walk_tree(&mut cursor, &mut normal_lines);
-            let normal_lines: Vec<usize> =
-                normal_lines.into_iter().sorted().collect();
-            normal_lines
-        } else {
-            Vec::new()
-        };
-
-        let lens = Self::lens_from_normal_lines(
-            new_text.line_of_offset(new_text.len()) + 1,
-            self.line_height,
-            self.lens_height,
-            &normal_lines,
-        );
-        Syntax {
-            rev: new_rev,
-            language: self.language,
-            tree: new_tree,
-            text: new_text,
-            lens,
-            line_height: self.line_height,
-            lens_height: self.lens_height,
-            normal_lines,
-            styles,
-        }
-    }
-
-    pub fn update_lens_height(&mut self, line_height: usize, lens_height: usize) {
-        self.lens = Self::lens_from_normal_lines(
-            self.text.line_of_offset(self.text.len()) + 1,
-            line_height,
-            lens_height,
-            &self.normal_lines,
-        );
-        self.line_height = line_height;
-        self.lens_height = lens_height;
-    }
-
-    pub fn lens_from_normal_lines(
-        total_lines: usize,
-        line_height: usize,
-        lens_height: usize,
-        normal_lines: &[usize],
-    ) -> Lens {
-        let mut builder = LensBuilder::new();
-        let mut current_line = 0;
-        for normal_line in normal_lines.iter() {
-            let normal_line = *normal_line;
-            if normal_line > current_line {
-                builder.add_section(normal_line - current_line, lens_height);
-            }
-            builder.add_section(1, line_height);
-            current_line = normal_line + 1;
-        }
-        if current_line < total_lines {
-            builder.add_section(total_lines - current_line, lens_height);
-        }
-        builder.build()
-    }
-
-    pub fn find_matching_pair(&self, offset: usize) -> Option<usize> {
-        let tree = self.tree.as_ref()?;
-        let node = tree
-            .root_node()
-            .descendant_for_byte_range(offset, offset + 1)?;
-        let mut chars = node.kind().chars();
-        let char = chars.next()?;
-        let char = matching_char(char)?;
-        let tag = &char.to_string();
-
-        if let Some(offset) = self.find_tag_in_siblings(node, true, tag) {
-            return Some(offset);
-        }
-        if let Some(offset) = self.find_tag_in_siblings(node, false, tag) {
-            return Some(offset);
-        }
-        None
-    }
-
-    pub fn find_tag(
-        &self,
-        offset: usize,
-        previous: bool,
-        tag: &str,
-    ) -> Option<usize> {
-        let tree = self.tree.as_ref()?;
-        let node = tree
-            .root_node()
-            .descendant_for_byte_range(offset, offset + 1)?;
-
-        if let Some(offset) = self.find_tag_in_siblings(node, previous, tag) {
-            return Some(offset);
-        }
-
-        if let Some(offset) = self.find_tag_in_children(node, tag) {
-            return Some(offset);
-        }
-
-        let mut node = node;
-        while let Some(parent) = node.parent() {
-            if let Some(offset) = self.find_tag_in_siblings(parent, previous, tag) {
-                return Some(offset);
-            }
-            node = parent;
-        }
-        None
-    }
-
-    fn find_tag_in_siblings(
-        &self,
-        node: Node,
-        previous: bool,
-        tag: &str,
-    ) -> Option<usize> {
-        let mut node = node;
-        while let Some(sibling) = if previous {
-            node.prev_sibling()
-        } else {
-            node.next_sibling()
-        } {
-            if sibling.kind() == tag {
-                let offset = sibling.start_byte();
-                return Some(offset);
-            }
-            node = sibling;
-        }
-        None
-    }
-
-    fn find_tag_in_children(&self, node: Node, tag: &str) -> Option<usize> {
-        for i in 0..node.child_count() {
-            if let Some(child) = node.child(i) {
-                if child.kind() == tag {
-                    let offset = child.start_byte();
-                    return Some(offset);
-                }
-            }
-        }
-        None
-    }
-}
-
-pub fn matching_pair_direction(c: char) -> Option<bool> {
-    Some(match c {
-        '{' => true,
-        '}' => false,
-        '(' => true,
-        ')' => false,
-        '[' => true,
-        ']' => false,
-        _ => return None,
-    })
-}
-
-pub fn matching_char(c: char) -> Option<char> {
-    Some(match c {
-        '{' => '}',
-        '}' => '{',
-        '(' => ')',
-        ')' => '(',
-        '[' => ']',
-        ']' => '[',
-        _ => return None,
-    })
-}
-
-pub fn has_unmatched_pair(line: &str) -> bool {
-    let mut count = HashMap::new();
-    let mut pair_first = HashMap::new();
-    for c in line.chars().rev() {
-        if let Some(left) = matching_pair_direction(c) {
-            let key = if left { c } else { matching_char(c).unwrap() };
-            let pair_count = *count.get(&key).unwrap_or(&0i32);
-            pair_first.entry(key).or_insert(left);
-            if left {
-                count.insert(key, pair_count - 1);
-            } else {
-                count.insert(key, pair_count + 1);
-            }
-        }
-    }
-    for (_, pair_count) in count.iter() {
-        if *pair_count < 0 {
-            return true;
-        }
-    }
-    for (_, left) in pair_first.iter() {
-        if *left {
-            return true;
-        }
-    }
-    false
-}
-
-pub fn str_is_pair_left(c: &str) -> bool {
-    if c.chars().count() == 1 {
-        let c = c.chars().next().unwrap();
-        if matching_pair_direction(c).unwrap_or(false) {
-            return true;
-        }
-    }
-    false
-}
-
-pub fn str_matching_pair(c: &str) -> Option<char> {
-    if c.chars().count() == 1 {
-        let c = c.chars().next().unwrap();
-        return matching_char(c);
-    }
-    None
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_lens() {
-        let lens = Syntax::lens_from_normal_lines(5, 25, 2, &[4]);
-        assert_eq!(5, lens.len());
-        assert_eq!(8, lens.height_of_line(4));
-        assert_eq!(33, lens.height_of_line(5));
-
-        let lens = Syntax::lens_from_normal_lines(5, 25, 2, &[3]);
-        assert_eq!(5, lens.len());
-        assert_eq!(6, lens.height_of_line(3));
-        assert_eq!(31, lens.height_of_line(4));
-        assert_eq!(33, lens.height_of_line(5));
-    }
-
-    #[test]
-    fn test_lens_iter() {
-        let lens = Syntax::lens_from_normal_lines(5, 25, 2, &[0, 2, 4]);
-        assert_eq!(5, lens.len());
-        let mut iter = lens.iter_chunks(2..5);
-        assert_eq!(Some((2, 25)), iter.next());
-        assert_eq!(Some((3, 2)), iter.next());
-        assert_eq!(Some((4, 25)), iter.next());
-        assert_eq!(None, iter.next());
-
-        let lens =
-            Syntax::lens_from_normal_lines(91, 25, 2, &[0, 11, 14, 54, 57, 90]);
-        assert_eq!(91, lens.len());
-        let mut iter = lens.iter_chunks(89..91);
-        assert_eq!(Some((89, 2)), iter.next());
-        assert_eq!(Some((90, 25)), iter.next());
-        assert_eq!(None, iter.next());
-    }
-}
diff --git a/lapce-core/src/syntax/edit.rs b/lapce-core/src/syntax/edit.rs
new file mode 100644
index 0000000000..28edcae9fb
--- /dev/null
+++ b/lapce-core/src/syntax/edit.rs
@@ -0,0 +1,76 @@
+use lapce_xi_rope::Rope;
+use tree_sitter::Point;
+
+use crate::buffer::rope_text::RopeText;
+
+#[derive(Clone)]
+pub struct SyntaxEdit(pub(crate) Vec<tree_sitter::InputEdit>);
+
+impl SyntaxEdit {
+    pub fn new(edits: Vec<tree_sitter::InputEdit>) -> Self {
+        Self(edits)
+    }
+}
+
+fn point_at_offset(text: &Rope, offset: usize) -> Point {
+    let text = RopeText::new(text);
+    let line = text.line_of_offset(offset);
+    let col = text.offset_of_line(line + 1).saturating_sub(offset);
+    Point::new(line, col)
+}
+
+fn traverse(point: Point, text: &str) -> Point {
+    let Point {
+        mut row,
+        mut column,
+    } = point;
+
+    for ch in text.chars() {
+        if ch == '\n' {
+            row += 1;
+            column = 0;
+        } else {
+            column += 1;
+        }
+    }
+    Point { row, column }
+}
+
+pub fn create_insert_edit(
+    old_text: &Rope,
+    start: usize,
+    inserted: &Rope,
+) -> tree_sitter::InputEdit {
+    let start_position = point_at_offset(old_text, start);
+    tree_sitter::InputEdit {
+        start_byte: start,
+        old_end_byte: start,
+        new_end_byte: start + inserted.len(),
+        start_position,
+        old_end_position: start_position,
+        new_end_position: traverse(
+            start_position,
+            &inserted.slice_to_cow(0..inserted.len()),
+        ),
+    }
+}
+
+pub fn create_delete_edit(
+    old_text: &Rope,
+    start: usize,
+    end: usize,
+) -> tree_sitter::InputEdit {
+    let start_position = point_at_offset(old_text, start);
+    let end_position = point_at_offset(old_text, end);
+    tree_sitter::InputEdit {
+        start_byte: start,
+        // The old end byte position was at the end
+        old_end_byte: end,
+        // but since we're deleting everything up to it, it gets 'moved' to where we start
+        new_end_byte: start,
+
+        start_position,
+        old_end_position: end_position,
+        new_end_position: start_position,
+    }
+}
diff --git a/lapce-core/src/syntax/highlight.rs b/lapce-core/src/syntax/highlight.rs
new file mode 100644
index 0000000000..ce44c7acea
--- /dev/null
+++ b/lapce-core/src/syntax/highlight.rs
@@ -0,0 +1,860 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * Much of the code in this file is modified from [helix](https://github.com/helix-editor/helix)'s implementation of their syntax highlighting, which is under the MPL.
+ */
+
+use std::{
+    borrow::Cow,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+};
+
+use arc_swap::ArcSwap;
+use lapce_xi_rope::Rope;
+use tree_sitter::{
+    Language, Point, Query, QueryCaptures, QueryCursor, QueryMatch, Tree,
+};
+
+use super::{util::RopeProvider, PARSER};
+use crate::{language::LapceLanguage, style::SCOPES};
+
+macro_rules! declare_language_highlights {
+    ($($name:ident: $feature_name:expr),* $(,)?) => {
+        mod highlights {
+            // We allow non upper case globals to make the macro definition simpler.
+            #![allow(non_upper_case_globals)]
+            use once_cell::sync::Lazy;
+            use crate::language::LapceLanguage;
+            use std::sync::Arc;
+            use super::{HighlightConfiguration, HighlightIssue};
+
+            // We use Arcs because in the future we may want to load highlight configurations at runtime
+            $(
+                #[cfg(feature = $feature_name)]
+                pub static $name: Lazy<Result<Arc<HighlightConfiguration>, HighlightIssue>> = Lazy::new(|| {
+                    LapceLanguage::$name.new_highlight_config().map(Arc::new)
+                });
+            )*
+        }
+
+        pub(crate) fn get_highlight_config(lang: LapceLanguage) -> Result<Arc<HighlightConfiguration>, HighlightIssue> {
+            match lang {
+                $(
+                    #[cfg(feature = $feature_name)]
+                    LapceLanguage::$name => highlights::$name.clone()
+                ),*
+            }
+        }
+    };
+}
+
+declare_language_highlights!(
+    Bash: "lang-bash",
+    C: "lang-c",
+    Clojure: "lang-clojure",
+    Cmake: "lang-cmake",
+    Cpp: "lang-cpp",
+    Csharp: "lang-csharp",
+    Css: "lang-css",
+    D: "lang-d",
+    Dart: "lang-dart",
+    Dockerfile: "lang-dockerfile",
+    Elixir: "lang-elixir",
+    Elm: "lang-elm",
+    Erlang: "lang-erlang",
+    Glimmer: "lang-glimmer",
+    Glsl: "lang-glsl",
+    Go: "lang-go",
+    Hare: "lang-hare",
+    Haskell: "lang-haskell",
+    Haxe: "lang-haxe",
+    Hcl: "lang-hcl",
+    Html: "lang-html",
+    Java: "lang-java",
+    Javascript: "lang-javascript",
+    Json: "lang-json",
+    Jsx: "lang-javascript",
+    Julia: "lang-julia",
+    Kotlin: "lang-kotlin",
+    Latex: "lang-latex",
+    Lua: "lang-lua",
+    Markdown: "lang-markdown",
+    MarkdownInline: "lang-markdown",
+    Nix: "lang-nix",
+    Ocaml: "lang-ocaml",
+    OcamlInterface: "lang-ocaml",
+    Php: "lang-php",
+    Prisma: "lang-prisma",
+    ProtoBuf: "lang-protobuf",
+    Python: "lang-python",
+    Ql: "lang-ql",
+    R: "lang-r",
+    Ruby: "lang-ruby",
+    Rust: "lang-rust",
+    Scheme: "lang-scheme",
+    Scss: "lang-scss",
+    Sql: "lang-sql",
+    Svelte: "lang-svelte",
+    Swift: "lang-swift",
+    Toml: "lang-toml",
+    Tsx: "lang-typescript",
+    Typescript: "lang-typescript",
+    Vue: "lang-vue",
+    Wgsl: "lang-wgsl",
+    Xml: "lang-xml",
+    Yaml: "lang-yaml",
+    Zig: "lang-zig",
+);
+
+/// Indicates which highlight should be applied to a region of source code.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct Highlight(pub usize);
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum HighlightIssue {
+    Error(String),
+    NotAvailable,
+}
+
+/// Represents a single step in rendering a syntax-highlighted document.
+#[derive(Copy, Clone, Debug)]
+pub enum HighlightEvent {
+    Source { start: usize, end: usize },
+    HighlightStart(Highlight),
+    HighlightEnd,
+}
+
+#[derive(Debug)]
+pub(crate) struct LocalDef<'a> {
+    name: Cow<'a, str>,
+    value_range: std::ops::Range<usize>,
+    highlight: Option<Highlight>,
+}
+
+#[derive(Debug)]
+pub(crate) struct LocalScope<'a> {
+    pub(crate) inherits: bool,
+    pub(crate) range: std::ops::Range<usize>,
+    pub(crate) local_defs: Vec<LocalDef<'a>>,
+}
+
+const CANCELLATION_CHECK_INTERVAL: usize = 100;
+
+/// Contains the data needed to highlight code written in a particular language.
+///
+/// This struct is immutable and can be shared between threads.
+#[derive(Debug)]
+pub struct HighlightConfiguration {
+    pub language: Language,
+    pub query: Query,
+    pub injections_query: Query,
+    pub combined_injections_query: Option<Query>,
+    pub highlights_pattern_index: usize,
+    pub highlight_indices: ArcSwap<Vec<Option<Highlight>>>,
+    pub non_local_variable_patterns: Vec<bool>,
+    pub injection_content_capture_index: Option<u32>,
+    pub injection_language_capture_index: Option<u32>,
+    pub local_scope_capture_index: Option<u32>,
+    pub local_def_capture_index: Option<u32>,
+    pub local_def_value_capture_index: Option<u32>,
+    pub local_ref_capture_index: Option<u32>,
+}
+
+impl HighlightConfiguration {
+    /// Creates a `HighlightConfiguration` for a given `Language` and set of highlighting
+    /// queries.
+    ///
+    /// # Parameters
+    ///
+    /// * `language`  - The Tree-sitter `Language` that should be used for parsing.
+    /// * `highlights_query` - A string containing tree patterns for syntax highlighting. This
+    ///   should be non-empty, otherwise no syntax highlights will be added.
+    /// * `injections_query` -  A string containing tree patterns for injecting other languages
+    ///   into the document. This can be empty if no injections are desired.
+    /// * `locals_query` - A string containing tree patterns for tracking local variable
+    ///   definitions and references. This can be empty if local variable tracking is not needed.
+    ///
+    /// Returns a `HighlightConfiguration` that can then be used with the `highlight` method.
+    pub fn new(
+        language: Language,
+        highlights_query: &str,
+        injection_query: &str,
+        locals_query: &str,
+    ) -> Result<Self, tree_sitter::QueryError> {
+        // Concatenate the query strings, keeping track of the start offset of each section.
+        let mut query_source = String::new();
+        query_source.push_str(locals_query);
+        let highlights_query_offset = query_source.len();
+        query_source.push_str(highlights_query);
+
+        // Construct a single query by concatenating the three query strings, but record the
+        // range of pattern indices that belong to each individual string.
+        let query = Query::new(language, &query_source)?;
+        let mut highlights_pattern_index = 0;
+        for i in 0..(query.pattern_count()) {
+            let pattern_offset = query.start_byte_for_pattern(i);
+            if pattern_offset < highlights_query_offset {
+                highlights_pattern_index += 1;
+            }
+        }
+
+        let mut injections_query = Query::new(language, injection_query)?;
+
+        // Construct a separate query just for dealing with the 'combined injections'.
+        // Disable the combined injection patterns in the main query.
+        let mut combined_injections_query = Query::new(language, injection_query)?;
+        let mut has_combined_queries = false;
+        for pattern_index in 0..injections_query.pattern_count() {
+            let settings = injections_query.property_settings(pattern_index);
+            if settings.iter().any(|s| &*s.key == "injection.combined") {
+                has_combined_queries = true;
+                injections_query.disable_pattern(pattern_index);
+            } else {
+                combined_injections_query.disable_pattern(pattern_index);
+            }
+        }
+        let combined_injections_query = if has_combined_queries {
+            Some(combined_injections_query)
+        } else {
+            None
+        };
+
+        // Find all of the highlighting patterns that are disabled for nodes that
+        // have been identified as local variables.
+        let non_local_variable_patterns = (0..query.pattern_count())
+            .map(|i| {
+                query.property_predicates(i).iter().any(|(prop, positive)| {
+                    !*positive && prop.key.as_ref() == "local"
+                })
+            })
+            .collect();
+
+        // Store the numeric ids for all of the special captures.
+        let mut injection_content_capture_index = None;
+        let mut injection_language_capture_index = None;
+        let mut local_def_capture_index = None;
+        let mut local_def_value_capture_index = None;
+        let mut local_ref_capture_index = None;
+        let mut local_scope_capture_index = None;
+        for (i, name) in query.capture_names().iter().enumerate() {
+            let i = Some(i as u32);
+            match name.as_str() {
+                "local.definition" => local_def_capture_index = i,
+                "local.definition-value" => local_def_value_capture_index = i,
+                "local.reference" => local_ref_capture_index = i,
+                "local.scope" => local_scope_capture_index = i,
+                _ => {}
+            }
+        }
+
+        for (i, name) in injections_query.capture_names().iter().enumerate() {
+            let i = Some(i as u32);
+            match name.as_str() {
+                "injection.content" => injection_content_capture_index = i,
+                "injection.language" => injection_language_capture_index = i,
+                _ => {}
+            }
+        }
+
+        let highlight_indices: ArcSwap<Vec<_>> =
+            ArcSwap::from_pointee(vec![None; query.capture_names().len()]);
+        let conf = Self {
+            language,
+            query,
+            injections_query,
+            combined_injections_query,
+            highlights_pattern_index,
+            highlight_indices,
+            non_local_variable_patterns,
+            injection_content_capture_index,
+            injection_language_capture_index,
+            local_scope_capture_index,
+            local_def_capture_index,
+            local_def_value_capture_index,
+            local_ref_capture_index,
+        };
+        conf.configure(SCOPES);
+        Ok(conf)
+    }
+
+    /// Get a slice containing all of the highlight names used in the configuration.
+    pub fn names(&self) -> &[String] {
+        self.query.capture_names()
+    }
+
+    /// Set the list of recognized highlight names.
+    ///
+    /// Tree-sitter syntax-highlighting queries specify highlights in the form of dot-separated
+    /// highlight names like `punctuation.bracket` and `function.method.builtin`. Consumers of
+    /// these queries can choose to recognize highlights with different levels of specificity.
+    /// For example, the string `function.builtin` will match against `function.builtin.constructor`
+    /// but will not match `function.method.builtin` and `function.method`.
+    ///
+    /// When highlighting, results are returned as `Highlight` values, which contain the index
+    /// of the matched highlight this list of highlight names.
+    pub fn configure(&self, recognized_names: &[&str]) {
+        let mut capture_parts = Vec::new();
+        let indices: Vec<_> = self
+            .query
+            .capture_names()
+            .iter()
+            .map(move |capture_name| {
+                capture_parts.clear();
+                capture_parts.extend(capture_name.split('.'));
+
+                let mut best_index = None;
+                let mut best_match_len = 0;
+                for (i, recognized_name) in recognized_names.iter().enumerate() {
+                    let recognized_name = recognized_name;
+                    let mut len = 0;
+                    let mut matches = true;
+                    for (i, part) in recognized_name.split('.').enumerate() {
+                        match capture_parts.get(i) {
+                            Some(capture_part) if *capture_part == part => len += 1,
+                            _ => {
+                                matches = false;
+                                break;
+                            }
+                        }
+                    }
+                    if matches && len > best_match_len {
+                        best_index = Some(i);
+                        best_match_len = len;
+                    }
+                }
+                best_index.map(Highlight)
+            })
+            .collect();
+
+        self.highlight_indices.store(Arc::new(indices));
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct HighlightIter<'a> {
+    pub(crate) source: &'a Rope,
+    pub(crate) byte_offset: usize,
+    pub(crate) cancellation_flag: Option<&'a AtomicUsize>,
+    pub(crate) layers: Vec<HighlightIterLayer<'a>>,
+    pub(crate) iter_count: usize,
+    pub(crate) next_event: Option<HighlightEvent>,
+    pub(crate) last_highlight_range: Option<(usize, usize, usize)>,
+}
+
+pub(crate) struct HighlightIterLayer<'a> {
+    pub(crate) _tree: Option<Tree>,
+    pub(crate) cursor: QueryCursor,
+    pub(crate) captures:
+        std::iter::Peekable<QueryCaptures<'a, 'a, RopeProvider<'a>>>,
+    pub(crate) config: &'a HighlightConfiguration,
+    pub(crate) highlight_end_stack: Vec<usize>,
+    pub(crate) scope_stack: Vec<LocalScope<'a>>,
+    pub(crate) depth: usize,
+    pub(crate) ranges: &'a [tree_sitter::Range],
+}
+impl<'a> std::fmt::Debug for HighlightIterLayer<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HighlightIterLayer").finish()
+    }
+}
+
+impl<'a> HighlightIterLayer<'a> {
+    // First, sort scope boundaries by their byte offset in the document. At a
+    // given position, emit scope endings before scope beginnings. Finally, emit
+    // scope boundaries from deeper layers first.
+    fn sort_key(&mut self) -> Option<(usize, bool, isize)> {
+        let depth = -(self.depth as isize);
+        let next_start = self
+            .captures
+            .peek()
+            .map(|(m, i)| m.captures[*i].node.start_byte());
+        let next_end = self.highlight_end_stack.last().cloned();
+        match (next_start, next_end) {
+            (Some(start), Some(end)) => {
+                if start < end {
+                    Some((start, true, depth))
+                } else {
+                    Some((end, false, depth))
+                }
+            }
+            (Some(i), None) => Some((i, true, depth)),
+            (None, Some(j)) => Some((j, false, depth)),
+            _ => None,
+        }
+    }
+}
+
+impl<'a> HighlightIter<'a> {
+    fn emit_event(
+        &mut self,
+        offset: usize,
+        event: Option<HighlightEvent>,
+    ) -> Option<Result<HighlightEvent, super::Error>> {
+        let result;
+        if self.byte_offset < offset {
+            result = Some(Ok(HighlightEvent::Source {
+                start: self.byte_offset,
+                end: offset,
+            }));
+            self.byte_offset = offset;
+            self.next_event = event;
+        } else {
+            result = event.map(Ok);
+        }
+        self.sort_layers();
+        result
+    }
+
+    pub(crate) fn sort_layers(&mut self) {
+        while !self.layers.is_empty() {
+            if let Some(sort_key) = self.layers[0].sort_key() {
+                let mut i = 0;
+                while i + 1 < self.layers.len() {
+                    if let Some(next_offset) = self.layers[i + 1].sort_key() {
+                        if next_offset < sort_key {
+                            i += 1;
+                            continue;
+                        }
+                    } else {
+                        let layer = self.layers.remove(i + 1);
+                        PARSER.with(|ts_parser| {
+                            let highlighter = &mut ts_parser.borrow_mut();
+                            highlighter.cursors.push(layer.cursor);
+                        });
+                    }
+                    break;
+                }
+                if i > 0 {
+                    self.layers[0..(i + 1)].rotate_left(1);
+                }
+                break;
+            } else {
+                let layer = self.layers.remove(0);
+                PARSER.with(|ts_parser| {
+                    let highlighter = &mut ts_parser.borrow_mut();
+                    highlighter.cursors.push(layer.cursor);
+                });
+            }
+        }
+    }
+}
+
+impl<'a> Iterator for HighlightIter<'a> {
+    type Item = Result<HighlightEvent, super::Error>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        'main: loop {
+            // If we've already determined the next highlight boundary, just return it.
+            if let Some(e) = self.next_event.take() {
+                return Some(Ok(e));
+            }
+
+            // Periodically check for cancellation, returning `Cancelled` error if the
+            // cancellation flag was flipped.
+            if let Some(cancellation_flag) = self.cancellation_flag {
+                self.iter_count += 1;
+                if self.iter_count >= CANCELLATION_CHECK_INTERVAL {
+                    self.iter_count = 0;
+                    if cancellation_flag.load(Ordering::Relaxed) != 0 {
+                        return Some(Err(super::Error::Cancelled));
+                    }
+                }
+            }
+
+            // If none of the layers have any more highlight boundaries, terminate.
+            if self.layers.is_empty() {
+                let len = self.source.len();
+                return if self.byte_offset < len {
+                    let result = Some(Ok(HighlightEvent::Source {
+                        start: self.byte_offset,
+                        end: len,
+                    }));
+                    self.byte_offset = len;
+                    result
+                } else {
+                    None
+                };
+            }
+
+            // Get the next capture from whichever layer has the earliest highlight boundary.
+            let range;
+            let layer = &mut self.layers[0];
+            if let Some((next_match, capture_index)) = layer.captures.peek() {
+                let next_capture = next_match.captures[*capture_index];
+                range = next_capture.node.byte_range();
+
+                // If any previous highlight ends before this node starts, then before
+                // processing this capture, emit the source code up until the end of the
+                // previous highlight, and an end event for that highlight.
+                if let Some(end_byte) = layer.highlight_end_stack.last().cloned() {
+                    if end_byte <= range.start {
+                        layer.highlight_end_stack.pop();
+                        return self.emit_event(
+                            end_byte,
+                            Some(HighlightEvent::HighlightEnd),
+                        );
+                    }
+                }
+            }
+            // If there are no more captures, then emit any remaining highlight end events.
+            // And if there are none of those, then just advance to the end of the document.
+            else if let Some(end_byte) = layer.highlight_end_stack.last().cloned()
+            {
+                layer.highlight_end_stack.pop();
+                return self
+                    .emit_event(end_byte, Some(HighlightEvent::HighlightEnd));
+            } else {
+                return self.emit_event(self.source.len(), None);
+            };
+
+            let (mut match_, capture_index) = layer.captures.next().unwrap();
+            let mut capture = match_.captures[capture_index];
+
+            // Remove from the local scope stack any local scopes that have already ended.
+            while range.start > layer.scope_stack.last().unwrap().range.end {
+                layer.scope_stack.pop();
+            }
+
+            // If this capture is for tracking local variables, then process the
+            // local variable info.
+            let mut reference_highlight = None;
+            let mut definition_highlight = None;
+            while match_.pattern_index < layer.config.highlights_pattern_index {
+                // If the node represents a local scope, push a new local scope onto
+                // the scope stack.
+                if Some(capture.index) == layer.config.local_scope_capture_index {
+                    definition_highlight = None;
+                    let mut scope = LocalScope {
+                        inherits: true,
+                        range: range.clone(),
+                        local_defs: Vec::new(),
+                    };
+                    for prop in
+                        layer.config.query.property_settings(match_.pattern_index)
+                    {
+                        if let "local.scope-inherits" = prop.key.as_ref() {
+                            scope.inherits = prop
+                                .value
+                                .as_ref()
+                                .map_or(true, |r| r.as_ref() == "true");
+                        }
+                    }
+                    layer.scope_stack.push(scope);
+                }
+                // If the node represents a definition, add a new definition to the
+                // local scope at the top of the scope stack.
+                else if Some(capture.index) == layer.config.local_def_capture_index
+                {
+                    reference_highlight = None;
+                    let scope = layer.scope_stack.last_mut().unwrap();
+
+                    let mut value_range = 0..0;
+                    for capture in match_.captures {
+                        if Some(capture.index)
+                            == layer.config.local_def_value_capture_index
+                        {
+                            value_range = capture.node.byte_range();
+                        }
+                    }
+
+                    let name = self.source.slice_to_cow(range.clone());
+                    scope.local_defs.push(LocalDef {
+                        name,
+                        value_range,
+                        highlight: None,
+                    });
+                    definition_highlight =
+                        scope.local_defs.last_mut().map(|s| &mut s.highlight);
+                }
+                // If the node represents a reference, then try to find the corresponding
+                // definition in the scope stack.
+                else if Some(capture.index) == layer.config.local_ref_capture_index
+                    && definition_highlight.is_none()
+                {
+                    definition_highlight = None;
+                    let name = self.source.slice_to_cow(range.clone());
+                    for scope in layer.scope_stack.iter().rev() {
+                        if let Some(highlight) =
+                            scope.local_defs.iter().rev().find_map(|def| {
+                                if def.name == name
+                                    && range.start >= def.value_range.end
+                                {
+                                    Some(def.highlight)
+                                } else {
+                                    None
+                                }
+                            })
+                        {
+                            reference_highlight = highlight;
+                            break;
+                        }
+                        if !scope.inherits {
+                            break;
+                        }
+                    }
+                }
+
+                // Continue processing any additional matches for the same node.
+                if let Some((next_match, next_capture_index)) = layer.captures.peek()
+                {
+                    let next_capture = next_match.captures[*next_capture_index];
+                    if next_capture.node == capture.node {
+                        capture = next_capture;
+                        match_ = layer.captures.next().unwrap().0;
+                        continue;
+                    }
+                }
+
+                self.sort_layers();
+                continue 'main;
+            }
+
+            // Otherwise, this capture must represent a highlight.
+            // If this exact range has already been highlighted by an earlier pattern, or by
+            // a different layer, then skip over this one.
+            if let Some((last_start, last_end, last_depth)) =
+                self.last_highlight_range
+            {
+                if range.start == last_start
+                    && range.end == last_end
+                    && layer.depth < last_depth
+                {
+                    self.sort_layers();
+                    continue 'main;
+                }
+            }
+
+            // If the current node was found to be a local variable, then skip over any
+            // highlighting patterns that are disabled for local variables.
+            if definition_highlight.is_some() || reference_highlight.is_some() {
+                while layer.config.non_local_variable_patterns[match_.pattern_index]
+                {
+                    if let Some((next_match, next_capture_index)) =
+                        layer.captures.peek()
+                    {
+                        let next_capture = next_match.captures[*next_capture_index];
+                        if next_capture.node == capture.node {
+                            capture = next_capture;
+                            match_ = layer.captures.next().unwrap().0;
+                            continue;
+                        }
+                    }
+
+                    self.sort_layers();
+                    continue 'main;
+                }
+            }
+
+            // Once a highlighting pattern is found for the current node, skip over
+            // any later highlighting patterns that also match this node. Captures
+            // for a given node are ordered by pattern index, so these subsequent
+            // captures are guaranteed to be for highlighting, not injections or
+            // local variables.
+            while let Some((next_match, next_capture_index)) = layer.captures.peek()
+            {
+                let next_capture = next_match.captures[*next_capture_index];
+                if next_capture.node == capture.node {
+                    layer.captures.next();
+                } else {
+                    break;
+                }
+            }
+
+            let current_highlight =
+                layer.config.highlight_indices.load()[capture.index as usize];
+
+            // If this node represents a local definition, then store the current
+            // highlight value on the local scope entry representing this node.
+            if let Some(definition_highlight) = definition_highlight {
+                *definition_highlight = current_highlight;
+            }
+
+            // Emit a scope start event and push the node's end position to the stack.
+            if let Some(highlight) = reference_highlight.or(current_highlight) {
+                self.last_highlight_range =
+                    Some((range.start, range.end, layer.depth));
+                layer.highlight_end_stack.push(range.end);
+                return self.emit_event(
+                    range.start,
+                    Some(HighlightEvent::HighlightStart(highlight)),
+                );
+            }
+
+            self.sort_layers();
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) enum IncludedChildren {
+    None,
+    All,
+    Unnamed,
+}
+
+impl Default for IncludedChildren {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
+// Compute the ranges that should be included when parsing an injection.
+// This takes into account three things:
+// * `parent_ranges` - The ranges must all fall within the *current* layer's ranges.
+// * `nodes` - Every injection takes place within a set of nodes. The injection ranges
+//   are the ranges of those nodes.
+// * `includes_children` - For some injections, the content nodes' children should be
+//   excluded from the nested document, so that only the content nodes' *own* content
+//   is reparsed. For other injections, the content nodes' entire ranges should be
+//   reparsed, including the ranges of their children.
+pub(crate) fn intersect_ranges(
+    parent_ranges: &[tree_sitter::Range],
+    nodes: &[tree_sitter::Node],
+    included_children: IncludedChildren,
+) -> Vec<tree_sitter::Range> {
+    let mut cursor = nodes[0].walk();
+    let mut result = Vec::new();
+    let mut parent_range_iter = parent_ranges.iter();
+    let mut parent_range = parent_range_iter
+        .next()
+        .expect("Layers should only be constructed with non-empty ranges vectors");
+    for node in nodes.iter() {
+        let mut preceding_range = tree_sitter::Range {
+            start_byte: 0,
+            start_point: Point::new(0, 0),
+            end_byte: node.start_byte(),
+            end_point: node.start_position(),
+        };
+        let following_range = tree_sitter::Range {
+            start_byte: node.end_byte(),
+            start_point: node.end_position(),
+            end_byte: usize::MAX,
+            end_point: Point::new(usize::MAX, usize::MAX),
+        };
+
+        for excluded_range in node
+            .children(&mut cursor)
+            .filter_map(|child| match included_children {
+                IncludedChildren::None => Some(child.range()),
+                IncludedChildren::All => None,
+                IncludedChildren::Unnamed => {
+                    if child.is_named() {
+                        Some(child.range())
+                    } else {
+                        None
+                    }
+                }
+            })
+            .chain([following_range].iter().cloned())
+        {
+            let mut range = tree_sitter::Range {
+                start_byte: preceding_range.end_byte,
+                start_point: preceding_range.end_point,
+                end_byte: excluded_range.start_byte,
+                end_point: excluded_range.start_point,
+            };
+            preceding_range = excluded_range;
+
+            if range.end_byte < parent_range.start_byte {
+                continue;
+            }
+
+            while parent_range.start_byte <= range.end_byte {
+                if parent_range.end_byte > range.start_byte {
+                    if range.start_byte < parent_range.start_byte {
+                        range.start_byte = parent_range.start_byte;
+                        range.start_point = parent_range.start_point;
+                    }
+
+                    if parent_range.end_byte < range.end_byte {
+                        if range.start_byte < parent_range.end_byte {
+                            result.push(tree_sitter::Range {
+                                start_byte: range.start_byte,
+                                start_point: range.start_point,
+                                end_byte: parent_range.end_byte,
+                                end_point: parent_range.end_point,
+                            });
+                        }
+                        range.start_byte = parent_range.end_byte;
+                        range.start_point = parent_range.end_point;
+                    } else {
+                        if range.start_byte < range.end_byte {
+                            result.push(range);
+                        }
+                        break;
+                    }
+                }
+
+                if let Some(next_range) = parent_range_iter.next() {
+                    parent_range = next_range;
+                } else {
+                    return result;
+                }
+            }
+        }
+    }
+    result
+}
+
+pub(crate) fn injection_for_match<'a>(
+    config: &HighlightConfiguration,
+    query: &'a Query,
+    query_match: &QueryMatch<'a, 'a>,
+    source: &'a Rope,
+) -> (
+    Option<Cow<'a, str>>,
+    Option<tree_sitter::Node<'a>>,
+    IncludedChildren,
+) {
+    let content_capture_index = config.injection_content_capture_index;
+    let language_capture_index = config.injection_language_capture_index;
+
+    let mut language_name = None;
+    let mut content_node = None;
+    for capture in query_match.captures {
+        let index = Some(capture.index);
+        if index == language_capture_index {
+            let name = source.slice_to_cow(capture.node.byte_range());
+            language_name = Some(name);
+        } else if index == content_capture_index {
+            content_node = Some(capture.node);
+        }
+    }
+
+    let mut included_children = IncludedChildren::default();
+    for prop in query.property_settings(query_match.pattern_index) {
+        match prop.key.as_ref() {
+            // In addition to specifying the language name via the text of a
+            // captured node, it can also be hard-coded via a `#set!` predicate
+            // that sets the injection.language key.
+            "injection.language" => {
+                if language_name.is_none() {
+                    language_name = prop.value.as_ref().map(|s| s.as_ref().into())
+                }
+            }
+
+            // By default, injections do not include the *children* of an
+            // `injection.content` node - only the ranges that belong to the
+            // node itself. This can be changed using a `#set!` predicate that
+            // sets the `injection.include-children` key.
+            "injection.include-children" => {
+                included_children = IncludedChildren::All
+            }
+
+            // Some queries might only exclude named children but include unnamed
+            // children in their `injection.content` node. This can be enabled using
+            // a `#set!` predicate that sets the `injection.include-unnamed-children` key.
+            "injection.include-unnamed-children" => {
+                included_children = IncludedChildren::Unnamed
+            }
+            _ => {}
+        }
+    }
+
+    (language_name, content_node, included_children)
+}
diff --git a/lapce-core/src/syntax/mod.rs b/lapce-core/src/syntax/mod.rs
new file mode 100644
index 0000000000..d586d80b26
--- /dev/null
+++ b/lapce-core/src/syntax/mod.rs
@@ -0,0 +1,891 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * Much of the code in this file is modified from [helix](https://github.com/helix-editor/helix)'s implementation of their syntax highlighting, which is under the MPL.
+ */
+
+use std::{
+    cell::RefCell,
+    collections::{HashSet, VecDeque},
+    mem,
+    path::Path,
+    sync::{atomic::AtomicUsize, Arc},
+};
+
+use itertools::Itertools;
+use lapce_rpc::style::Style;
+use lapce_xi_rope::{
+    spans::{Spans, SpansBuilder},
+    Interval, Rope,
+};
+use slotmap::{DefaultKey as LayerId, HopSlotMap};
+use thiserror::Error;
+use tree_sitter::{Node, Parser, Point, QueryCursor, Tree};
+
+use self::{
+    edit::SyntaxEdit,
+    highlight::{
+        get_highlight_config, injection_for_match, intersect_ranges, Highlight,
+        HighlightConfiguration, HighlightEvent, HighlightIssue, HighlightIter,
+        HighlightIterLayer, IncludedChildren, LocalScope,
+    },
+    util::{matching_bracket_general, matching_pair_direction, RopeProvider},
+};
+use crate::{
+    language::LapceLanguage,
+    lens::{Lens, LensBuilder},
+    style::SCOPES,
+};
+
+pub mod edit;
+pub mod highlight;
+pub mod util;
+
+// Uses significant portions Helix's implementation, and on tree-sitter's highlighter implementation
+
+pub struct TsParser {
+    parser: tree_sitter::Parser,
+    pub cursors: Vec<QueryCursor>,
+}
+
+thread_local! {
+    pub static PARSER: RefCell<TsParser> = RefCell::new(TsParser {
+        parser: Parser::new(),
+        cursors: Vec::new(),
+    });
+}
+
+/// Represents the reason why syntax highlighting failed.
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum Error {
+    #[error("Cancelled")]
+    Cancelled,
+    #[error("Invalid language")]
+    InvalidLanguage,
+    #[error("Unknown error")]
+    Unknown,
+}
+
+#[derive(Debug, Clone)]
+pub struct LanguageLayer {
+    // mode
+    // grammar
+    pub config: Arc<HighlightConfiguration>,
+    pub(crate) tree: Option<Tree>,
+    pub ranges: Vec<tree_sitter::Range>,
+    pub depth: usize,
+    rev: u64,
+}
+
+impl LanguageLayer {
+    pub fn tree(&self) -> &Tree {
+        self.tree.as_ref().unwrap()
+    }
+
+    pub fn try_tree(&self) -> Option<&Tree> {
+        self.tree.as_ref()
+    }
+
+    fn parse(
+        &mut self,
+        parser: &mut Parser,
+        source: &Rope,
+        had_edits: bool,
+    ) -> Result<(), Error> {
+        parser.set_included_ranges(&self.ranges).unwrap();
+
+        parser
+            .set_language(self.config.language)
+            .map_err(|_| Error::InvalidLanguage)?;
+
+        // unsafe { syntax.parser.set_cancellation_flag(cancellation_flag) };
+        let tree = parser
+            .parse_with(
+                &mut |byte, _| {
+                    if byte <= source.len() {
+                        source
+                            .iter_chunks(byte..)
+                            .next()
+                            .map(|s| s.as_bytes())
+                            .unwrap_or(&[])
+                    } else {
+                        &[]
+                    }
+                },
+                had_edits.then_some(()).and(self.tree.as_ref()),
+            )
+            .ok_or(Error::Cancelled)?;
+        // unsafe { ts_parser.parser.set_cancellation_flag(None) };
+        self.tree = Some(tree);
+        Ok(())
+    }
+}
+
+#[derive(Clone)]
+pub struct SyntaxLayers {
+    layers: HopSlotMap<LayerId, LanguageLayer>,
+    root: LayerId,
+}
+impl SyntaxLayers {
+    pub fn new_empty(config: Arc<HighlightConfiguration>) -> SyntaxLayers {
+        Self::new(None, config)
+    }
+
+    pub fn new(
+        source: Option<&Rope>,
+        config: Arc<HighlightConfiguration>,
+    ) -> SyntaxLayers {
+        let root_layer = LanguageLayer {
+            tree: None,
+            config,
+            depth: 0,
+            ranges: vec![tree_sitter::Range {
+                start_byte: 0,
+                end_byte: usize::MAX,
+                start_point: Point::new(0, 0),
+                end_point: Point::new(usize::MAX, usize::MAX),
+            }],
+            rev: 0,
+        };
+
+        let mut layers = HopSlotMap::default();
+        let root = layers.insert(root_layer);
+
+        let mut syntax = SyntaxLayers { root, layers };
+
+        if let Some(source) = source {
+            let _ = syntax.update(0, 0, source, None);
+        }
+
+        syntax
+    }
+
+    pub fn update(
+        &mut self,
+        current_rev: u64,
+        new_rev: u64,
+        source: &Rope,
+        syntax_edits: Option<&[SyntaxEdit]>,
+    ) -> Result<(), Error> {
+        let mut queue = VecDeque::new();
+        queue.push_back(self.root);
+
+        let injection_callback = |language: &str| {
+            LapceLanguage::from_name(language)
+                .map(get_highlight_config)
+                .unwrap_or(Err(highlight::HighlightIssue::NotAvailable))
+        };
+
+        let mut edits = Vec::new();
+        if let Some(syntax_edits) = syntax_edits {
+            for edit in syntax_edits {
+                for edit in &edit.0 {
+                    edits.push(edit);
+                }
+            }
+        }
+
+        // Use the edits to update all layers markers
+        if !edits.is_empty() {
+            fn point_add(a: Point, b: Point) -> Point {
+                if b.row > 0 {
+                    Point::new(a.row.saturating_add(b.row), b.column)
+                } else {
+                    Point::new(0, a.column.saturating_add(b.column))
+                }
+            }
+            fn point_sub(a: Point, b: Point) -> Point {
+                if a.row > b.row {
+                    Point::new(a.row.saturating_sub(b.row), a.column)
+                } else {
+                    Point::new(0, a.column.saturating_sub(b.column))
+                }
+            }
+
+            for layer in &mut self.layers.values_mut() {
+                // The root layer always covers the whole range (0..usize::MAX)
+                if layer.depth == 0 {
+                    continue;
+                }
+
+                for range in &mut layer.ranges {
+                    // Roughly based on https://github.com/tree-sitter/tree-sitter/blob/ddeaa0c7f534268b35b4f6cb39b52df082754413/lib/src/subtree.c#L691-L720
+                    for edit in edits.iter().rev() {
+                        let is_pure_insertion = edit.old_end_byte == edit.start_byte;
+
+                        // if edit is after range, skip
+                        if edit.start_byte > range.end_byte {
+                            // TODO: || (is_noop && edit.start_byte == range.end_byte)
+                            continue;
+                        }
+
+                        // if edit is before range, shift entire range by len
+                        if edit.old_end_byte < range.start_byte {
+                            range.start_byte = edit.new_end_byte
+                                + (range.start_byte - edit.old_end_byte);
+                            range.start_point = point_add(
+                                edit.new_end_position,
+                                point_sub(range.start_point, edit.old_end_position),
+                            );
+
+                            range.end_byte = edit
+                                .new_end_byte
+                                .saturating_add(range.end_byte - edit.old_end_byte);
+                            range.end_point = point_add(
+                                edit.new_end_position,
+                                point_sub(range.end_point, edit.old_end_position),
+                            );
+                        }
+                        // if the edit starts in the space before and extends into the range
+                        else if edit.start_byte < range.start_byte {
+                            range.start_byte = edit.new_end_byte;
+                            range.start_point = edit.new_end_position;
+
+                            range.end_byte = range
+                                .end_byte
+                                .saturating_sub(edit.old_end_byte)
+                                .saturating_add(edit.new_end_byte);
+                            range.end_point = point_add(
+                                edit.new_end_position,
+                                point_sub(range.end_point, edit.old_end_position),
+                            );
+                        }
+                        // If the edit is an insertion at the start of the tree, shift
+                        else if edit.start_byte == range.start_byte
+                            && is_pure_insertion
+                        {
+                            range.start_byte = edit.new_end_byte;
+                            range.start_point = edit.new_end_position;
+                        } else {
+                            range.end_byte = range
+                                .end_byte
+                                .saturating_sub(edit.old_end_byte)
+                                .saturating_add(edit.new_end_byte);
+                            range.end_point = point_add(
+                                edit.new_end_position,
+                                point_sub(range.end_point, edit.old_end_position),
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        PARSER.with(|ts_parser| {
+            let ts_parser = &mut ts_parser.borrow_mut();
+            let mut cursor = ts_parser.cursors.pop().unwrap_or_else(QueryCursor::new);
+            // TODO: might need to set cursor range
+            cursor.set_byte_range(0..usize::MAX);
+
+            let mut touched = HashSet::new();
+
+            // TODO: we should be able to avoid editing & parsing layers with ranges earlier in the document before the edit
+
+            while let Some(layer_id) = queue.pop_front() {
+                // Mark the layer as touched
+                touched.insert(layer_id);
+
+                let layer = &mut self.layers[layer_id];
+
+                let had_edits = layer.rev == current_rev && syntax_edits.is_some();
+                // If a tree already exists, notify it of changes.
+                if had_edits {
+                    if let Some(tree) = &mut layer.tree {
+                        for edit in edits.iter() {
+                            tree.edit(edit);
+                        }
+                    }
+                }
+
+                // Re-parse the tree.
+                layer.parse(&mut ts_parser.parser, source, had_edits)?;
+                layer.rev = new_rev;
+
+                // Switch to an immutable borrow.
+                let layer = &self.layers[layer_id];
+
+                // Process injections.
+                let matches = cursor.matches(
+                    &layer.config.injections_query,
+                    layer.tree().root_node(),
+                    RopeProvider(source),
+                );
+                let mut injections = Vec::new();
+                for mat in matches {
+                    let (language_name, content_node, included_children) = injection_for_match(
+                        &layer.config,
+                        &layer.config.injections_query,
+                        &mat,
+                        source,
+                    );
+
+                    // Explicitly remove this match so that none of its other captures will remain
+                    // in the stream of captures.
+                    mat.remove();
+
+                    // If a language is found with the given name, then add a new language layer
+                    // to the highlighted document.
+                    if let (Some(language_name), Some(content_node)) = (language_name, content_node)
+                    {
+                        if let Ok(config) = (injection_callback)(&language_name) {
+                            let ranges =
+                                intersect_ranges(&layer.ranges, &[content_node], included_children);
+
+                            if !ranges.is_empty() {
+                                injections.push((config, ranges));
+                            }
+                        }
+                    }
+                }
+
+                // Process combined injections.
+                if let Some(combined_injections_query) = &layer.config.combined_injections_query {
+                    let mut injections_by_pattern_index =
+                        vec![
+                            (None, Vec::new(), IncludedChildren::default());
+                            combined_injections_query.pattern_count()
+                        ];
+                    let matches = cursor.matches(
+                        combined_injections_query,
+                        layer.tree().root_node(),
+                        RopeProvider(source),
+                    );
+                    for mat in matches {
+                        let entry = &mut injections_by_pattern_index[mat.pattern_index];
+                        let (language_name, content_node, included_children) = injection_for_match(
+                            &layer.config,
+                            combined_injections_query,
+                            &mat,
+                            source,
+                        );
+                        if language_name.is_some() {
+                            entry.0 = language_name;
+                        }
+                        if let Some(content_node) = content_node {
+                            entry.1.push(content_node);
+                        }
+                        entry.2 = included_children;
+                    }
+                    for (lang_name, content_nodes, included_children) in injections_by_pattern_index
+                    {
+                        if let (Some(lang_name), false) = (lang_name, content_nodes.is_empty()) {
+                            if let Ok(config) = (injection_callback)(&lang_name) {
+                                let ranges = intersect_ranges(
+                                    &layer.ranges,
+                                    &content_nodes,
+                                    included_children,
+                                );
+                                if !ranges.is_empty() {
+                                    injections.push((config, ranges));
+                                }
+                            }
+                        }
+                    }
+                }
+
+                let depth = layer.depth + 1;
+                // TODO: can't inline this since matches borrows self.layers
+                for (config, ranges) in injections {
+                    // Find an existing layer
+                    let layer = self
+                        .layers
+                        .iter_mut()
+                        .find(|(_, layer)| {
+                            layer.depth == depth && // TODO: track parent id instead
+                            layer.config.language == config.language && layer.ranges == ranges
+                        })
+                        .map(|(id, _layer)| id);
+
+                    // ...or insert a new one.
+                    let layer_id = layer.unwrap_or_else(|| {
+                        self.layers.insert(LanguageLayer {
+                            tree: None,
+                            config,
+                            depth,
+                            ranges,
+                            rev: 0,
+                        })
+                    });
+
+                    queue.push_back(layer_id);
+                }
+
+                // TODO: pre-process local scopes at this time, rather than highlight?
+                // would solve problems with locals not working across boundaries
+            }
+
+            // Return the cursor back in the pool.
+            ts_parser.cursors.push(cursor);
+
+            // Remove all untouched layers
+            self.layers.retain(|id, _| touched.contains(&id));
+
+            Ok(())
+        })
+    }
+
+    pub fn tree(&self) -> &Tree {
+        self.layers[self.root].tree()
+    }
+
+    pub fn try_tree(&self) -> Option<&Tree> {
+        self.layers[self.root].try_tree()
+    }
+
+    /// Iterate over the highlighted regions for a given slice of source code.
+    pub fn highlight_iter<'a>(
+        &'a self,
+        source: &'a Rope,
+        range: Option<std::ops::Range<usize>>,
+        cancellation_flag: Option<&'a AtomicUsize>,
+    ) -> impl Iterator<Item = Result<HighlightEvent, Error>> + 'a {
+        let mut layers = self
+            .layers
+            .iter()
+            .filter_map(|(_, layer)| {
+                // TODO: if range doesn't overlap layer range, skip it
+
+                // Reuse a cursor from the pool if available.
+                let mut cursor = PARSER.with(|ts_parser| {
+                    let highlighter = &mut ts_parser.borrow_mut();
+                    highlighter.cursors.pop().unwrap_or_else(QueryCursor::new)
+                });
+
+                // The `captures` iterator borrows the `Tree` and the `QueryCursor`, which
+                // prevents them from being moved. But both of these values are really just
+                // pointers, so it's actually ok to move them.
+                let cursor_ref = unsafe {
+                    mem::transmute::<_, &'static mut QueryCursor>(&mut cursor)
+                };
+
+                // if reusing cursors & no range this resets to whole range
+                cursor_ref.set_byte_range(range.clone().unwrap_or(0..usize::MAX));
+
+                let mut captures = cursor_ref
+                    .captures(
+                        &layer.config.query,
+                        layer.tree().root_node(),
+                        RopeProvider(source),
+                    )
+                    .peekable();
+
+                // If there's no captures, skip the layer
+                captures.peek()?;
+
+                Some(HighlightIterLayer {
+                    highlight_end_stack: Vec::new(),
+                    scope_stack: vec![LocalScope {
+                        inherits: false,
+                        range: 0..usize::MAX,
+                        local_defs: Vec::new(),
+                    }],
+                    cursor,
+                    _tree: None,
+                    captures,
+                    config: layer.config.as_ref(), // TODO: just reuse `layer`
+                    depth: layer.depth,            // TODO: just reuse `layer`
+                    ranges: &layer.ranges,         // TODO: temp
+                })
+            })
+            .collect::<Vec<_>>();
+
+        // HAXX: arrange layers by byte range, with deeper layers positioned first
+        layers.sort_by_key(|layer| {
+            (
+                layer.ranges.first().cloned(),
+                std::cmp::Reverse(layer.depth),
+            )
+        });
+
+        let mut result = HighlightIter {
+            source,
+            byte_offset: range.map_or(0, |r| r.start),
+            cancellation_flag,
+            iter_count: 0,
+            layers,
+            next_event: None,
+            last_highlight_range: None,
+        };
+        result.sort_layers();
+        result
+    }
+
+    // Commenting
+    // comment_strings_for_pos
+    // is_commented
+
+    // Indentation
+    // suggested_indent_for_line_at_buffer_row
+    // suggested_indent_for_buffer_row
+    // indent_level_for_line
+
+    // TODO: Folding
+}
+
+#[derive(Clone)]
+pub struct Syntax {
+    pub rev: u64,
+    pub language: LapceLanguage,
+    pub text: Rope,
+    pub layers: SyntaxLayers,
+    pub lens: Lens,
+    pub normal_lines: Vec<usize>,
+    pub line_height: usize,
+    pub lens_height: usize,
+    pub styles: Option<Arc<Spans<Style>>>,
+}
+
+impl std::fmt::Debug for Syntax {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Syntax")
+            .field("rev", &self.rev)
+            .field("language", &self.language)
+            .field("text", &self.text)
+            .field("normal_lines", &self.normal_lines)
+            .field("line_height", &self.line_height)
+            .field("lens_height", &self.lens_height)
+            .field("styles", &self.styles)
+            .finish()
+    }
+}
+
+impl Syntax {
+    pub fn init(path: &Path) -> Result<Syntax, HighlightIssue> {
+        LapceLanguage::from_path(path)
+            .map(Syntax::from_language)
+            .unwrap_or(Err(HighlightIssue::NotAvailable))
+    }
+
+    pub fn from_language(language: LapceLanguage) -> Result<Syntax, HighlightIssue> {
+        get_highlight_config(language).map(|x| Syntax {
+            rev: 0,
+            language,
+            text: Rope::from(""),
+            layers: SyntaxLayers::new_empty(x),
+            lens: Self::lens_from_normal_lines(0, 0, 0, &Vec::new()),
+            line_height: 0,
+            lens_height: 0,
+            normal_lines: Vec::new(),
+            styles: None,
+        })
+    }
+
+    pub fn parse(
+        &mut self,
+        new_rev: u64,
+        new_text: Rope,
+        edits: Option<&[SyntaxEdit]>,
+    ) {
+        let edits = edits.filter(|edits| new_rev == self.rev + edits.len() as u64);
+        let _ = self.layers.update(self.rev, new_rev, &new_text, edits);
+        let tree = self.layers.try_tree();
+
+        let styles = if tree.is_some() {
+            let mut current_hl: Option<Highlight> = None;
+            let mut highlights: SpansBuilder<Style> =
+                SpansBuilder::new(new_text.len());
+
+            // TODO: Should we be ignoring highlight errors via flattening them?
+            for highlight in self
+                .layers
+                .highlight_iter(&new_text, Some(0..new_text.len()), None)
+                .flatten()
+            {
+                match highlight {
+                    HighlightEvent::Source { start, end } => {
+                        if let Some(hl) = current_hl {
+                            if let Some(hl) = SCOPES.get(hl.0) {
+                                highlights.add_span(
+                                    Interval::new(start, end),
+                                    Style {
+                                        fg_color: Some(hl.to_string()),
+                                    },
+                                );
+                            }
+                        }
+                    }
+                    HighlightEvent::HighlightStart(hl) => {
+                        current_hl = Some(hl);
+                    }
+                    HighlightEvent::HighlightEnd => current_hl = None,
+                }
+            }
+
+            Some(Arc::new(highlights.build()))
+        } else {
+            None
+        };
+
+        let normal_lines = if let Some(tree) = tree {
+            let mut cursor = tree.walk();
+            let mut normal_lines = HashSet::new();
+            self.language.walk_tree(&mut cursor, &mut normal_lines);
+            normal_lines.into_iter().sorted().collect::<Vec<usize>>()
+        } else {
+            Vec::new()
+        };
+
+        let lens = Self::lens_from_normal_lines(
+            new_text.line_of_offset(new_text.len()) + 1,
+            self.line_height,
+            self.lens_height,
+            &normal_lines,
+        );
+
+        self.rev = new_rev;
+        self.lens = lens;
+        self.normal_lines = normal_lines;
+        self.styles = styles;
+        self.text = new_text
+    }
+
+    pub fn update_lens_height(&mut self, line_height: usize, lens_height: usize) {
+        self.lens = Self::lens_from_normal_lines(
+            self.text.line_of_offset(self.text.len()) + 1,
+            line_height,
+            lens_height,
+            &self.normal_lines,
+        );
+        self.line_height = line_height;
+        self.lens_height = lens_height;
+    }
+
+    pub fn lens_from_normal_lines(
+        total_lines: usize,
+        line_height: usize,
+        lens_height: usize,
+        normal_lines: &[usize],
+    ) -> Lens {
+        let mut builder = LensBuilder::new();
+        let mut current_line = 0;
+        for normal_line in normal_lines.iter() {
+            let normal_line = *normal_line;
+            if normal_line > current_line {
+                builder.add_section(normal_line - current_line, lens_height);
+            }
+            builder.add_section(1, line_height);
+            current_line = normal_line + 1;
+        }
+        if current_line < total_lines {
+            builder.add_section(total_lines - current_line, lens_height);
+        }
+        builder.build()
+    }
+
+    pub fn find_matching_pair(&self, offset: usize) -> Option<usize> {
+        let tree = self.layers.try_tree()?;
+        let node = tree
+            .root_node()
+            .descendant_for_byte_range(offset, offset + 1)?;
+        let char = node.kind().chars().next()?;
+        let tag: &'static str = matching_bracket_general(char)?;
+
+        if let Some(offset) = self.find_tag_in_siblings(node, true, tag) {
+            return Some(offset);
+        }
+        if let Some(offset) = self.find_tag_in_siblings(node, false, tag) {
+            return Some(offset);
+        }
+        None
+    }
+
+    pub fn parent_offset(&self, offset: usize) -> Option<usize> {
+        let tree = self.layers.try_tree()?;
+        let node = tree
+            .root_node()
+            .descendant_for_byte_range(offset, offset + 1)?;
+        let parent = node.parent()?;
+        Some(parent.start_byte())
+    }
+
+    pub fn find_tag(
+        &self,
+        offset: usize,
+        previous: bool,
+        tag: &str,
+    ) -> Option<usize> {
+        let tree = self.layers.try_tree()?;
+        let node = tree
+            .root_node()
+            .descendant_for_byte_range(offset, offset + 1)?;
+
+        if let Some(offset) = self.find_tag_in_siblings(node, previous, tag) {
+            return Some(offset);
+        }
+
+        if let Some(offset) = self.find_tag_in_children(node, tag) {
+            return Some(offset);
+        }
+
+        let mut node = node;
+        while let Some(parent) = node.parent() {
+            if let Some(offset) = self.find_tag_in_siblings(parent, previous, tag) {
+                return Some(offset);
+            }
+            node = parent;
+        }
+        None
+    }
+
+    fn find_tag_in_siblings(
+        &self,
+        node: Node,
+        previous: bool,
+        tag: &str,
+    ) -> Option<usize> {
+        let mut node = node;
+        while let Some(sibling) = if previous {
+            node.prev_sibling()
+        } else {
+            node.next_sibling()
+        } {
+            if sibling.kind() == tag {
+                let offset = sibling.start_byte();
+                return Some(offset);
+            }
+            node = sibling;
+        }
+        None
+    }
+
+    fn find_tag_in_children(&self, node: Node, tag: &str) -> Option<usize> {
+        for i in 0..node.child_count() {
+            if let Some(child) = node.child(i) {
+                if child.kind() == tag {
+                    let offset = child.start_byte();
+                    return Some(offset);
+                }
+            }
+        }
+        None
+    }
+
+    pub fn sticky_headers(&self, offset: usize) -> Option<Vec<usize>> {
+        let tree = self.layers.try_tree()?;
+        let mut node = tree.root_node().descendant_for_byte_range(offset, offset)?;
+        let mut offsets = Vec::new();
+        let sticky_header_tags = self.language.sticky_header_tags();
+        loop {
+            if sticky_header_tags.iter().any(|t| *t == node.kind()) {
+                offsets.push(node.start_byte());
+            }
+            if let Some(p) = node.parent() {
+                node = p;
+            } else {
+                break;
+            }
+        }
+        Some(offsets)
+    }
+
+    pub fn find_enclosing_parentheses(
+        &self,
+        offset: usize,
+    ) -> Option<(usize, usize)> {
+        // If there is no text then the document can't have any bytes
+        if self.text.is_empty() {
+            return None;
+        }
+        if offset >= self.text.len() {
+            return None;
+        }
+
+        let tree = self.layers.try_tree()?;
+        let mut node = tree.root_node().descendant_for_byte_range(offset, offset)?;
+
+        loop {
+            let start = node.start_byte();
+            if start >= self.text.len() {
+                return None;
+            }
+            let c = self.text.byte_at(start) as char;
+            if c == '(' {
+                let end = self.find_matching_pair(start)?;
+                if end >= offset && start < offset {
+                    return Some((start, end));
+                }
+            }
+            if let Some(sibling) = node.prev_sibling() {
+                node = sibling;
+            } else if let Some(parent) = node.parent() {
+                node = parent;
+            } else {
+                return None;
+            }
+        }
+    }
+
+    pub fn find_enclosing_pair(&self, offset: usize) -> Option<(usize, usize)> {
+        // If there is no text then the document can't have any bytes
+        if self.text.is_empty() {
+            return None;
+        }
+        if offset >= self.text.len() {
+            return None;
+        }
+
+        let tree = self.layers.try_tree()?;
+        let mut node = tree.root_node().descendant_for_byte_range(offset, offset)?;
+
+        loop {
+            let start = node.start_byte();
+            if start >= self.text.len() {
+                return None;
+            }
+            let c = self.text.byte_at(start) as char;
+            if matching_pair_direction(c) == Some(true) {
+                let end = self.find_matching_pair(start)?;
+                if end >= offset {
+                    return Some((start, end));
+                }
+            }
+            if let Some(sibling) = node.prev_sibling() {
+                node = sibling;
+            } else if let Some(parent) = node.parent() {
+                node = parent;
+            } else {
+                return None;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_lens() {
+        let lens = Syntax::lens_from_normal_lines(5, 25, 2, &[4]);
+        assert_eq!(5, lens.len());
+        assert_eq!(8, lens.height_of_line(4));
+        assert_eq!(33, lens.height_of_line(5));
+
+        let lens = Syntax::lens_from_normal_lines(5, 25, 2, &[3]);
+        assert_eq!(5, lens.len());
+        assert_eq!(6, lens.height_of_line(3));
+        assert_eq!(31, lens.height_of_line(4));
+        assert_eq!(33, lens.height_of_line(5));
+    }
+
+    #[test]
+    fn test_lens_iter() {
+        let lens = Syntax::lens_from_normal_lines(5, 25, 2, &[0, 2, 4]);
+        assert_eq!(5, lens.len());
+        let mut iter = lens.iter_chunks(2..5);
+        assert_eq!(Some((2, 25)), iter.next());
+        assert_eq!(Some((3, 2)), iter.next());
+        assert_eq!(Some((4, 25)), iter.next());
+        assert_eq!(None, iter.next());
+
+        let lens =
+            Syntax::lens_from_normal_lines(91, 25, 2, &[0, 11, 14, 54, 57, 90]);
+        assert_eq!(91, lens.len());
+        let mut iter = lens.iter_chunks(89..91);
+        assert_eq!(Some((89, 2)), iter.next());
+        assert_eq!(Some((90, 25)), iter.next());
+        assert_eq!(None, iter.next());
+    }
+}
diff --git a/lapce-core/src/syntax/util.rs b/lapce-core/src/syntax/util.rs
new file mode 100644
index 0000000000..a0770f3781
--- /dev/null
+++ b/lapce-core/src/syntax/util.rs
@@ -0,0 +1,155 @@
+use core::str::FromStr;
+use std::collections::HashMap;
+
+use lapce_xi_rope::{rope::ChunkIter, Rope};
+use tree_sitter::TextProvider;
+
+pub struct RopeChunksIterBytes<'a> {
+    chunks: ChunkIter<'a>,
+}
+impl<'a> Iterator for RopeChunksIterBytes<'a> {
+    type Item = &'a [u8];
+    fn next(&mut self) -> Option<Self::Item> {
+        self.chunks.next().map(str::as_bytes)
+    }
+}
+
+/// This allows tree-sitter to iterate over our Rope without us having to convert it into
+/// a contiguous byte-list.
+pub struct RopeProvider<'a>(pub &'a Rope);
+impl<'a> TextProvider<'a> for RopeProvider<'a> {
+    type I = RopeChunksIterBytes<'a>;
+    fn text(&mut self, node: tree_sitter::Node) -> Self::I {
+        let start = node.start_byte();
+        let end = node.end_byte().min(self.0.len());
+        let chunks = self.0.iter_chunks(start..end);
+        RopeChunksIterBytes { chunks }
+    }
+}
+
+/// If the character is an opening bracket return Some(true), if closing, return Some(false)
+pub fn matching_pair_direction(c: char) -> Option<bool> {
+    Some(match c {
+        '{' => true,
+        '}' => false,
+        '(' => true,
+        ')' => false,
+        '[' => true,
+        ']' => false,
+        _ => return None,
+    })
+}
+
+pub fn matching_char(c: char) -> Option<char> {
+    Some(match c {
+        '{' => '}',
+        '}' => '{',
+        '(' => ')',
+        ')' => '(',
+        '[' => ']',
+        ']' => '[',
+        _ => return None,
+    })
+}
+
+/// If the given character is a parenthesis, returns its matching bracket
+pub fn matching_bracket_general<R: ToStaticTextType>(char: char) -> Option<R>
+where
+    &'static str: ToStaticTextType<R>,
+{
+    let pair = match char {
+        '{' => "}",
+        '}' => "{",
+        '(' => ")",
+        ')' => "(",
+        '[' => "]",
+        ']' => "[",
+        _ => return None,
+    };
+    Some(pair.to_static())
+}
+
+pub trait ToStaticTextType<R: 'static = Self>: 'static {
+    fn to_static(self) -> R;
+}
+
+impl ToStaticTextType for &'static str {
+    #[inline]
+    fn to_static(self) -> &'static str {
+        self
+    }
+}
+
+impl ToStaticTextType<char> for &'static str {
+    #[inline]
+    fn to_static(self) -> char {
+        char::from_str(self).unwrap()
+    }
+}
+
+impl ToStaticTextType<String> for &'static str {
+    #[inline]
+    fn to_static(self) -> String {
+        self.to_string()
+    }
+}
+
+impl ToStaticTextType for char {
+    #[inline]
+    fn to_static(self) -> char {
+        self
+    }
+}
+
+impl ToStaticTextType for String {
+    #[inline]
+    fn to_static(self) -> String {
+        self
+    }
+}
+
+pub fn has_unmatched_pair(line: &str) -> bool {
+    let mut count = HashMap::new();
+    let mut pair_first = HashMap::new();
+    for c in line.chars().rev() {
+        if let Some(left) = matching_pair_direction(c) {
+            let key = if left { c } else { matching_char(c).unwrap() };
+            let pair_count = *count.get(&key).unwrap_or(&0i32);
+            pair_first.entry(key).or_insert(left);
+            if left {
+                count.insert(key, pair_count - 1);
+            } else {
+                count.insert(key, pair_count + 1);
+            }
+        }
+    }
+    for (_, pair_count) in count.iter() {
+        if *pair_count < 0 {
+            return true;
+        }
+    }
+    for (_, left) in pair_first.iter() {
+        if *left {
+            return true;
+        }
+    }
+    false
+}
+
+pub fn str_is_pair_left(c: &str) -> bool {
+    if c.chars().count() == 1 {
+        let c = c.chars().next().unwrap();
+        if matching_pair_direction(c).unwrap_or(false) {
+            return true;
+        }
+    }
+    false
+}
+
+pub fn str_matching_pair(c: &str) -> Option<char> {
+    if c.chars().count() == 1 {
+        let c = c.chars().next().unwrap();
+        return matching_char(c);
+    }
+    None
+}
diff --git a/lapce-core/src/word.rs b/lapce-core/src/word.rs
index 1a3e4a93d5..1e2a9cbcad 100644
--- a/lapce-core/src/word.rs
+++ b/lapce-core/src/word.rs
@@ -1,21 +1,35 @@
-use xi_rope::{Cursor, Rope, RopeInfo};
+use lapce_xi_rope::{Cursor, Rope, RopeInfo};
 
-use crate::syntax::{matching_char, matching_pair_direction};
+use crate::{
+    mode::Mode,
+    syntax::util::{matching_char, matching_pair_direction},
+};
 
-#[derive(Copy, Clone, PartialEq)]
-pub enum WordProperty {
+/// Describe char classifications used to compose word boundaries
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum CharClassification {
+    /// Carriage Return (`r`)
     Cr,
+    /// Line feed (`\n`)
     Lf,
+    /// Whitespace character
     Space,
+    /// Any punctuation character
     Punctuation,
-    Other, // includes letters and all of non-ascii unicode
+    /// Includes letters and all of non-ascii unicode
+    Other,
 }
 
+/// A word boundary can be the start of a word, its end or both for punctuation
 #[derive(PartialEq, Eq)]
 enum WordBoundary {
+    /// Denote that this is not a boundary
     Interior,
-    Start, // a boundary indicating the end of a word
-    End,   // a boundary indicating the start of a word
+    /// A boundary indicating the end of a word
+    Start,
+    /// A boundary indicating the start of a word
+    End,
+    /// Both start and end boundaries (ex: punctuation characters)
     Both,
 }
 
@@ -28,11 +42,15 @@ impl WordBoundary {
         *self == WordBoundary::End || *self == WordBoundary::Both
     }
 
+    #[allow(unused)]
     fn is_boundary(&self) -> bool {
         *self != WordBoundary::Interior
     }
 }
 
+/// A cursor providing utility function to navigate the rope
+/// by word boundaries.
+/// Boundaries can be the start of a word, its end, punctuation etc.
 pub struct WordCursor<'a> {
     pub(crate) inner: Cursor<'a, RopeInfo>,
 }
@@ -43,16 +61,39 @@ impl<'a> WordCursor<'a> {
         WordCursor { inner }
     }
 
-    /// Get previous boundary, and set the cursor at the boundary found.
-    pub fn prev_boundary(&mut self) -> Option<usize> {
+    /// Get the previous start boundary of a word, and set the cursor position to the boundary found.
+    /// The behaviour diffs a bit on new line character with modal and non modal,
+    /// while on modal, it will ignore the new line character and on non-modal,
+    /// it will stop at the new line character
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::word::WordCursor;
+    /// # use lapce_core::mode::Mode;
+    /// # use lapce_xi_rope::Rope;
+    /// let rope = Rope::from("Hello world");
+    /// let mut cursor = WordCursor::new(&rope, 4);
+    /// let boundary = cursor.prev_boundary(Mode::Insert);
+    /// assert_eq!(boundary, Some(0));
+    ///```
+    pub fn prev_boundary(&mut self, mode: Mode) -> Option<usize> {
         if let Some(ch) = self.inner.prev_codepoint() {
-            let mut prop = get_word_property(ch);
+            let mut prop = get_char_property(ch);
             let mut candidate = self.inner.pos();
             while let Some(prev) = self.inner.prev_codepoint() {
-                let prop_prev = get_word_property(prev);
+                let prop_prev = get_char_property(prev);
                 if classify_boundary(prop_prev, prop).is_start() {
                     break;
                 }
+
+                // Stop if line beginning reached, without any non-whitespace characters
+                if mode == Mode::Insert
+                    && prop_prev == CharClassification::Lf
+                    && prop == CharClassification::Space
+                {
+                    break;
+                }
+
                 prop = prop_prev;
                 candidate = self.inner.pos();
             }
@@ -62,11 +103,90 @@ impl<'a> WordCursor<'a> {
         None
     }
 
+    /// Computes where the cursor position should be after backward deletion.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::word::WordCursor;
+    /// # use lapce_xi_rope::Rope;
+    /// let text = "violet are blue";
+    /// let rope = Rope::from(text);
+    /// let mut cursor = WordCursor::new(&rope, 9);
+    /// let position = cursor.prev_deletion_boundary();
+    /// let position = position;
+    ///
+    /// assert_eq!(position, Some(7));
+    /// assert_eq!(&text[..position.unwrap()], "violet ");
+    ///```
+    pub fn prev_deletion_boundary(&mut self) -> Option<usize> {
+        if let Some(ch) = self.inner.prev_codepoint() {
+            let mut prop = get_char_property(ch);
+            let mut candidate = self.inner.pos();
+
+            // Flag, determines if the word should be deleted or not
+            // If not, erase only whitespace characters.
+            let mut keep_word = false;
+            while let Some(prev) = self.inner.prev_codepoint() {
+                let prop_prev = get_char_property(prev);
+
+                // Stop if line beginning reached, without any non-whitespace characters
+                if prop_prev == CharClassification::Lf
+                    && prop == CharClassification::Space
+                {
+                    break;
+                }
+
+                // More than a single whitespace: keep word, remove only whitespaces
+                if prop == CharClassification::Space
+                    && prop_prev == CharClassification::Space
+                {
+                    keep_word = true;
+                }
+
+                // Line break found: keep words, delete line break & trailing whitespaces
+                if prop == CharClassification::Lf || prop == CharClassification::Cr {
+                    keep_word = true;
+                }
+
+                // Skip word deletion if above conditions were met
+                if keep_word
+                    && (prop_prev == CharClassification::Punctuation
+                        || prop_prev == CharClassification::Other)
+                {
+                    break;
+                }
+
+                // Default deletion
+                if classify_boundary(prop_prev, prop).is_start() {
+                    break;
+                }
+                prop = prop_prev;
+                candidate = self.inner.pos();
+            }
+            self.inner.set(candidate);
+            return Some(candidate);
+        }
+        None
+    }
+
+    /// Get the position of the next non blank character in the rope
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::word::WordCursor;
+    /// # use lapce_xi_rope::Rope;
+    /// let rope = Rope::from("    world");
+    /// let mut cursor = WordCursor::new(&rope, 0);
+    /// let char_position = cursor.next_non_blank_char();
+    /// assert_eq!(char_position, 4);
+    ///```
     pub fn next_non_blank_char(&mut self) -> usize {
         let mut candidate = self.inner.pos();
         while let Some(next) = self.inner.next_codepoint() {
-            let prop = get_word_property(next);
-            if prop != WordProperty::Space {
+            let prop = get_char_property(next);
+            if prop != CharClassification::Space {
                 break;
             }
             candidate = self.inner.pos();
@@ -75,13 +195,23 @@ impl<'a> WordCursor<'a> {
         candidate
     }
 
-    /// Get next boundary, and set the cursor at the boundary found.
+    /// Get the next start boundary of a word, and set the cursor position to the boundary found.
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::word::WordCursor;
+    /// # use lapce_xi_rope::Rope;
+    /// let rope = Rope::from("Hello world");
+    /// let mut cursor = WordCursor::new(&rope, 0);
+    /// let boundary = cursor.next_boundary();
+    /// assert_eq!(boundary, Some(6));
+    ///```
     pub fn next_boundary(&mut self) -> Option<usize> {
         if let Some(ch) = self.inner.next_codepoint() {
-            let mut prop = get_word_property(ch);
+            let mut prop = get_char_property(ch);
             let mut candidate = self.inner.pos();
             while let Some(next) = self.inner.next_codepoint() {
-                let prop_next = get_word_property(next);
+                let prop_next = get_char_property(next);
                 if classify_boundary(prop, prop_next).is_start() {
                     break;
                 }
@@ -94,13 +224,24 @@ impl<'a> WordCursor<'a> {
         None
     }
 
+    /// Get the next end boundary, and set the cursor position to the boundary found.
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::word::WordCursor;
+    /// # use lapce_xi_rope::Rope;
+    /// let rope = Rope::from("Hello world");
+    /// let mut cursor = WordCursor::new(&rope, 3);
+    /// let end_boundary = cursor.end_boundary();
+    /// assert_eq!(end_boundary, Some(5));
+    ///```
     pub fn end_boundary(&mut self) -> Option<usize> {
         self.inner.next_codepoint();
         if let Some(ch) = self.inner.next_codepoint() {
-            let mut prop = get_word_property(ch);
+            let mut prop = get_char_property(ch);
             let mut candidate = self.inner.pos();
             while let Some(next) = self.inner.next_codepoint() {
-                let prop_next = get_word_property(next);
+                let prop_next = get_char_property(next);
                 if classify_boundary(prop, prop_next).is_end() {
                     break;
                 }
@@ -113,11 +254,23 @@ impl<'a> WordCursor<'a> {
         None
     }
 
+    /// Get the first matching [`CharClassification::Other`] backward and set the cursor position to this location .
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::word::WordCursor;
+    /// # use lapce_xi_rope::Rope;
+    /// let text = "violet, are\n blue";
+    /// let rope = Rope::from(text);
+    /// let mut cursor = WordCursor::new(&rope, 11);
+    /// let position = cursor.prev_code_boundary();
+    /// assert_eq!(&text[position..], "are\n blue");
+    ///```
     pub fn prev_code_boundary(&mut self) -> usize {
         let mut candidate = self.inner.pos();
         while let Some(prev) = self.inner.prev_codepoint() {
-            let prop_prev = get_word_property(prev);
-            if prop_prev != WordProperty::Other {
+            let prop_prev = get_char_property(prev);
+            if prop_prev != CharClassification::Other {
                 break;
             }
             candidate = self.inner.pos();
@@ -125,11 +278,23 @@ impl<'a> WordCursor<'a> {
         candidate
     }
 
+    /// Get the first matching [`CharClassification::Other`] forward and set the cursor position to this location .
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::word::WordCursor;
+    /// # use lapce_xi_rope::Rope;
+    /// let text = "violet, are\n blue";
+    /// let rope = Rope::from(text);
+    /// let mut cursor = WordCursor::new(&rope, 11);
+    /// let position = cursor.next_code_boundary();
+    /// assert_eq!(&text[position..], "\n blue");
+    ///```
     pub fn next_code_boundary(&mut self) -> usize {
         let mut candidate = self.inner.pos();
         while let Some(prev) = self.inner.next_codepoint() {
-            let prop_prev = get_word_property(prev);
-            if prop_prev != WordProperty::Other {
+            let prop_prev = get_char_property(prev);
+            if prop_prev != CharClassification::Other {
                 break;
             }
             candidate = self.inner.pos();
@@ -137,6 +302,21 @@ impl<'a> WordCursor<'a> {
         candidate
     }
 
+    /// Looks for a matching pair character, either forward for opening chars (ex: `(`) or
+    /// backward for closing char (ex: `}`), and return the matched character position if found.
+    /// Will return `None` if the character under cursor is not matchable (see [`crate::syntax::util::matching_char`]).
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use lapce_core::word::WordCursor;
+    /// # use lapce_xi_rope::Rope;
+    /// let text = "{ }";
+    /// let rope = Rope::from(text);
+    /// let mut cursor = WordCursor::new(&rope, 2);
+    /// let position = cursor.match_pairs();
+    /// assert_eq!(position, Some(0));
+    ///```
     pub fn match_pairs(&mut self) -> Option<usize> {
         let c = self.inner.peek_next_codepoint()?;
         let other = matching_char(c)?;
@@ -150,6 +330,18 @@ impl<'a> WordCursor<'a> {
         }
     }
 
+    /// Take a matchable character and look cforward for the first unmatched one
+    /// ignoring the encountered matched pairs.
+    ///
+    /// **Example**:
+    /// ```rust
+    /// # use lapce_xi_rope::Rope;
+    /// # use lapce_core::word::WordCursor;
+    /// let rope = Rope::from("outer {inner}} world");
+    /// let mut cursor = WordCursor::new(&rope, 0);
+    /// let position = cursor.next_unmatched('}');
+    /// assert_eq!(position, Some(14));
+    ///  ```
     pub fn next_unmatched(&mut self, c: char) -> Option<usize> {
         let other = matching_char(c)?;
         let mut n = 0;
@@ -166,6 +358,19 @@ impl<'a> WordCursor<'a> {
         None
     }
 
+    /// Take a matchable character and look backward for the first unmatched one
+    /// ignoring the encountered matched pairs.
+    ///
+    /// **Example**:
+    ///
+    /// ```rust
+    /// # use lapce_xi_rope::Rope;
+    /// # use lapce_core::word::WordCursor;
+    /// let rope = Rope::from("outer {{inner} world");
+    /// let mut cursor = WordCursor::new(&rope, 15);
+    /// let position = cursor.previous_unmatched('{');
+    /// assert_eq!(position, Some(6));
+    ///  ```
     pub fn previous_unmatched(&mut self, c: char) -> Option<usize> {
         let other = matching_char(c)?;
         let mut n = 0;
@@ -182,6 +387,19 @@ impl<'a> WordCursor<'a> {
         None
     }
 
+    /// Return the previous and end boundaries of the word under cursor.
+    ///
+    /// **Example**:
+    ///
+    ///```rust
+    /// # use lapce_core::word::WordCursor;
+    /// # use lapce_xi_rope::Rope;
+    /// let text = "violet are blue";
+    /// let rope = Rope::from(text);
+    /// let mut cursor = WordCursor::new(&rope, 9);
+    /// let (start, end) = cursor.select_word();
+    /// assert_eq!(&text[start..end], "are");
+    ///```
     pub fn select_word(&mut self) -> (usize, usize) {
         let initial = self.inner.pos();
         let end = self.next_code_boundary();
@@ -190,116 +408,71 @@ impl<'a> WordCursor<'a> {
         (start, end)
     }
 
-    /// Return the selection for the word containing the current cursor. The
-    /// cursor is moved to the end of that selection.
-    pub fn select_word_old(&mut self) -> (usize, usize) {
-        let initial = self.inner.pos();
-        let init_prop_after = self.inner.next_codepoint().map(get_word_property);
-        self.inner.set(initial);
-        let init_prop_before = self.inner.prev_codepoint().map(get_word_property);
-        let mut start = initial;
-        let init_boundary =
-            if let (Some(pb), Some(pa)) = (init_prop_before, init_prop_after) {
-                classify_boundary_initial(pb, pa)
-            } else {
-                WordBoundary::Both
-            };
-        let mut prop_after = init_prop_after;
-        let mut prop_before = init_prop_before;
-        if prop_after.is_none() {
-            start = self.inner.pos();
-            prop_after = prop_before;
-            prop_before = self.inner.prev_codepoint().map(get_word_property);
-        }
-        while let (Some(pb), Some(pa)) = (prop_before, prop_after) {
-            if start == initial {
-                if init_boundary.is_start() {
-                    break;
-                }
-            } else if !init_boundary.is_boundary() {
-                if classify_boundary(pb, pa).is_boundary() {
-                    break;
-                }
-            } else if classify_boundary(pb, pa).is_start() {
-                break;
-            }
-            start = self.inner.pos();
-            prop_after = prop_before;
-            prop_before = self.inner.prev_codepoint().map(get_word_property);
-        }
-        self.inner.set(initial);
-        let mut end = initial;
-        prop_after = init_prop_after;
-        prop_before = init_prop_before;
-        if prop_before.is_none() {
-            prop_before = self.inner.next_codepoint().map(get_word_property);
-            end = self.inner.pos();
-            prop_after = self.inner.next_codepoint().map(get_word_property);
-        }
-        while let (Some(pb), Some(pa)) = (prop_before, prop_after) {
-            if end == initial {
-                if init_boundary.is_end() {
-                    break;
+    /// Return the enclosing brackets of the current position
+    ///
+    /// **Example**:
+    ///
+    ///```rust
+    /// # use lapce_core::word::WordCursor;
+    /// # use lapce_xi_rope::Rope;
+    /// let text = "outer {{inner} world";
+    /// let rope = Rope::from(text);
+    /// let mut cursor = WordCursor::new(&rope, 10);
+    /// let (start, end) = cursor.find_enclosing_pair().unwrap();
+    /// assert_eq!(start, 7);
+    /// assert_eq!(end, 13)
+    ///```
+    pub fn find_enclosing_pair(&mut self) -> Option<(usize, usize)> {
+        let old_offset = self.inner.pos();
+        while let Some(c) = self.inner.prev_codepoint() {
+            if matching_pair_direction(c) == Some(true) {
+                let opening_bracket_offset = self.inner.pos();
+                if let Some(closing_bracket_offset) = self.match_pairs() {
+                    if (opening_bracket_offset..closing_bracket_offset)
+                        .contains(&old_offset)
+                    {
+                        return Some((
+                            opening_bracket_offset,
+                            closing_bracket_offset,
+                        ));
+                    } else {
+                        self.inner.set(opening_bracket_offset);
+                    }
                 }
-            } else if !init_boundary.is_boundary() {
-                if classify_boundary(pb, pa).is_boundary() {
-                    break;
-                }
-            } else if classify_boundary(pb, pa).is_end() {
-                break;
             }
-            end = self.inner.pos();
-            prop_before = prop_after;
-            prop_after = self.inner.next_codepoint().map(get_word_property);
         }
-        self.inner.set(end);
-        (start, end)
+        None
     }
 }
 
-pub fn get_word_property(codepoint: char) -> WordProperty {
+/// Return the [`CharClassification`] of the input character
+pub fn get_char_property(codepoint: char) -> CharClassification {
     if codepoint <= ' ' {
         if codepoint == '\r' {
-            return WordProperty::Cr;
+            return CharClassification::Cr;
         }
         if codepoint == '\n' {
-            return WordProperty::Lf;
+            return CharClassification::Lf;
         }
-        return WordProperty::Space;
+        return CharClassification::Space;
     } else if codepoint <= '\u{3f}' {
         if (0xfc00fffe00000000u64 >> (codepoint as u32)) & 1 != 0 {
-            return WordProperty::Punctuation;
+            return CharClassification::Punctuation;
         }
     } else if codepoint <= '\u{7f}' {
         // Hardcoded: @[\]^`{|}~
         if (0x7800000178000001u64 >> ((codepoint as u32) & 0x3f)) & 1 != 0 {
-            return WordProperty::Punctuation;
+            return CharClassification::Punctuation;
         }
     }
-    WordProperty::Other
+    CharClassification::Other
 }
 
-fn classify_boundary_initial(
-    prev: WordProperty,
-    next: WordProperty,
+fn classify_boundary(
+    prev: CharClassification,
+    next: CharClassification,
 ) -> WordBoundary {
-    #[allow(clippy::match_single_binding)]
-    match (prev, next) {
-        // (Lf, Other) => Start,
-        // (Other, Lf) => End,
-        // (Lf, Space) => Interior,
-        // (Lf, Punctuation) => Interior,
-        // (Space, Lf) => Interior,
-        // (Punctuation, Lf) => Interior,
-        // (Space, Punctuation) => Interior,
-        // (Punctuation, Space) => Interior,
-        _ => classify_boundary(prev, next),
-    }
-}
-
-fn classify_boundary(prev: WordProperty, next: WordProperty) -> WordBoundary {
-    use self::WordBoundary::*;
-    use self::WordProperty::*;
+    use self::{CharClassification::*, WordBoundary::*};
     match (prev, next) {
         (Lf, Lf) => Start,
         (Lf, Space) => Interior,
@@ -319,4 +492,218 @@ fn classify_boundary(prev: WordProperty, next: WordProperty) -> WordBoundary {
 }
 
 #[cfg(test)]
-mod test;
+mod test {
+    use lapce_xi_rope::Rope;
+
+    use super::WordCursor;
+    use crate::mode::Mode;
+
+    #[test]
+    fn prev_boundary_should_be_none_at_position_zero() {
+        let rope = Rope::from("Hello world");
+        let mut cursor = WordCursor::new(&rope, 0);
+        let boudary = cursor.prev_boundary(Mode::Insert);
+        assert!(boudary.is_none())
+    }
+
+    #[test]
+    fn prev_boundary_should_be_zero_when_cursor_on_first_word() {
+        let rope = Rope::from("Hello world");
+        let mut cursor = WordCursor::new(&rope, 4);
+        let boundary = cursor.prev_boundary(Mode::Insert);
+        assert_eq!(boundary, Some(0));
+    }
+
+    #[test]
+    fn prev_boundary_should_be_at_word_start() {
+        let rope = Rope::from("Hello world");
+        let mut cursor = WordCursor::new(&rope, 9);
+        let boundary = cursor.prev_boundary(Mode::Insert);
+        assert_eq!(boundary, Some(6));
+    }
+
+    #[test]
+    fn on_whitespace_prev_boundary_should_be_at_line_start_for_non_modal() {
+        let rope = Rope::from("Hello\n    world");
+        let mut cursor = WordCursor::new(&rope, 10);
+        let boundary = cursor.prev_boundary(Mode::Insert);
+        assert_eq!(boundary, Some(6));
+    }
+
+    #[test]
+    fn on_whitespace_prev_boundary_should_cross_line_for_modal() {
+        let rope = Rope::from("Hello\n    world");
+        let mut cursor = WordCursor::new(&rope, 10);
+        let boundary = cursor.prev_boundary(Mode::Normal);
+        assert_eq!(boundary, Some(0));
+    }
+
+    #[test]
+    fn should_get_next_word_boundary() {
+        let rope = Rope::from("Hello world");
+        let mut cursor = WordCursor::new(&rope, 0);
+        let boundary = cursor.next_boundary();
+        assert_eq!(boundary, Some(6));
+    }
+
+    #[test]
+    fn next_word_boundary_should_be_none_at_last_position() {
+        let rope = Rope::from("Hello world");
+        let mut cursor = WordCursor::new(&rope, 11);
+        let boundary = cursor.next_boundary();
+        assert_eq!(boundary, None);
+    }
+
+    #[test]
+    fn should_get_previous_code_boundary() {
+        let text = "violet, are\n blue";
+        let rope = Rope::from(text);
+        let mut cursor = WordCursor::new(&rope, 11);
+        let position = cursor.prev_code_boundary();
+        assert_eq!(&text[position..], "are\n blue");
+    }
+
+    #[test]
+    fn should_get_next_code_boundary() {
+        let text = "violet, are\n blue";
+        let rope = Rope::from(text);
+        let mut cursor = WordCursor::new(&rope, 11);
+        let position = cursor.next_code_boundary();
+        assert_eq!(&text[position..], "\n blue");
+    }
+
+    #[test]
+    fn get_next_non_blank_char_should_skip_whitespace() {
+        let rope = Rope::from("Hello world");
+        let mut cursor = WordCursor::new(&rope, 5);
+        let char_position = cursor.next_non_blank_char();
+        assert_eq!(char_position, 6);
+    }
+
+    #[test]
+    fn get_next_non_blank_char_should_return_current_position_on_non_blank_char() {
+        let rope = Rope::from("Hello world");
+        let mut cursor = WordCursor::new(&rope, 3);
+        let char_position = cursor.next_non_blank_char();
+        assert_eq!(char_position, 3);
+    }
+
+    #[test]
+    fn should_get_end_boundary() {
+        let rope = Rope::from("Hello world");
+        let mut cursor = WordCursor::new(&rope, 3);
+        let end_boundary = cursor.end_boundary();
+        assert_eq!(end_boundary, Some(5));
+    }
+
+    #[test]
+    fn should_get_next_unmatched_char() {
+        let rope = Rope::from("hello { world");
+        let mut cursor = WordCursor::new(&rope, 0);
+        let position = cursor.next_unmatched('{');
+        assert_eq!(position, Some(7));
+    }
+
+    #[test]
+    fn should_get_next_unmatched_char_witch_matched_chars() {
+        let rope = Rope::from("hello {} world }");
+        let mut cursor = WordCursor::new(&rope, 0);
+        let position = cursor.next_unmatched('}');
+        assert_eq!(position, Some(16));
+    }
+
+    #[test]
+    fn should_get_previous_unmatched_char() {
+        let rope = Rope::from("hello { world");
+        let mut cursor = WordCursor::new(&rope, 12);
+        let position = cursor.previous_unmatched('{');
+        assert_eq!(position, Some(6));
+    }
+
+    #[test]
+    fn should_get_previous_unmatched_char_with_inner_matched_chars() {
+        let rope = Rope::from("{hello {} world");
+        let mut cursor = WordCursor::new(&rope, 10);
+        let position = cursor.previous_unmatched('{');
+        assert_eq!(position, Some(0));
+    }
+
+    #[test]
+    fn should_match_pair_forward() {
+        let text = "{ }";
+        let rope = Rope::from(text);
+        let mut cursor = WordCursor::new(&rope, 0);
+        let position = cursor.match_pairs();
+        assert_eq!(position, Some(2));
+    }
+
+    #[test]
+    fn should_match_pair_backward() {
+        let text = "{ }";
+        let rope = Rope::from(text);
+        let mut cursor = WordCursor::new(&rope, 2);
+        let position = cursor.match_pairs();
+        assert_eq!(position, Some(0));
+    }
+
+    #[test]
+    fn match_pair_should_be_none() {
+        let text = "{ }";
+        let rope = Rope::from(text);
+        let mut cursor = WordCursor::new(&rope, 1);
+        let position = cursor.match_pairs();
+        assert_eq!(position, None);
+    }
+
+    #[test]
+    fn select_word_should_return_word_boundaries() {
+        let text = "violet are blue";
+        let rope = Rope::from(text);
+        let mut cursor = WordCursor::new(&rope, 9);
+        let (start, end) = cursor.select_word();
+        assert_eq!(&text[start..end], "are");
+    }
+
+    #[test]
+    fn should_get_deletion_boundary_backward() {
+        let text = "violet are blue";
+        let rope = Rope::from(text);
+        let mut cursor = WordCursor::new(&rope, 9);
+        let position = cursor.prev_deletion_boundary();
+        let position = position;
+
+        assert_eq!(position, Some(7));
+        assert_eq!(&text[..position.unwrap()], "violet ");
+    }
+
+    #[test]
+    fn find_pair_should_return_positions() {
+        let text = "violet (are) blue";
+        let rope = Rope::from(text);
+        let mut cursor = WordCursor::new(&rope, 9);
+        let positions = cursor.find_enclosing_pair();
+        assert_eq!(positions, Some((7, 11)));
+    }
+
+    #[test]
+    fn find_pair_should_return_next_pair() {
+        let text = "violets {are (blue)    }";
+        let rope = Rope::from(text);
+        let mut cursor = WordCursor::new(&rope, 11);
+        let positions = cursor.find_enclosing_pair();
+        assert_eq!(positions, Some((8, 23)));
+
+        let mut cursor = WordCursor::new(&rope, 20);
+        let positions = cursor.find_enclosing_pair();
+        assert_eq!(positions, Some((8, 23)))
+    }
+
+    #[test]
+    fn find_pair_should_return_none() {
+        let text = "violet (are) blue";
+        let rope = Rope::from(text);
+        let mut cursor = WordCursor::new(&rope, 1);
+        let positions = cursor.find_enclosing_pair();
+        assert_eq!(positions, None);
+    }
+}
diff --git a/lapce-core/src/word/test.rs b/lapce-core/src/word/test.rs
deleted file mode 100644
index 2ef39665a7..0000000000
--- a/lapce-core/src/word/test.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use super::WordCursor;
-use crate::buffer::Buffer;
-
-#[test]
-fn test_next_boundary_by_newline() {
-    let buffer = Buffer::new("a\nb");
-    let mut cursor = WordCursor::new(buffer.text(), 0);
-    assert_eq!(cursor.next_boundary(), Some(2));
-    assert_eq!(cursor.next_boundary(), Some(buffer.len()));
-    assert_eq!(cursor.next_boundary(), None);
-}
-
-#[test]
-fn test_next_boundary_by_space() {
-    let buffer = Buffer::new("a b   ");
-    let mut cursor = WordCursor::new(buffer.text(), 0);
-    assert_eq!(cursor.next_boundary(), Some(2));
-    assert_eq!(cursor.next_boundary(), Some(buffer.len()));
-    assert_eq!(cursor.next_boundary(), None);
-}
-
-#[test]
-fn test_end_boundary_by_spaces() {
-    // NOTE: The word end boundary is 1 after the last character in the word.
-    // For example, in "abc-def", the end boundary of the word "abc" is at the
-    // position of '-'.
-    let buffer = Buffer::new("");
-    let mut cursor = WordCursor::new(buffer.text(), 0);
-    assert_eq!(cursor.end_boundary(), None);
-    let buffer = Buffer::new("a");
-    let mut cursor = WordCursor::new(buffer.text(), 0);
-    assert_eq!(cursor.end_boundary(), None);
-
-    let buffer = Buffer::new("bc");
-    let mut cursor = WordCursor::new(buffer.text(), 0);
-    assert_eq!(cursor.end_boundary(), Some(2));
-    assert_eq!(cursor.end_boundary(), None);
-
-    let buffer = Buffer::new("a bc  def   ");
-    //                      ->012345678901<-
-    let mut cursor = WordCursor::new(buffer.text(), 0);
-    assert_eq!(cursor.end_boundary(), Some(4));
-    assert_eq!(cursor.end_boundary(), Some(9));
-    // This end of word bounary is expected to go 1 beyond the buffer end.
-    assert_eq!(cursor.end_boundary(), Some(buffer.len()));
-    assert_eq!(cursor.end_boundary(), None);
-}
-
-#[test]
-fn test_end_boundary_by_newline() {
-    let buffer = Buffer::new("a\nbc\n\ndef\n\n\nghij\n\n\n");
-    //                      ->01 234 5 6789 0 1 23456 7 8 <-
-    let mut cursor = WordCursor::new(buffer.text(), 0);
-    assert_eq!(cursor.end_boundary(), Some(4));
-    assert_eq!(cursor.end_boundary(), Some(9));
-    assert_eq!(cursor.end_boundary(), Some(16));
-    assert_eq!(cursor.end_boundary(), Some(buffer.len()));
-    assert_eq!(cursor.end_boundary(), None);
-}
-
-// This test fails. See #501.
-#[should_panic]
-#[test]
-fn next_boundary_failure_to_be_fixed_1() {
-    let buffer = Buffer::new("a\nb\n\n\n");
-    let mut cursor = WordCursor::new(buffer.text(), 0);
-    assert_eq!(cursor.next_boundary(), Some(2));
-    // This assertion fails.
-    assert_eq!(cursor.next_boundary(), Some(buffer.len()));
-    assert_eq!(cursor.next_boundary(), None);
-}
-
-#[should_panic]
-#[test]
-fn next_boundary_failure_to_be_fixed_2() {
-    let buffer = Buffer::new("a\nb\n\n\n");
-    let mut cursor = WordCursor::new(buffer.text(), 0);
-    assert_eq!(cursor.next_boundary(), Some(2));
-    // This assertion also fails:
-    assert_eq!(cursor.next_boundary(), Some(3));
-    // assert_eq!(cursor.next_boundary(), Some(4));
-    // assert_eq!(cursor.next_boundary(), Some(5));
-    // assert_eq!(cursor.next_boundary(), Some(6));
-    // assert_eq!(cursor.next_boundary(), None);
-}
diff --git a/lapce-data/Cargo.toml b/lapce-data/Cargo.toml
index 5909e1f8e6..00f2c739ce 100644
--- a/lapce-data/Cargo.toml
+++ b/lapce-data/Cargo.toml
@@ -1,59 +1,67 @@
 [package]
 name = "lapce-data"
-version = "0.1.2"
-authors = ["Dongdong Zhou <dzhou121@gmail.com>"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
 
 [dependencies]
-bitflags = "1"
-chrono = "0.4.19"
-log = "0.4.14"
-fern = "0.6.0"
-Inflector = "0.11.4"
-rayon = "1.5.1"
-diff = "0.1.12"
-libloading = "0.7"
-flate2 = "1.0.22"
-reqwest = { version = "0.11", features = ["blocking", "json", "socks"] }
-hashbrown = "0.11.2"
+alacritty_terminal.workspace = true
+anyhow.workspace = true
+chrono.workspace = true
+clap.workspace = true
+crossbeam-channel.workspace = true
+directories.workspace = true
+flate2.workspace = true
+hashbrown.workspace = true
+im.workspace = true
+include_dir.workspace = true
+indexmap.workspace = true
+interprocess.workspace = true
+itertools.workspace = true
+log.workspace = true
+notify.workspace = true
+once_cell.workspace = true
+parking_lot.workspace = true
+rayon.workspace = true
+regex.workspace = true
+reqwest.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+smallvec.workspace = true
+strum.workspace = true
+strum_macros.workspace = true
+tar.workspace = true
+thiserror.workspace = true
+toml_edit.workspace = true
+
+lsp-types.workspace = true
+
+lapce-xi-rope.workspace = true
+
+lapce-core.workspace = true
+lapce-rpc.workspace = true
+lapce-proxy.workspace = true
+
+druid.workspace = true
+
+sha2 = "0.10.6"
+fs_extra = "1.2.0"
 sled = "0.34.7"
-base64 = "0.13.0"
-alacritty_terminal = "0.16"
-config = "0.11"
-indexmap = "1.7.0"
-directories = "4.0.1"
-itertools = "0.10.1"
-unicode-width = "0.1.8"
-unicode-segmentation = "1.7.1"
-im = { version = "15.0.0", features = ["serde"] }
-crossbeam-channel = "0.5.0"
-crossbeam-utils = "0.8.4"
-regex = "1.5.6"
-jsonrpc-lite = "0.5.0"
-bit-vec = "0.5.0"
-parking_lot = { version = "0.11.0", features = ["deadlock_detection"] }
-include_dir = "0.6.0"
-thiserror = "1.0"
-anyhow = "1.0.32"
-strum = "0.24.0"
-strum_macros = "0.24"
-lazy_static = "1.4.0"
-serde = "1.0"
-serde_json = "1.0"
-notify = { version = "5.0.0-pre.13", features = ["serde"] }
-xi-rope = { git = "https://github.com/lapce/xi-editor", features = ["serde"] }
-xi-unicode = "0.3.0"
+config = { version = "0.13.2", default-features = false, features = ["toml"] }
 fuzzy-matcher = "0.3.7"
-uuid = { version = "0.8.2", features = ["v4"] }
-lsp-types = { version = "0.89.2", features = ["proposed"] }
-druid = { git = "https://github.com/lapce/druid", branch = "shell_opengl", features = [ "svg", "im", "serde", ] }
-# druid = { path = "../../druid/druid", features = ["svg", "im" , "serde"] }
-toml = { version = "0.5.8", features = ["preserve_order"] }
+uuid = { version = "1.2.2", features = ["v4"] }
 structdesc = { git = "https://github.com/lapce/structdesc" }
-#structdesc = { path = "../../structdesc" }
-lapce-core = { path = "../lapce-core" }
-lapce-rpc = { path = "../lapce-rpc" }
-lapce-proxy = { path = "../lapce-proxy" }
 bytemuck = "1.8.0"
 # For parsing markdown data, such as in hovers
 pulldown-cmark = "0.9.1"
+url = "2.3.1"
+
+[target.'cfg(target_os="macos")'.dependencies]
+dmg = "0.1.1"
+
+[target.'cfg(target_os="windows")'.dependencies]
+zip = { version = "0.6.3", default-features = false, features = ["deflate"] }
+
+[features]
+updater = []
+portable = []
diff --git a/lapce-data/src/about.rs b/lapce-data/src/about.rs
new file mode 100644
index 0000000000..510055fca9
--- /dev/null
+++ b/lapce-data/src/about.rs
@@ -0,0 +1,82 @@
+use std::sync::Arc;
+
+use druid::{Command, Env, EventCtx, Modifiers, Target, WidgetId};
+use lapce_core::{command::FocusCommand, mode::Mode};
+
+use crate::{
+    command::{CommandExecuted, CommandKind, LapceCommand, LAPCE_COMMAND},
+    data::LapceTabData,
+    keypress::KeyPressFocus,
+};
+
+#[derive(Clone)]
+pub struct AboutData {
+    pub widget_id: WidgetId,
+    pub active: bool,
+}
+
+pub struct AboutFocusData {
+    about: Arc<AboutData>,
+}
+
+impl Default for AboutData {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AboutData {
+    pub fn new() -> Self {
+        Self {
+            widget_id: WidgetId::next(),
+            active: false,
+        }
+    }
+}
+
+impl KeyPressFocus for AboutFocusData {
+    fn get_mode(&self) -> Mode {
+        Mode::Insert
+    }
+
+    fn focus_only(&self) -> bool {
+        true
+    }
+
+    fn check_condition(&self, condition: &str) -> bool {
+        matches!(condition, "modal_focus")
+    }
+
+    fn run_command(
+        &mut self,
+        ctx: &mut EventCtx,
+        command: &LapceCommand,
+        _count: Option<usize>,
+        _mods: Modifiers,
+        _env: &Env,
+    ) -> CommandExecuted {
+        if let CommandKind::Focus(FocusCommand::ModalClose) = command.kind {
+            ctx.submit_command(Command::new(
+                LAPCE_COMMAND,
+                LapceCommand {
+                    kind: CommandKind::Focus(FocusCommand::ModalClose),
+                    data: None,
+                },
+                Target::Widget(self.about.widget_id),
+            ));
+            CommandExecuted::Yes
+        } else {
+            CommandExecuted::No
+        }
+    }
+
+    fn receive_char(&mut self, _ctx: &mut EventCtx, _c: &str) {}
+}
+
+impl AboutFocusData {
+    pub fn new(data: &LapceTabData) -> Self {
+        Self {
+            about: data.about.clone(),
+        }
+    }
+}
diff --git a/lapce-data/src/atomic_soft_tabs.rs b/lapce-data/src/atomic_soft_tabs.rs
new file mode 100644
index 0000000000..0697902484
--- /dev/null
+++ b/lapce-data/src/atomic_soft_tabs.rs
@@ -0,0 +1,255 @@
+use lapce_core::buffer::Buffer;
+
+/// The direction to snap. Left is used when moving left, Right when moving right.
+/// Nearest is used for mouse selection.
+pub enum SnapDirection {
+    Left,
+    Right,
+    Nearest,
+}
+
+/// If the cursor is inside a soft tab at the start of the line, snap it to the
+/// nearest, left or right edge. This version takes an offset and returns an offset.
+pub fn snap_to_soft_tab(
+    buffer: &Buffer,
+    offset: usize,
+    direction: SnapDirection,
+    tab_width: usize,
+) -> usize {
+    // Fine which line we're on.
+    let line = buffer.line_of_offset(offset);
+    // Get the offset to the start of the line.
+    let start_line_offset = buffer.offset_of_line(line);
+    // And the offset within the lint.
+    let offset_within_line = offset - start_line_offset;
+
+    start_line_offset
+        + snap_to_soft_tab_logic(
+            buffer,
+            offset_within_line,
+            start_line_offset,
+            direction,
+            tab_width,
+        )
+}
+
+/// If the cursor is inside a soft tab at the start of the line, snap it to the
+/// nearest, left or right edge. This version takes a line/column and returns a column.
+pub fn snap_to_soft_tab_line_col(
+    buffer: &Buffer,
+    line: usize,
+    col: usize,
+    direction: SnapDirection,
+    tab_width: usize,
+) -> usize {
+    // Get the offset to the start of the line.
+    let start_line_offset = buffer.offset_of_line(line);
+
+    snap_to_soft_tab_logic(buffer, col, start_line_offset, direction, tab_width)
+}
+
+/// Internal shared logic that performs the actual snapping. It can be passed
+/// either an column or offset within the line since it is only modified when it makes no
+/// difference which is used (since they're equal for spaces).
+/// It returns the column or offset within the line (depending on what you passed in).
+fn snap_to_soft_tab_logic(
+    buffer: &Buffer,
+    offset_or_col: usize,
+    start_line_offset: usize,
+    direction: SnapDirection,
+    tab_width: usize,
+) -> usize {
+    assert!(tab_width >= 1);
+
+    // Number of spaces, ignoring incomplete soft tabs.
+    let space_count =
+        (count_spaces_from(buffer, start_line_offset) / tab_width) * tab_width;
+
+    // If we're past the soft tabs, we don't need to snap.
+    if offset_or_col >= space_count {
+        return offset_or_col;
+    }
+
+    let bias = match direction {
+        SnapDirection::Left => 0,
+        SnapDirection::Right => tab_width - 1,
+        SnapDirection::Nearest => tab_width / 2,
+    };
+
+    ((offset_or_col + bias) / tab_width) * tab_width
+}
+
+/// Count the number of spaces found after a certain offset.
+fn count_spaces_from(buffer: &Buffer, from_offset: usize) -> usize {
+    let mut cursor = lapce_xi_rope::Cursor::new(buffer.text(), from_offset);
+    let mut space_count = 0usize;
+    while let Some(next) = cursor.next_codepoint() {
+        if next != ' ' {
+            break;
+        }
+        space_count += 1;
+    }
+    space_count
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_count_spaces_from() {
+        let buffer = Buffer::new("     abc\n   def\nghi\n");
+        assert_eq!(count_spaces_from(&buffer, 0), 5);
+        assert_eq!(count_spaces_from(&buffer, 1), 4);
+        assert_eq!(count_spaces_from(&buffer, 5), 0);
+        assert_eq!(count_spaces_from(&buffer, 6), 0);
+
+        assert_eq!(count_spaces_from(&buffer, 8), 0);
+        assert_eq!(count_spaces_from(&buffer, 9), 3);
+        assert_eq!(count_spaces_from(&buffer, 10), 2);
+
+        assert_eq!(count_spaces_from(&buffer, 16), 0);
+        assert_eq!(count_spaces_from(&buffer, 17), 0);
+    }
+
+    #[test]
+    fn test_snap_to_soft_tab() {
+        let buffer =
+            Buffer::new("          abc\n      def\n    ghi\nklm\n        opq");
+
+        let tab_width = 4;
+
+        // Input offset, and output offset for Left, Nearest and Right respectively.
+        let test_cases = [
+            (0, 0, 0, 0),
+            (1, 0, 0, 4),
+            (2, 0, 4, 4),
+            (3, 0, 4, 4),
+            (4, 4, 4, 4),
+            (5, 4, 4, 8),
+            (6, 4, 8, 8),
+            (7, 4, 8, 8),
+            (8, 8, 8, 8),
+            (9, 9, 9, 9),
+            (10, 10, 10, 10),
+            (11, 11, 11, 11),
+            (12, 12, 12, 12),
+            (13, 13, 13, 13),
+            (14, 14, 14, 14),
+            (15, 14, 14, 18),
+            (16, 14, 18, 18),
+            (17, 14, 18, 18),
+            (18, 18, 18, 18),
+            (19, 19, 19, 19),
+            (20, 20, 20, 20),
+            (21, 21, 21, 21),
+        ];
+
+        for test_case in test_cases {
+            assert_eq!(
+                snap_to_soft_tab(
+                    &buffer,
+                    test_case.0,
+                    SnapDirection::Left,
+                    tab_width
+                ),
+                test_case.1
+            );
+            assert_eq!(
+                snap_to_soft_tab(
+                    &buffer,
+                    test_case.0,
+                    SnapDirection::Nearest,
+                    tab_width
+                ),
+                test_case.2
+            );
+            assert_eq!(
+                snap_to_soft_tab(
+                    &buffer,
+                    test_case.0,
+                    SnapDirection::Right,
+                    tab_width
+                ),
+                test_case.3
+            );
+        }
+    }
+
+    #[test]
+    fn test_snap_to_soft_tab_line_col() {
+        let buffer =
+            Buffer::new("          abc\n      def\n    ghi\nklm\n        opq");
+
+        let tab_width = 4;
+
+        // Input line, column, and output column for Left, Nearest and Right respectively.
+        let test_cases = [
+            (0, 0, 0, 0, 0),
+            (0, 1, 0, 0, 4),
+            (0, 2, 0, 4, 4),
+            (0, 3, 0, 4, 4),
+            (0, 4, 4, 4, 4),
+            (0, 5, 4, 4, 8),
+            (0, 6, 4, 8, 8),
+            (0, 7, 4, 8, 8),
+            (0, 8, 8, 8, 8),
+            (0, 9, 9, 9, 9),
+            (0, 10, 10, 10, 10),
+            (0, 11, 11, 11, 11),
+            (0, 12, 12, 12, 12),
+            (0, 13, 13, 13, 13),
+            (1, 0, 0, 0, 0),
+            (1, 1, 0, 0, 4),
+            (1, 2, 0, 4, 4),
+            (1, 3, 0, 4, 4),
+            (1, 4, 4, 4, 4),
+            (1, 5, 5, 5, 5),
+            (1, 6, 6, 6, 6),
+            (1, 7, 7, 7, 7),
+            (4, 0, 0, 0, 0),
+            (4, 1, 0, 0, 4),
+            (4, 2, 0, 4, 4),
+            (4, 3, 0, 4, 4),
+            (4, 4, 4, 4, 4),
+            (4, 5, 4, 4, 8),
+            (4, 6, 4, 8, 8),
+            (4, 7, 4, 8, 8),
+            (4, 8, 8, 8, 8),
+            (4, 9, 9, 9, 9),
+        ];
+
+        for test_case in test_cases {
+            assert_eq!(
+                snap_to_soft_tab_line_col(
+                    &buffer,
+                    test_case.0,
+                    test_case.1,
+                    SnapDirection::Left,
+                    tab_width
+                ),
+                test_case.2
+            );
+            assert_eq!(
+                snap_to_soft_tab_line_col(
+                    &buffer,
+                    test_case.0,
+                    test_case.1,
+                    SnapDirection::Nearest,
+                    tab_width
+                ),
+                test_case.3
+            );
+            assert_eq!(
+                snap_to_soft_tab_line_col(
+                    &buffer,
+                    test_case.0,
+                    test_case.1,
+                    SnapDirection::Right,
+                    tab_width
+                ),
+                test_case.4
+            );
+        }
+    }
+}
diff --git a/lapce-data/src/command.rs b/lapce-data/src/command.rs
index 13550f6094..d8f2ba1c30 100644
--- a/lapce-data/src/command.rs
+++ b/lapce-data/src/command.rs
@@ -1,39 +1,57 @@
 use std::{collections::HashMap, path::PathBuf, sync::Arc};
 
 use anyhow::Result;
-use druid::{FileInfo, Point, Rect, Selector, SingleUse, Size, WidgetId, WindowId};
+use druid::{
+    EventCtx, FileInfo, Point, Rect, Selector, SingleUse, WidgetId, WindowId,
+};
 use indexmap::IndexMap;
-use lapce_core::buffer::DiffLines;
-use lapce_core::command::{
-    EditCommand, FocusCommand, MotionModeCommand, MoveCommand, MultiSelectionCommand,
+use lapce_core::{
+    buffer::DiffLines,
+    command::{
+        EditCommand, FocusCommand, MotionModeCommand, MoveCommand,
+        MultiSelectionCommand,
+    },
+    syntax::Syntax,
 };
-use lapce_core::syntax::Syntax;
 use lapce_rpc::{
-    buffer::BufferId, file::FileNodeItem, plugin::PluginDescription,
-    source_control::DiffInfo, style::Style, terminal::TermId,
+    buffer::BufferId,
+    file::FileNodeItem,
+    plugin::{PluginId, VoltID, VoltInfo, VoltMetadata},
+    source_control::DiffInfo,
+    style::Style,
+    terminal::TermId,
 };
+use lapce_xi_rope::{spans::Spans, Rope};
 use lsp_types::{
     CodeActionOrCommand, CodeActionResponse, CompletionItem, CompletionResponse,
-    Location, Position, ProgressParams, PublishDiagnosticsParams, TextEdit,
+    InlayHint, Location, MessageType, Position, ProgressParams,
+    PublishDiagnosticsParams, SelectionRange, SignatureHelp, TextEdit, Url,
+    WorkspaceEdit,
 };
 use serde_json::Value;
 use strum::{self, EnumMessage, IntoEnumIterator};
 use strum_macros::{Display, EnumIter, EnumMessage, EnumString, IntoStaticStr};
-use xi_rope::{spans::Spans, Rope};
 
-use crate::alert::AlertContentData;
-use crate::data::LapceWorkspace;
-use crate::document::BufferContent;
-use crate::menu::MenuKind;
-use crate::rich_text::RichText;
 use crate::{
-    data::{EditorTabChild, SplitContent},
-    editor::EditorLocation,
+    alert::AlertContentData,
+    data::{
+        EditorTabChild, LapceMainSplitData, LapceTabData, LapceWorkspace,
+        SplitContent,
+    },
+    document::BufferContent,
+    editor::{EditorLocation, EditorPosition, Line, LineCol},
+    images,
     keypress::{KeyMap, KeyPress},
+    markdown::Content,
+    menu::MenuKind,
     palette::{PaletteItem, PaletteType},
+    plugin::{PluginsInfo, VoltIconKind},
     proxy::ProxyStatus,
     search::Match,
+    selection_range::SelectionRangeDirection,
+    settings::LapceSettingsKind,
     split::{SplitDirection, SplitMoveDirection},
+    update::ReleaseInfo,
 };
 
 pub const LAPCE_OPEN_FOLDER: Selector<FileInfo> = Selector::new("lapce.open-folder");
@@ -44,13 +62,13 @@ pub const LAPCE_COMMAND: Selector<LapceCommand> = Selector::new("lapce.new-comma
 pub const LAPCE_UI_COMMAND: Selector<LapceUICommand> =
     Selector::new("lapce.ui_command");
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct LapceCommand {
     pub kind: CommandKind,
     pub data: Option<Value>,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum CommandKind {
     Workbench(LapceWorkbenchCommand),
     Edit(EditCommand),
@@ -94,10 +112,13 @@ impl LapceCommand {
                 | LapceWorkbenchCommand::PaletteLine
                 | LapceWorkbenchCommand::PaletteSymbol
                 | LapceWorkbenchCommand::PaletteCommand
-                | LapceWorkbenchCommand::ChangeTheme
+                | LapceWorkbenchCommand::ChangeFileLanguage
+                | LapceWorkbenchCommand::ChangeColorTheme
+                | LapceWorkbenchCommand::ChangeIconTheme
                 | LapceWorkbenchCommand::ConnectSshHost
-                | LapceWorkbenchCommand::ConnectWsl
                 | LapceWorkbenchCommand::PaletteWorkspace => return true,
+                #[cfg(windows)]
+                LapceWorkbenchCommand::ConnectWsl => return true,
                 _ => {}
             }
         }
@@ -106,7 +127,7 @@ impl LapceCommand {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Eq)]
 pub enum CommandExecuted {
     Yes,
     No,
@@ -172,6 +193,7 @@ pub fn lapce_internal_commands() -> IndexMap<String, LapceCommand> {
     EnumIter,
     Clone,
     PartialEq,
+    Eq,
     Debug,
     EnumMessage,
     IntoStaticStr,
@@ -197,9 +219,17 @@ pub enum LapceWorkbenchCommand {
     #[strum(message = "fileを開く")]
     OpenFile,
 
-    #[strum(serialize = "change_theme")]
-    #[strum(message = "themeの変更")]
-    ChangeTheme,
+    #[strum(serialize = "reveal_active_file_in_file_explorer")]
+    #[strum(message = "File ExplorerでActiveなFileを表示する")]
+    RevealActiveFileInFileExplorer,
+
+    #[strum(serialize = "change_color_theme")]
+    #[strum(message = "Color Themeの変更")]
+    ChangeColorTheme,
+
+    #[strum(serialize = "change_icon_theme")]
+    #[strum(message = "Icon Themeの変更")]
+    ChangeIconTheme,
 
     #[strum(serialize = "open_settings")]
     #[strum(message = "設定を開く")]
@@ -209,6 +239,10 @@ pub enum LapceWorkbenchCommand {
     #[strum(message = "設定fileを開く")]
     OpenSettingsFile,
 
+    #[strum(serialize = "open_settings_directory")]
+    #[strum(message = "Open Settings Directory")]
+    OpenSettingsDirectory,
+
     #[strum(serialize = "open_keyboard_shortcuts")]
     #[strum(message = "keyboad shortcutを開く")]
     OpenKeyboardShortcuts,
@@ -221,6 +255,22 @@ pub enum LapceWorkbenchCommand {
     #[strum(message = "log fileを開く")]
     OpenLogFile,
 
+    #[strum(serialize = "open_logs_directory")]
+    #[strum(message = "Open Logs Directory")]
+    OpenLogsDirectory,
+
+    #[strum(serialize = "open_proxy_directory")]
+    #[strum(message = "Open Proxy Directory")]
+    OpenProxyDirectory,
+
+    #[strum(serialize = "open_themes_directory")]
+    #[strum(message = "Open Themes Directory")]
+    OpenThemesDirectory,
+
+    #[strum(serialize = "open_plugins_directory")]
+    #[strum(message = "Open Plugins Directory")]
+    OpenPluginsDirectory,
+
     #[strum(serialize = "close_window_tab")]
     #[strum(message = "現在のWindow Tabを閉じる")]
     CloseWindowTab,
@@ -229,6 +279,22 @@ pub enum LapceWorkbenchCommand {
     #[strum(message = "新しいWindow Tabを作成する")]
     NewWindowTab,
 
+    #[strum(serialize = "new_terminal_tab")]
+    #[strum(message = "Create New Terminal Tab")]
+    NewTerminalTab,
+
+    #[strum(serialize = "close_terminal_tab")]
+    #[strum(message = "Close Terminal Tab")]
+    CloseTerminalTab,
+
+    #[strum(serialize = "next_terminal_tab")]
+    #[strum(message = "Next Terminal Tab")]
+    NextTerminalTab,
+
+    #[strum(serialize = "previous_terminal_tab")]
+    #[strum(message = "Previous Terminal Tab")]
+    PreviousTerminalTab,
+
     #[strum(serialize = "next_window_tab")]
     #[strum(message = "次のWindow Tabへ")]
     NextWindowTab,
@@ -245,6 +311,10 @@ pub enum LapceWorkbenchCommand {
     #[strum(serialize = "new_window")]
     NewWindow,
 
+    #[strum(message = "Windowを閉じる")]
+    #[strum(serialize = "close_window")]
+    CloseWindow,
+
     #[strum(message = "新規file")]
     #[strum(serialize = "new_file")]
     NewFile,
@@ -253,6 +323,7 @@ pub enum LapceWorkbenchCommand {
     #[strum(message = "SSH hostに接続")]
     ConnectSshHost,
 
+    #[cfg(windows)]
     #[strum(serialize = "connect_wsl")]
     #[strum(message = "WSLに接続")]
     ConnectWsl,
@@ -271,7 +342,10 @@ pub enum LapceWorkbenchCommand {
     #[strum(serialize = "palette.symbol")]
     PaletteSymbol,
 
-    #[strum(message = "command palette")]
+    #[strum(serialize = "palette.workspace_symbol")]
+    PaletteWorkspaceSymbol,
+
+    #[strum(message = "Command Palette")]
     #[strum(serialize = "palette.command")]
     PaletteCommand,
 
@@ -299,6 +373,15 @@ pub enum LapceWorkbenchCommand {
     #[strum(serialize = "toggle_panel_visual")]
     TogglePanelVisual,
 
+    #[strum(serialize = "toggle_panel_left_visual")]
+    TogglePanelLeftVisual,
+
+    #[strum(serialize = "toggle_panel_right_visual")]
+    TogglePanelRightVisual,
+
+    #[strum(serialize = "toggle_panel_bottom_visual")]
+    TogglePanelBottomVisual,
+
     // Focus toggle commands
     #[strum(message = "Toggle Terminal Focus")]
     #[strum(serialize = "toggle_terminal_focus")]
@@ -348,9 +431,28 @@ pub enum LapceWorkbenchCommand {
     #[strum(serialize = "focus_terminal")]
     FocusTerminal,
 
+    #[strum(message = "Source Control: Init")]
+    #[strum(serialize = "source_control_init")]
+    SourceControlInit,
+
     #[strum(serialize = "source_control_commit")]
     SourceControlCommit,
 
+    #[strum(message = "Source Control: Copy Remote File Url")]
+    #[strum(serialize = "source_control_copy_active_file_remote_url")]
+    SourceControlCopyActiveFileRemoteUrl,
+
+    #[strum(message = "Source Control: Discard File Changes")]
+    #[strum(serialize = "source_control_discard_active_file_changes")]
+    SourceControlDiscardActiveFileChanges,
+
+    #[strum(serialize = "source_control_discard_target_file_changes")]
+    SourceControlDiscardTargetFileChanges,
+
+    #[strum(message = "Source Control: Discard Workspace Changes")]
+    #[strum(serialize = "source_control_discard_workspace_changes")]
+    SourceControlDiscardWorkspaceChanges,
+
     #[strum(serialize = "export_current_theme_settings")]
     #[strum(message = "current settingsをtheme fileにexport")]
     ExportCurrentThemeSettings,
@@ -358,6 +460,47 @@ pub enum LapceWorkbenchCommand {
     #[strum(serialize = "install_theme")]
     #[strum(message = "current theme fileをinstall")]
     InstallTheme,
+
+    #[strum(serialize = "change_file_language")]
+    #[strum(message = "Change current file language")]
+    ChangeFileLanguage,
+
+    #[strum(serialize = "next_editor_tab")]
+    #[strum(message = "Next editor tab")]
+    NextEditorTab,
+
+    #[strum(serialize = "previous_editor_tab")]
+    #[strum(message = "Previous editor tab")]
+    PreviousEditorTab,
+
+    #[strum(serialize = "toggle_inlay_hints")]
+    #[strum(message = "Toggle Inlay Hints")]
+    ToggleInlayHints,
+
+    #[strum(serialize = "restart_to_update")]
+    RestartToUpdate,
+
+    #[strum(serialize = "show_about")]
+    #[strum(message = "About Lapce")]
+    ShowAbout,
+
+    #[strum(message = "Save All Files")]
+    #[strum(serialize = "save_all")]
+    SaveAll,
+
+    #[cfg(target_os = "macos")]
+    #[strum(message = "Install Lapce to PATH")]
+    #[strum(serialize = "install_to_path")]
+    InstallToPATH,
+
+    #[cfg(target_os = "macos")]
+    #[strum(message = "Uninstall Lapce from PATH")]
+    #[strum(serialize = "uninstall_from_path")]
+    UninstallFromPATH,
+
+    #[strum(serialize = "quit")]
+    #[strum(message = "Quit Editor")]
+    Quit,
 }
 
 #[derive(Debug)]
@@ -374,14 +517,22 @@ pub enum EnsureVisiblePosition {
 }
 
 pub enum LapceUICommand {
-    InitChildren,
-    InitTerminalPanel(bool),
+    /// Reload the config file
     ReloadConfig,
-    InitBufferContent {
-        path: PathBuf,
-        content: Rope,
-        locations: Vec<(WidgetId, EditorLocation)>,
-    },
+    /// Initializes the buffer content at a particular position.  
+    /// (UTF8 offsets into the file)
+    InitBufferContent(InitBufferContent<usize>),
+    /// Initializes the buffer content at a particular position.  
+    /// (Start of line position)
+    InitBufferContentLine(InitBufferContent<Line>),
+    /// Initializes the buffer content at a particular position.  
+    /// (Line and UTF8 Column Positions)
+    InitBufferContentLineCol(InitBufferContent<LineCol>),
+    /// Initializes the buffer content at a particular position.  
+    /// (UTF16 LSP positions)
+    InitBufferContentLsp(InitBufferContent<Position>),
+    /// Informs the editor that the file has been changed, giving the new content.  
+    /// (Sent by the proxy on certain watcher events)
     OpenFileChanged {
         path: PathBuf,
         content: Rope,
@@ -391,83 +542,297 @@ pub enum LapceUICommand {
         rev: u64,
         content: Rope,
     },
+    /// Informs the editor of the `head` version of the buffer.  
+    /// (Sent by the proxy when history is requested for a document)
     LoadBufferHead {
         path: PathBuf,
         version: String,
         content: Rope,
     },
-    LoadBufferAndGoToPosition {
-        path: PathBuf,
-        content: String,
-        editor_view_id: WidgetId,
-        location: EditorLocation,
-    },
+    /// Display the about modal
+    ShowAbout,
+    /// Display the alert modal (ex: the "Are you sure you want to close without saving?")
     ShowAlert(AlertContentData),
+    /// Display the context menu at a specific point
     ShowMenu(Point, Arc<Vec<MenuKind>>),
+    /// Bring the window to the front
+    ShowWindow,
+    /// Display the git branch picker at the specified point
+    ShowGitBranches {
+        origin: Point,
+        branches: im::Vector<String>,
+    },
+    /// Update global search input with the given pattern
     UpdateSearchInput(String),
-    UpdateSearch(String),
-    GlobalSearchResult(String, Arc<HashMap<PathBuf, Vec<Match>>>),
+    /// Update the global search with the given pattern (actually performs the search)
+    UpdateSearch(
+        String,
+        // If present, will update the case-sensitivity
+        Option<bool>,
+    ),
+    /// Informs the editor of the results from the global search, this is caused by the
+    /// `UpdateSearch{,WithCaseSensitivity}` commands
+    GlobalSearchResult(String, Arc<IndexMap<PathBuf, Vec<Match>>>),
     CancelFilePicker,
+    /// Change the workspace to the given path/remote (or clear it)
     SetWorkspace(LapceWorkspace),
-    SetTheme(String, bool),
+    SetColorTheme {
+        theme: String,
+        /// Whether the changes are temporary, and thus whether we should update the config file
+        preview: bool,
+    },
+    SetIconTheme {
+        theme: String,
+        /// Whether the changes are temporary, and thus whether we should update the config file
+        preview: bool,
+    },
     UpdateKeymap(KeyMap, Vec<KeyPress>),
-    OpenFile(PathBuf),
-    OpenFileDiff(PathBuf, String),
-    CancelCompletion(usize),
-    ResolveCompletion(BufferId, u64, usize, Box<CompletionItem>),
-    UpdateCompletion(usize, String, CompletionResponse),
-    UpdateHover(usize, Arc<Vec<RichText>>),
-    UpdateCodeActions(PathBuf, u64, usize, CodeActionResponse),
-    CancelPalette,
-    RunCodeAction(CodeActionOrCommand),
+    /// Open the URI in the respective program, such as urls for the browser, or paths in the file
+    /// explorer
+    OpenURI(String),
+    /// Open multiple folders/files in the editor, potentially as new window tabs
+    OpenPaths {
+        window_tab_id: Option<(WindowId, WidgetId)>,
+        folders: Vec<PathBuf>,
+        files: Vec<PathBuf>,
+    },
+    /// Open a specific file in the editor; along with `same_tab` which decides which tabs to look
+    /// at for whether the file is already open.
+    OpenFile(PathBuf, bool),
+    /// Open a specific file in the editor as a source control diff view
+    OpenFileDiff {
+        path: PathBuf,
+        /// Ex: "head"
+        history: String,
+    },
+    /// Shows a specific file in the user's file explorer
+    RevealInFileExplorer(PathBuf),
+    /// Cancel the completion request
+    CancelCompletion {
+        request_id: usize,
+    },
+    /// Receieved when the request for completion items has completed
+    UpdateCompletion {
+        request_id: usize,
+        input: String,
+        resp: CompletionResponse,
+        plugin_id: PluginId,
+    },
+    /// Received when the completion item has been selected and we've resolved it to the actual
+    /// actions needed to expand it.
+    ResolveCompletion {
+        id: BufferId,
+        rev: u64,
+        offset: usize,
+        item: Box<CompletionItem>,
+    },
+    /// Completion 'internal' event that indicates that it should recompute the layouts for
+    /// the completion documentation.
+    RefreshCompletionDocumentation,
+    /// Received when the request for signature information has completed
+    UpdateSignature {
+        request_id: usize,
+        resp: SignatureHelp,
+        plugin_id: PluginId,
+    },
+    /// Signature 'internal' event that indicates that it should recompute the layouts for
+    /// the signature view.
+    RefreshSignature,
+    /// Received when the request for hover information has completed
+    UpdateHover {
+        request_id: usize,
+        items: Arc<Vec<Content>>,
+    },
+    /// Received when the request for the plugin's description completed
+    UpdateVoltReadme(Arc<Vec<Content>>),
+    UpdateInlayHints {
+        path: PathBuf,
+        rev: u64,
+        hints: Spans<InlayHint>,
+    },
+    /// Received when the request for code actions in the file completed
+    UpdateCodeActions {
+        path: PathBuf,
+        plugin_id: PluginId,
+        rev: u64,
+        offset: usize,
+        resp: CodeActionResponse,
+    },
+    /// Received when there was an error in getting code actions
+    CodeActionsError {
+        path: PathBuf,
+        rev: u64,
+        offset: usize,
+    },
+    /// Run a system command with the given args
+    RunCommand(String, Vec<String>),
+    /// Execute a code action from a specific plugin
+    RunCodeAction(CodeActionOrCommand, PluginId),
+    /// Apply a workspace edit, which comes from an LSP
+    ApplyWorkspaceEdit(WorkspaceEdit),
+    /// Display a list of the current code actions at the given point
     ShowCodeActions(Option<Point>),
+    /// Sets the information about the latest Lapce release
+    UpdateLatestRelease(ReleaseInfo),
+    /// Hide the widget which receives this (requires that it handles this)
     Hide,
-    ResignFocus,
+    /// Focus the widget which receives this
     Focus,
+    /// Inform the widget that they lost focus (not often used)
+    FocusLost,
+    /// Inform that the widget that their children have changed, typically so that they can call
+    /// `ctx.children_changed()` on the next `event`
+    ChildrenChanged,
+    /// Changes the active file in the explorer panel to the current file
     EnsureEditorTabActiveVisible,
-    FocusSourceControl,
+    /// Displays the (core) settings in the settings view
     ShowSettings,
+    /// Displays the keybindings in the settings view
     ShowKeybindings,
-    FocusEditor,
+    /// Displays the given settings in the settings view
+    ShowSettingsKind(LapceSettingsKind),
+    /// Display the palette, initialized to a specific type
     RunPalette(Option<PaletteType>),
-    RunPaletteReferences(Vec<EditorLocation>),
+    /// Receives the positions of the requested references
+    RunPaletteReferences(Vec<EditorLocation<Position>>),
+    /// Sets the palette's input to the given string. This changes it without updating.
     InitPaletteInput(String),
+    /// Sets the palette's input to the given string. This updates the contents of the palette
+    /// based on the input.
     UpdatePaletteInput(String),
-    UpdatePaletteItems(String, Vec<PaletteItem>),
-    FilterPaletteItems(String, String, Vec<PaletteItem>),
+    /// Event received to set the palette's items after they were loaded
+    UpdatePaletteItems {
+        run_id: String,
+        items: im::Vector<PaletteItem>,
+    },
+    /// Event received to set the palette's items after they were filtered
+    FilterPaletteItems {
+        run_id: String,
+        input: String,
+        filtered_items: im::Vector<PaletteItem>,
+    },
+    /// Set the filter for the keymaps (in the settings), updating which keymaps are shown
     UpdateKeymapsFilter(String),
-    ResetSettingsFile(String, String),
-    UpdateSettingsFile(String, String, Value),
+    /// Reset a specific settings item to its default value by sending it to the widget  
+    /// (note: only handled by theme settings items currently)
+    ResetSettingsItem,
+    /// Reset a specific settings item to its default value by the path to it
+    ResetSettingsFile {
+        kind: String,
+        key: String,
+    },
+    /// Set a specific settings item to a new value by the path to it
+    UpdateSettingsFile {
+        kind: String,
+        key: String,
+        value: Value,
+    },
+    /// Update the filter for the settings
+    /// TODO: currently unused!
     UpdateSettingsFilter(String),
-    FilterKeymaps(String, Arc<Vec<KeyMap>>, Arc<Vec<LapceCommand>>),
+    FilterKeymaps {
+        pattern: String,
+        /// The filtered keymaps
+        keymaps: Arc<Vec<KeyMap>>,
+        /// The filtered commands
+        commands: Arc<Vec<LapceCommand>>,
+    },
     UpdatePickerPwd(PathBuf),
     UpdatePickerItems(PathBuf, HashMap<PathBuf, FileNodeItem>),
-    UpdateExplorerItems(PathBuf, HashMap<PathBuf, FileNodeItem>, bool),
-    UpdateInstalledPlugins(HashMap<String, PluginDescription>),
-    UpdatePluginDescriptions(Vec<PluginDescription>),
+    /// Event received when the directory of a folder has been read, so that we can include the new
+    /// files in the explorer.
+    UpdateExplorerItems {
+        /// The path of the folder we're updating the items of
+        path: PathBuf,
+        /// The items within the folder
+        items: HashMap<PathBuf, FileNodeItem>,
+        /// Whether the folder should be open or not
+        expand: bool,
+    },
+    LoadPluginLatest(VoltInfo),
+    /// Event to inform what plugins the user has installed, and thus should be loaded.
+    LoadPlugins(PluginsInfo),
+    LoadPluginsFailed,
+    /// Event received when the plugin's icon has been loaded
+    LoadPluginIcon(VoltID, VoltIconKind),
+    VoltInstalled(VoltMetadata, Option<Vec<u8>>),
+    VoltInstalling(VoltInfo, String),
+    VoltRemoving(VoltMetadata, String),
+    VoltInstallStatusClear(VoltID),
+    VoltRemoved(VoltInfo, bool),
+    EnableVolt(VoltInfo),
+    DisableVolt(VoltInfo),
+    EnableVoltWorkspace(VoltInfo),
+    DisableVoltWorkspace(VoltInfo),
     RequestLayout,
     RequestPaint,
     ResetFade,
-    //FocusTab,
+    /// Close a window tab (which is distinct from the typical editor tab!)
     CloseTab,
+    /// Close a window tab by its id
     CloseTabId(WidgetId),
+    /// Focus on a window tab by its id
     FocusTabId(WidgetId),
+    /// Swap the active window tab with the window tab at the index
     SwapTab(usize),
-    NewTab,
+    /// Move a window tab out into its own window
+    TabToWindow(WindowId, WidgetId),
+    /// Create a new window tab, optionally with a specific workspace
+    NewTab(Option<LapceWorkspace>),
+    /// Switch to the next window tab (in terms of order, not usage)
     NextTab,
+    /// Switch to the previous window tab (in terms of order, not usage)
     PreviousTab,
-    FilterItems,
+    /// Switch to the next editor tab (in terms of order, not usage)
+    NextEditorTab,
+    /// Switch to the previous editor tab (in terms of order, not usage)
+    PreviousEditorTab,
+    /// Restart Lapce at the given path so that we can apply the update
+    RestartToUpdate(PathBuf, ReleaseInfo),
+    UpdateStarted,
+    UpdateFailed,
+    /// Create a new Lapce window
     NewWindow(WindowId),
+    /// Close a Lapce window, saving the DB as needed
+    CloseWindow(WindowId),
+    /// Reload the current Lapce window
     ReloadWindow,
-    CloseBuffers(Vec<BufferId>),
-    RequestPaintRect(Rect),
-    ApplyEdits(usize, u64, Vec<TextEdit>),
-    ApplyEditsAndSave(usize, u64, Result<Value>),
-    DocumentFormat(PathBuf, u64, Result<Value>),
-    DocumentFormatAndSave(PathBuf, u64, Result<Value>, Option<WidgetId>),
-    DocumentSave(PathBuf, Option<WidgetId>),
-    BufferSave(PathBuf, u64, Option<WidgetId>),
-    UpdateSemanticStyles(BufferId, PathBuf, u64, Arc<Spans<Style>>),
+    /// Event received when the formatting request has been completed, which formats the document
+    /// with the given path using the edits.
+    DocumentFormat {
+        path: PathBuf,
+        rev: u64,
+        /// The resulting edits
+        result: Result<Vec<TextEdit>>,
+    },
+    /// Event received when the formatting request has been completed, and the document should be
+    /// saved with the given path using the edits.
+    DocumentFormatAndSave {
+        path: PathBuf,
+        rev: u64,
+        result: Result<Vec<TextEdit>>,
+        exit: Option<WidgetId>,
+    },
+    /// Save the document with the given path
+    DocumentSave {
+        path: PathBuf,
+        exit: Option<WidgetId>,
+    },
+    /// Mark the document as saved/pristine, if the revision still matches
+    BufferSave {
+        path: PathBuf,
+        rev: u64,
+        exit: Option<WidgetId>,
+    },
+    /// Update the semantic styles for the document with the given path
+    UpdateSemanticStyles {
+        // TODO: This doesn't actually use the buffer id, perhaps it should just be removed?
+        id: BufferId,
+        path: PathBuf,
+        rev: u64,
+        styles: Arc<Spans<Style>>,
+    },
+    /// Set the terminal's title
     UpdateTerminalTitle(TermId, String),
     UpdateHistoryStyle {
         id: BufferId,
@@ -475,9 +840,9 @@ pub enum LapceUICommand {
         history: String,
         highlights: Arc<Spans<Style>>,
     },
+    /// Update the syntax highlighting for the document with the given content
     UpdateSyntax {
         content: BufferContent,
-        rev: u64,
         syntax: SingleUse<Syntax>,
     },
     UpdateHistoryChanges {
@@ -486,26 +851,46 @@ pub enum LapceUICommand {
         rev: u64,
         history: String,
         changes: Arc<Vec<DiffLines>>,
+        diff_context_lines: i32,
     },
-    CenterOfWindow,
-    UpdateLineChanges(BufferId),
+    /// Publish diagnostics changes (from the proxy)
     PublishDiagnostics(PublishDiagnosticsParams),
+    /// Update the current progress information (from the proxy)
     WorkDoneProgress(ProgressParams),
     UpdateDiffInfo(DiffInfo),
-    EnsureVisible((Rect, (f64, f64), Option<EnsureVisiblePosition>)),
+    /// Scrolls the editor-view so that the rect is visible  
     EnsureRectVisible(Rect),
+    /// Scrolls the editor-view so that the cursor is visible
     EnsureCursorVisible(Option<EnsureVisiblePosition>),
     EnsureCursorPosition(EnsureVisiblePosition),
-    EditorViewSize(Size),
+    /// Scroll the editor-view by the given amount
     Scroll((f64, f64)),
+    /// Scroll the editor-view to the given point
     ScrollTo((f64, f64)),
     ForceScrollTo(f64, f64),
-    SaveAs(BufferContent, PathBuf, WidgetId, bool),
-    SaveAsSuccess(BufferContent, u64, PathBuf, WidgetId, bool),
+    /// Save the given content to the path
+    SaveAs {
+        content: BufferContent,
+        path: PathBuf,
+        view_id: WidgetId,
+        exit: bool,
+    },
+    /// Event received when save-as succeeds, used for updating the existing tab
+    SaveAsSuccess {
+        content: BufferContent,
+        rev: u64,
+        path: PathBuf,
+        view_id: WidgetId,
+        exit: bool,
+    },
+    /// Sets the picker home directory
     HomeDir(PathBuf),
-    FileChange(notify::Event),
+    /// Event received from the proxy when a file has changed in the current workspace, used for
+    /// updating the file explorer.
+    WorkspaceFileChange,
     ProxyUpdateStatus(ProxyStatus),
     CloseTerminal(TermId),
+    OpenPluginInfo(VoltInfo),
     SplitTerminal(bool, WidgetId),
     SplitTerminalClose(TermId, WidgetId),
     SplitEditor(bool, WidgetId),
@@ -523,16 +908,179 @@ pub enum LapceUICommand {
     EditorTabAdd(usize, EditorTabChild),
     EditorTabRemove(usize, bool, bool),
     EditorTabSwap(usize, usize),
-    JumpToPosition(Option<WidgetId>, Position),
+    EditorContentChanged,
+    JumpToPosition(Option<WidgetId>, Position, bool),
     JumpToLine(Option<WidgetId>, usize),
-    JumpToLocation(Option<WidgetId>, EditorLocation),
+    JumpToLocation(Option<WidgetId>, EditorLocation, bool),
+    JumpToLspLocation(Option<WidgetId>, EditorLocation<Position>, bool),
+    JumpToLineLocation(Option<WidgetId>, EditorLocation<Line>),
+    JumpToLineColLocation(Option<WidgetId>, EditorLocation<LineCol>, bool),
+    ToggleProblem(PathBuf),
     TerminalJumpToLine(i32),
-    GoToLocationNew(WidgetId, EditorLocation),
-    GotoReference(WidgetId, usize, EditorLocation),
-    GotoDefinition(WidgetId, usize, EditorLocation),
+    GoToLocation(Option<WidgetId>, EditorLocation, bool),
+    GotoDefinition {
+        editor_view_id: WidgetId,
+        offset: usize,
+        location: EditorLocation<Position>,
+    },
+    PrepareRename {
+        path: PathBuf,
+        rev: u64,
+        offset: usize,
+        start: usize,
+        end: usize,
+        placeholder: String,
+    },
+    /// Informs the editor about the locations for requested references
     PaletteReferences(usize, Vec<Location>),
     GotoLocation(Location),
+    /// Update the current file highlighted in the explorer panel
     ActiveFileChanged {
         path: Option<PathBuf>,
     },
+    /// Create a file in the given path with the given name and then open it
+    CreateFileOpen {
+        path: PathBuf,
+    },
+    CreateDirectory {
+        path: PathBuf,
+    },
+    /// Copy an existing file to the given name and then open it
+    DuplicateFileOpen {
+        existing_path: PathBuf,
+        new_path: PathBuf,
+    },
+    RenamePath {
+        from: PathBuf,
+        to: PathBuf,
+    },
+    /// Move a file/directory to the os-specific trash
+    TrashPath {
+        path: PathBuf,
+    },
+    /// Start duplicating a specific file in view at the given index
+    ExplorerStartDuplicate {
+        /// The index into the explorer's file listing
+        list_index: usize,
+        /// The level that it should be indented to
+        indent_level: usize,
+        /// The folder that the file/directory is being created within
+        base_path: PathBuf,
+        /// The name of the file being duplicated
+        name: String,
+    },
+    /// Start renaming a specific file in view at the given index
+    ExplorerStartRename {
+        /// The index into the explorer's file listing
+        list_index: usize,
+        /// The level that it should be indented to
+        indent_level: usize,
+        /// The text it will start with
+        text: String,
+    },
+    /// Start creating a new file/directory
+    ExplorerNew {
+        /// The index in the explorer's file listing that this should appear *after*
+        list_index: usize,
+        /// The level that it should be indented to
+        indent_level: usize,
+        /// Whether we are creating a file or a directory
+        is_dir: bool,
+        /// The folder that it would be created in
+        base_path: PathBuf,
+    },
+    ExplorerEndNaming {
+        /// Whether it should name/rename the file with the input data
+        apply_naming: bool,
+    },
+    ExplorerRevealPath {
+        path: PathBuf,
+    },
+    FileExplorerRefresh,
+    PutToClipboard(String),
+    CopyPath(PathBuf),
+    CopyRelativePath(PathBuf),
+    SetLanguage(String),
+    ApplySelectionRange {
+        buffer_id: BufferId,
+        rev: u64,
+        direction: SelectionRangeDirection,
+    },
+    StoreSelectionRangeAndApply {
+        buffer_id: BufferId,
+        rev: u64,
+        current_selection: Option<(usize, usize)>,
+        ranges: Vec<SelectionRange>,
+        direction: SelectionRangeDirection,
+    },
+
+    /// An item in a list was chosen
+    /// This is typically targeted at the widget which contains the list
+    ListItemSelected,
+    /// An item in the dropdown list was selected as the current item  
+    /// This is typically targeted at the widget which contains the dropdown
+    DropdownItemSelected,
+    NewMessage {
+        kind: MessageType,
+        title: String,
+        message: String,
+    },
+    CloseMessage(WidgetId),
+    ImageLoaded {
+        url: Url,
+        image: Result<images::Image, anyhow::Error>,
+    },
+}
+
+/// This can't be an `FnOnce` because we only ever get a reference to
+/// [`InitBufferContent`]
+/// However, in reality, it should only ever be called once.
+/// This could be more powerful if it was given `&mut LapceTabData` but that would
+/// require moving the callers of it into `LapceTabData`.
+///
+/// Parameters:
+/// `(ctx: &mut EventCtx, data: &mut LapceMainSplitData)`
+pub type InitBufferContentCb =
+    Box<dyn Fn(&mut EventCtx, &mut LapceMainSplitData) + Send>;
+
+pub struct InitBufferContent<P: EditorPosition> {
+    pub path: PathBuf,
+    pub content: Rope,
+    pub locations: Vec<(WidgetId, EditorLocation<P>)>,
+    pub edits: Option<Rope>,
+    pub cb: Option<InitBufferContentCb>,
+}
+
+impl<P: EditorPosition + Clone + Send + 'static> InitBufferContent<P> {
+    pub fn execute(&self, ctx: &mut EventCtx, data: &mut LapceTabData) {
+        let doc = data.main_split.open_docs.get_mut(&self.path).unwrap();
+        let doc = Arc::make_mut(doc);
+        doc.init_content(self.content.to_owned());
+
+        if let Some(rope) = &self.edits {
+            doc.reload(rope.clone(), false);
+        }
+        if let BufferContent::File(path) = doc.content() {
+            if let Some(d) = data.main_split.diagnostics.get(path) {
+                doc.set_diagnostics(d);
+            }
+        }
+
+        for (view_id, location) in &self.locations {
+            data.main_split.go_to_location(
+                ctx,
+                Some(*view_id),
+                false,
+                location.clone(),
+                &data.config,
+            );
+        }
+
+        // We've loaded the buffer and added it to the view, so inform the caller about it
+        if let Some(cb) = &self.cb {
+            (cb)(ctx, &mut data.main_split);
+        }
+
+        ctx.set_handled();
+    }
 }
diff --git a/lapce-data/src/completion.rs b/lapce-data/src/completion.rs
index 967fe8c7bc..aaa46052e2 100644
--- a/lapce-data/src/completion.rs
+++ b/lapce-data/src/completion.rs
@@ -1,31 +1,32 @@
-use std::{fmt::Display, sync::Arc};
+use std::{borrow::Cow, fmt::Display, path::PathBuf, str::FromStr, sync::Arc};
 
 use anyhow::Error;
-use druid::{ExtEventSink, Size, Target, WidgetId};
+use core::fmt;
+use druid::{EventCtx, Size, WidgetId};
 use fuzzy_matcher::{skim::SkimMatcherV2, FuzzyMatcher};
-use itertools::Itertools;
-use lapce_core::movement::Movement;
-use lapce_rpc::buffer::BufferId;
-use lsp_types::{CompletionItem, CompletionResponse, Position};
+use lapce_core::command::FocusCommand;
+use lapce_rpc::{buffer::BufferId, plugin::PluginId};
+use lsp_types::{CompletionItem, CompletionResponse, CompletionTextEdit, Position};
+use once_cell::sync::Lazy;
 use regex::Regex;
-use std::str::FromStr;
 
 use crate::{
-    command::{LapceUICommand, LAPCE_UI_COMMAND},
+    config::LapceConfig, data::LapceEditorData, document::Document, list::ListData,
     proxy::LapceProxy,
 };
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct Snippet {
     elements: Vec<SnippetElement>,
 }
 
 impl Snippet {
+    #[inline]
     fn extract_elements(
         s: &str,
         pos: usize,
-        escs: Vec<&str>,
-        loose_escs: Vec<&str>,
+        escs: &[char],
+        loose_escs: &[char],
     ) -> (Vec<SnippetElement>, usize) {
         let mut elements = Vec::new();
         let mut pos = pos;
@@ -39,7 +40,7 @@ impl Snippet {
                 elements.push(ele);
                 pos = end;
             } else if let Some((ele, end)) =
-                Self::extract_text(s, pos, escs.clone(), loose_escs.clone())
+                Self::extract_text(s, pos, escs, loose_escs)
             {
                 elements.push(ele);
                 pos = end;
@@ -50,27 +51,61 @@ impl Snippet {
         (elements, pos)
     }
 
-    fn extract_tabstop(s: &str, pos: usize) -> Option<(SnippetElement, usize)> {
-        for re in &[
-            Regex::new(r#"^\$(\d+)"#).unwrap(),
-            Regex::new(r#"^\$\{(\d+)\}"#).unwrap(),
-        ] {
-            if let Some(caps) = re.captures(&s[pos..]) {
-                let end = pos + re.find(&s[pos..])?.end();
-                let m = caps.get(1)?;
-                let n = m.as_str().parse::<usize>().ok()?;
-                return Some((SnippetElement::Tabstop(n), end));
-            }
-        }
+    #[inline]
+    fn extract_tabstop(str: &str, pos: usize) -> Option<(SnippetElement, usize)> {
+        // Regex for `$...` pattern, where `...` is some number (for example `$1`)
+        static REGEX_FIRST: Lazy<Regex> =
+            Lazy::new(|| Regex::new(r#"^\$(\d+)"#).unwrap());
+        // Regex for `${...}` pattern, where `...` is some number (for example `${1}`)
+        static REGEX_SECOND: Lazy<Regex> =
+            Lazy::new(|| Regex::new(r#"^\$\{(\d+)\}"#).unwrap());
 
+        let str = &str[pos..];
+        if let Some(matched) = REGEX_FIRST.find(str) {
+            // SAFETY:
+            // * The start index is guaranteed not to exceed the end index, since we
+            //   compare with the `$ ...` pattern, and, therefore, the first element
+            //   is always equal to the symbol `$`;
+            // * The indices are within the bounds of the original slice and lie on
+            //   UTF-8 sequence boundaries, since we take the entire slice, with the
+            //   exception of the first `$` char which is 1 byte in accordance with
+            //   the UTF-8 standard.
+            let n = unsafe {
+                matched.as_str().get_unchecked(1..).parse::<usize>().ok()?
+            };
+            let end = pos + matched.end();
+            return Some((SnippetElement::Tabstop(n), end));
+        }
+        if let Some(matched) = REGEX_SECOND.find(str) {
+            let matched = matched.as_str();
+            // SAFETY:
+            // * The start index is guaranteed not to exceed the end index, since we
+            //   compare with the `${...}` pattern, and, therefore, the first two elements
+            //   are always equal to the `${` and the last one is equal to `}`;
+            // * The indices are within the bounds of the original slice and lie on UTF-8
+            //   sequence boundaries, since we take the entire slice, with the exception
+            //   of the first two `${` and last one `}` chars each of which is 1 byte in
+            //   accordance with the UTF-8 standard.
+            let n = unsafe {
+                matched
+                    .get_unchecked(2..matched.len() - 1)
+                    .parse::<usize>()
+                    .ok()?
+            };
+            let end = pos + matched.len();
+            return Some((SnippetElement::Tabstop(n), end));
+        }
         None
     }
 
+    #[inline]
     fn extract_placeholder(s: &str, pos: usize) -> Option<(SnippetElement, usize)> {
-        let re = Regex::new(r#"^\$\{(\d+):(.*?)\}"#).unwrap();
-        let end = pos + re.find(&s[pos..])?.end();
+        // Regex for `${num:text}` pattern, where text can be empty (for example `${1:first}`
+        // and `${2:}`)
+        static REGEX: Lazy<Regex> =
+            Lazy::new(|| Regex::new(r#"^\$\{(\d+):(.*?)\}"#).unwrap());
 
-        let caps = re.captures(&s[pos..])?;
+        let caps = REGEX.captures(&s[pos..])?;
 
         let tab = caps.get(1)?.as_str().parse::<usize>().ok()?;
 
@@ -80,49 +115,43 @@ impl Snippet {
             return Some((
                 SnippetElement::PlaceHolder(
                     tab,
-                    vec![SnippetElement::Text("".to_string())],
+                    vec![SnippetElement::Text(String::new())],
                 ),
-                end,
+                pos + caps.get(0).unwrap().end(),
             ));
         }
         let (els, pos) =
-            Self::extract_elements(s, pos + m.start(), vec!["$", "}", "\\"], vec![]);
+            Self::extract_elements(s, pos + m.start(), &['$', '}', '\\'], &[]);
         Some((SnippetElement::PlaceHolder(tab, els), pos + 1))
     }
 
+    #[inline]
     fn extract_text(
         s: &str,
         pos: usize,
-        escs: Vec<&str>,
-        loose_escs: Vec<&str>,
+        escs: &[char],
+        loose_escs: &[char],
     ) -> Option<(SnippetElement, usize)> {
-        let mut s = &s[pos..];
-        let mut ele = "".to_string();
+        let mut ele = String::new();
         let mut end = pos;
+        let mut chars_iter = s[pos..].chars().peekable();
 
-        while !s.is_empty() {
-            if s.len() >= 2 {
-                let esc = &s[..2];
-                let mut new_escs = escs.clone();
-                new_escs.extend_from_slice(&loose_escs);
-
-                if new_escs
-                    .iter()
-                    .map(|e| format!("\\{}", e))
-                    .any(|x| x == *esc)
-                {
-                    ele = ele + &s[1..2].to_string();
-                    end += 2;
-                    s = &s[2..];
-                    continue;
+        while let Some(char) = chars_iter.next() {
+            if char == '\\' {
+                if let Some(&next) = chars_iter.peek() {
+                    if escs.iter().chain(loose_escs.iter()).any(|c| *c == next) {
+                        chars_iter.next();
+                        ele.push(next);
+                        end += 1 + next.len_utf8();
+                        continue;
+                    }
                 }
             }
-            if escs.contains(&&s[0..1]) {
+            if escs.contains(&char) {
                 break;
             }
-            ele = ele + &s[0..1].to_string();
-            end += 1;
-            s = &s[1..];
+            ele.push(char);
+            end += char.len_utf8();
         }
         if ele.is_empty() {
             return None;
@@ -130,10 +159,23 @@ impl Snippet {
         Some((SnippetElement::Text(ele), end))
     }
 
+    #[inline]
     pub fn text(&self) -> String {
-        self.elements.iter().map(|e| e.text()).join("")
+        let mut buf = String::new();
+        self.write_text_to(&mut buf)
+            .expect("Snippet::write_text_to function unexpectedly return error");
+        buf
+    }
+
+    #[inline]
+    fn write_text_to<Buffer: fmt::Write>(&self, buf: &mut Buffer) -> fmt::Result {
+        for snippet_element in self.elements.iter() {
+            snippet_element.write_text_to(buf)?
+        }
+        fmt::Result::Ok(())
     }
 
+    #[inline]
     pub fn tabs(&self, pos: usize) -> Vec<(usize, (usize, usize))> {
         Self::elements_tabs(&self.elements, pos)
     }
@@ -168,20 +210,23 @@ impl Snippet {
 impl FromStr for Snippet {
     type Err = Error;
 
+    #[inline]
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let (elements, _) = Self::extract_elements(s, 0, vec!["$", "\\"], vec!["}"]);
+        let (elements, _) = Self::extract_elements(s, 0, &['$', '\\'], &['}']);
         Ok(Snippet { elements })
     }
 }
 
 impl Display for Snippet {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let text = self.elements.iter().map(|e| e.to_string()).join("");
-        f.write_str(&text)
+        for snippet_element in self.elements.iter() {
+            fmt::Display::fmt(snippet_element, f)?;
+        }
+        fmt::Result::Ok(())
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum SnippetElement {
     Text(String),
     PlaceHolder(usize, Vec<SnippetElement>),
@@ -199,17 +244,30 @@ impl SnippetElement {
         }
     }
 
+    #[inline]
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
+    #[inline]
     pub fn text(&self) -> String {
-        match &self {
-            SnippetElement::Text(t) => t.to_string(),
+        let mut buf = String::new();
+        self.write_text_to(&mut buf)
+            .expect("a write_to function returned an error unexpectedly");
+        buf
+    }
+
+    fn write_text_to<Buffer: fmt::Write>(&self, buf: &mut Buffer) -> fmt::Result {
+        match self {
+            SnippetElement::Text(text) => buf.write_str(text),
             SnippetElement::PlaceHolder(_, elements) => {
-                elements.iter().map(|e| e.text()).join("")
+                for child_snippet_elm in elements {
+                    // call ourselves recursively
+                    child_snippet_elm.write_text_to(buf)?;
+                }
+                fmt::Result::Ok(())
             }
-            SnippetElement::Tabstop(_) => "".to_string(),
+            SnippetElement::Tabstop(_) => fmt::Result::Ok(()),
         }
     }
 }
@@ -219,15 +277,20 @@ impl Display for SnippetElement {
         match &self {
             SnippetElement::Text(text) => f.write_str(text),
             SnippetElement::PlaceHolder(tab, elements) => {
-                let elements = elements.iter().map(|e| e.to_string()).join("");
-                write!(f, "${{{}:{}}}", tab, elements)
+                // Trying to write to the provided buffer in the form "${tab:text}"
+                write!(f, "${{{tab}:")?;
+                for child_snippet_elm in elements {
+                    // call ourselves recursively
+                    fmt::Display::fmt(child_snippet_elm, f)?;
+                }
+                f.write_str("}")
             }
-            SnippetElement::Tabstop(tab) => write!(f, "${}", tab),
+            SnippetElement::Tabstop(tab) => write!(f, "${tab}"),
         }
     }
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Eq)]
 pub enum CompletionStatus {
     Inactive,
     Started,
@@ -237,108 +300,89 @@ pub enum CompletionStatus {
 pub struct CompletionData {
     pub id: WidgetId,
     pub scroll_id: WidgetId,
+    pub documentation_scroll_id: WidgetId,
     pub request_id: usize,
     pub status: CompletionStatus,
     pub offset: usize,
     pub buffer_id: BufferId,
     pub input: String,
-    pub index: usize,
-    pub input_items: im::HashMap<String, Arc<Vec<ScoredCompletionItem>>>,
-    empty: Arc<Vec<ScoredCompletionItem>>,
-    pub filtered_items: Arc<Vec<ScoredCompletionItem>>,
+    pub input_items: im::HashMap<String, im::Vector<ScoredCompletionItem>>,
+    empty: im::Vector<ScoredCompletionItem>,
+    pub completion_list: ListData<ScoredCompletionItem, ()>,
     pub matcher: Arc<SkimMatcherV2>,
-    pub size: Size,
+    /// The size of the documentation view
+    pub documentation_size: Size,
 }
 
 impl CompletionData {
-    pub fn new() -> Self {
+    pub fn new(config: Arc<LapceConfig>) -> Self {
+        let id = WidgetId::next();
+        let mut completion_list = ListData::new(config, id, ());
+        // TODO: Make this configurable
+        completion_list.max_displayed_items = 15;
         Self {
-            id: WidgetId::next(),
+            id,
             scroll_id: WidgetId::next(),
+            documentation_scroll_id: WidgetId::next(),
             request_id: 0,
-            index: 0,
             offset: 0,
             status: CompletionStatus::Inactive,
             buffer_id: BufferId(0),
             input: "".to_string(),
             input_items: im::HashMap::new(),
-            filtered_items: Arc::new(Vec::new()),
+            completion_list,
             matcher: Arc::new(SkimMatcherV2::default().ignore_case()),
-            size: Size::new(400.0, 300.0),
-            empty: Arc::new(Vec::new()),
+            // TODO: Make this configurable
+            documentation_size: Size::new(400.0, 300.0),
+            empty: im::Vector::new(),
         }
     }
 
+    /// Return the number of entries that are displayable
     pub fn len(&self) -> usize {
-        self.current_items().len()
+        self.completion_list.items.len()
     }
 
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
-    pub fn next(&mut self) {
-        self.index = Movement::Down.update_index(self.index, self.len(), 1, true);
-    }
-
-    pub fn previous(&mut self) {
-        self.index = Movement::Up.update_index(self.index, self.len(), 1, true);
-    }
-
-    pub fn current_items(&self) -> &Arc<Vec<ScoredCompletionItem>> {
+    pub fn current_items(&self) -> &im::Vector<ScoredCompletionItem> {
         if self.input.is_empty() {
             self.all_items()
         } else {
-            &self.filtered_items
+            &self.completion_list.items
         }
     }
 
-    pub fn all_items(&self) -> &Arc<Vec<ScoredCompletionItem>> {
+    pub fn all_items(&self) -> &im::Vector<ScoredCompletionItem> {
         self.input_items
             .get(&self.input)
             .filter(|items| !items.is_empty())
             .unwrap_or_else(move || self.input_items.get("").unwrap_or(&self.empty))
     }
 
-    pub fn current_item(&self) -> &CompletionItem {
-        &self.current_items()[self.index].item
+    pub fn current_item(&self) -> Option<&ScoredCompletionItem> {
+        self.completion_list
+            .items
+            .get(self.completion_list.selected_index)
     }
 
-    pub fn current(&self) -> &str {
-        self.current_items()[self.index].item.label.as_str()
+    pub fn current(&self) -> Option<&str> {
+        self.current_item().map(|item| item.item.label.as_str())
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn request(
-        &self,
+        &mut self,
         proxy: Arc<LapceProxy>,
-        request_id: usize,
-        buffer_id: BufferId,
+        path: PathBuf,
         input: String,
         position: Position,
-        completion_widget_id: WidgetId,
-        event_sink: ExtEventSink,
     ) {
-        proxy.get_completion(
-            request_id,
-            buffer_id,
-            position,
-            Box::new(move |result| {
-                if let Ok(res) = result {
-                    if let Ok(resp) =
-                        serde_json::from_value::<CompletionResponse>(res)
-                    {
-                        let _ = event_sink.submit_command(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::UpdateCompletion(
-                                request_id, input, resp,
-                            ),
-                            Target::Widget(completion_widget_id),
-                        );
-                    }
-                }
-            }),
-        );
+        self.input_items.insert(input.clone(), im::Vector::new());
+        proxy
+            .proxy_rpc
+            .completion(self.request_id, path, input, position);
     }
 
     pub fn cancel(&mut self) {
@@ -348,12 +392,12 @@ impl CompletionData {
         self.status = CompletionStatus::Inactive;
         self.input = "".to_string();
         self.input_items.clear();
-        self.index = 0;
+        self.completion_list.clear_items();
     }
 
     pub fn update_input(&mut self, input: String) {
         self.input = input;
-        self.index = 0;
+        self.completion_list.selected_index = 0;
         if self.status == CompletionStatus::Inactive {
             return;
         }
@@ -365,6 +409,7 @@ impl CompletionData {
         request_id: usize,
         input: String,
         resp: CompletionResponse,
+        plugin_id: PluginId,
     ) {
         if self.status == CompletionStatus::Inactive || self.request_id != request_id
         {
@@ -375,32 +420,44 @@ impl CompletionData {
             CompletionResponse::Array(items) => items,
             CompletionResponse::List(list) => list.items,
         };
-        let items: Vec<ScoredCompletionItem> = items
+        let items: im::Vector<ScoredCompletionItem> = items
             .iter()
             .map(|i| ScoredCompletionItem {
                 item: i.to_owned(),
+                plugin_id,
                 score: 0,
                 label_score: 0,
                 indices: Vec::new(),
             })
             .collect();
 
-        self.input_items.insert(input, Arc::new(items));
+        self.input_items.insert(input, items);
         self.filter_items();
+
+        if self.completion_list.selected_index >= self.len() {
+            self.completion_list.selected_index = 0;
+        }
     }
 
     pub fn filter_items(&mut self) {
         if self.input.is_empty() {
+            self.completion_list.items = self.all_items().clone();
             return;
         }
 
-        let mut items: Vec<ScoredCompletionItem> = self
+        let mut items: im::Vector<ScoredCompletionItem> = self
             .all_items()
             .iter()
             .filter_map(|i| {
                 let filter_text =
                     i.item.filter_text.as_ref().unwrap_or(&i.item.label);
-                let shift = i.item.label.match_indices(filter_text).next()?.0;
+                let shift = i
+                    .item
+                    .label
+                    .match_indices(filter_text)
+                    .next()
+                    .map(|(shift, _)| shift)
+                    .unwrap_or(0);
                 if let Some((score, mut indices)) =
                     self.matcher.fuzzy_indices(filter_text, &self.input)
                 {
@@ -430,34 +487,136 @@ impl CompletionData {
                 .then_with(|| b.label_score.cmp(&a.label_score))
                 .then_with(|| a.item.label.len().cmp(&b.item.label.len()))
         });
-        self.filtered_items = Arc::new(items);
+        self.completion_list.items = items;
     }
-}
 
-impl Default for CompletionData {
-    fn default() -> Self {
-        Self::new()
+    pub fn run_focus_command(
+        &mut self,
+        editor: &LapceEditorData,
+        doc: &mut Arc<Document>,
+        config: &LapceConfig,
+        ctx: &mut EventCtx,
+        command: &FocusCommand,
+    ) {
+        let prev_index = self.completion_list.selected_index;
+        self.completion_list.run_focus_command(ctx, command);
+
+        if prev_index != self.completion_list.selected_index {
+            self.update_document_completion(editor, doc, config);
+        }
     }
-}
 
-pub struct Completion {}
+    /// Update the active document's completion phantomtext, if it is enabled and needed.
+    pub fn update_document_completion(
+        &self,
+        editor: &LapceEditorData,
+        doc: &mut Arc<Document>,
+        config: &LapceConfig,
+    ) {
+        if editor.content.is_file() {
+            let doc = Arc::make_mut(doc);
 
-impl Completion {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
+            // It isn't enabled at all, so we just clear it (in case it was
+            // enabled, and then disalbled) which is cheap with no existing completion lens
+            if !config.editor.enable_completion_lens {
+                doc.clear_completion();
+                return;
+            }
+
+            let item = if let Some(item) = self.current_item() {
+                if let Some(edit) = &item.item.text_edit {
+                    // There's a text edit, which is used rather than the label
+
+                    let text_format = item
+                        .item
+                        .insert_text_format
+                        .unwrap_or(lsp_types::InsertTextFormat::PLAIN_TEXT);
+
+                    match edit {
+                        CompletionTextEdit::Edit(edit) => {
+                            // The completion offset can be different from the current
+                            // cursor offset
+                            let completion_offset = self.offset;
+
+                            let offset = editor.cursor.offset();
+                            let start_offset =
+                                doc.buffer().prev_code_boundary(offset);
+                            let edit_start =
+                                doc.buffer().offset_of_position(&edit.range.start);
+
+                            // If the start of the edit isn't where the cursor currently is
+                            // and it isn't at the start of the completion, then we ignore
+                            // it. This captures most cases that we want, even if it
+                            // skips over some easily displayeable edits.
+                            if start_offset != edit_start
+                                && completion_offset != edit_start
+                            {
+                                None
+                            } else {
+                                match text_format {
+                                    lsp_types::InsertTextFormat::PLAIN_TEXT => {
+                                        // This isn't entirely correcty because it assumes that the position is `{start,end}_offset` when it may not necessarily be.
+                                        let text = &edit.new_text;
+
+                                        Some(Cow::Borrowed(text))
+                                    }
+                                    lsp_types::InsertTextFormat::SNIPPET => {
+                                        // TODO: Don't unwrap
+                                        let snippet =
+                                            Snippet::from_str(&edit.new_text)
+                                                .unwrap();
+
+                                        let text = snippet.text();
+                                        Some(Cow::Owned(text))
+                                    }
+                                    _ => None,
+                                }
+                            }
+                        }
+                        CompletionTextEdit::InsertAndReplace(_) => None,
+                    }
+                } else {
+                    // There's no specific text edit, so we just use the label displayed in
+                    // the completion list
+                    let label = &item.item.label;
+
+                    Some(Cow::Borrowed(label))
+                }
+            } else {
+                None
+            };
 
-impl Default for Completion {
-    fn default() -> Self {
-        Self::new()
+            // We strip the prefix of the currently inputted text off of it, so that
+            // 'p' with a completion of `println` only sets the completion to 'rintln'.
+            // If it does not include the prefix in the right position, then we don't
+            // display it. There's probably nicer ways to do this, but that's how it works
+            // in other editors that impl it atm and it is simpler to implement.
+            let item = item.as_ref().and_then(|x| x.strip_prefix(&self.input));
+            // Get only the first line of text, because Lapce does not currently support
+            // multi-line phantom-text.
+            // TODO: Once Lapce supports multi-line phantom text, then this can be
+            // removed/modified to support it.
+            let item = item.map(|x| x.lines().next().unwrap_or(x));
+
+            // If the item we got is different from the one stored, either in content or
+            // existence, then we update the document's stored completion text.
+            if doc.completion() != item {
+                if let Some(item) = item {
+                    let offset = self.offset + self.input.len();
+                    let (line, col) = doc.buffer().offset_to_line_col(offset);
+                    doc.set_completion(item.to_string(), line, col);
+                } else {
+                    doc.clear_completion();
+                }
+            }
+        }
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub struct ScoredCompletionItem {
     pub item: CompletionItem,
-
+    pub plugin_id: PluginId,
     pub score: i64,
     pub label_score: i64,
     pub indices: Vec<usize>,
@@ -469,6 +628,8 @@ mod tests {
 
     #[test]
     fn test_snippet() {
+        use SnippetElement::*;
+
         let s = "start $1${2:second ${3:third}} $0";
         let parsed = Snippet::from_str(s).unwrap();
         assert_eq!(s, parsed.to_string());
@@ -480,5 +641,561 @@ mod tests {
             vec![(1, (6, 6)), (2, (6, 18)), (3, (13, 18)), (0, (19, 19))],
             parsed.tabs(0)
         );
+
+        let s = "start ${1}${2:second ${3:third}} $0and ${4}fourth";
+
+        let parsed = Snippet::from_str(s).unwrap();
+        assert_eq!(
+            "start $1${2:second ${3:third}} $0and $4fourth",
+            parsed.to_string()
+        );
+
+        let text = "start second third and fourth";
+        assert_eq!(text, parsed.text());
+
+        assert_eq!(
+            vec![
+                (1, (6, 6)),
+                (2, (6, 18)),
+                (3, (13, 18)),
+                (0, (19, 19)),
+                (4, (23, 23))
+            ],
+            parsed.tabs(0)
+        );
+
+        let s = "${1:first $6${2:second ${7}${3:third ${4:fourth ${5:fifth}}}}}";
+
+        let parsed = Snippet::from_str(s).unwrap();
+        assert_eq!(
+            "${1:first $6${2:second $7${3:third ${4:fourth ${5:fifth}}}}}",
+            parsed.to_string()
+        );
+
+        let text = "first second third fourth fifth";
+        assert_eq!(text, parsed.text());
+
+        assert_eq!(
+            vec![
+                (1, (0, 31)),
+                (6, (6, 6)),
+                (2, (6, 31)),
+                (7, (13, 13)),
+                (3, (13, 31)),
+                (4, (19, 31)),
+                (5, (26, 31))
+            ],
+            parsed.tabs(0)
+        );
+
+        assert_eq!(
+            Snippet {
+                elements: vec![PlaceHolder(
+                    1,
+                    vec![
+                        Text("first ".into()),
+                        Tabstop(6),
+                        PlaceHolder(
+                            2,
+                            vec![
+                                Text("second ".into()),
+                                Tabstop(7),
+                                PlaceHolder(
+                                    3,
+                                    vec![
+                                        Text("third ".into()),
+                                        PlaceHolder(
+                                            4,
+                                            vec![
+                                                Text("fourth ".into()),
+                                                PlaceHolder(
+                                                    5,
+                                                    vec![Text("fifth".into())]
+                                                )
+                                            ]
+                                        )
+                                    ]
+                                )
+                            ]
+                        )
+                    ]
+                )]
+            },
+            parsed
+        );
+
+        let s = "\\$1 start \\$2$3${4}${5:some text\\${6:third\\} $7}";
+
+        let parsed = Snippet::from_str(s).unwrap();
+        assert_eq!(
+            "$1 start $2$3$4${5:some text${6:third} $7}",
+            parsed.to_string()
+        );
+
+        let text = "$1 start $2some text${6:third} ";
+        assert_eq!(text, parsed.text());
+
+        assert_eq!(
+            vec![(3, (11, 11)), (4, (11, 11)), (5, (11, 31)), (7, (31, 31))],
+            parsed.tabs(0)
+        );
+
+        assert_eq!(
+            Snippet {
+                elements: vec![
+                    Text("$1 start $2".into()),
+                    Tabstop(3),
+                    Tabstop(4),
+                    PlaceHolder(
+                        5,
+                        vec![Text("some text${6:third} ".into()), Tabstop(7)]
+                    )
+                ]
+            },
+            parsed
+        );
+    }
+
+    #[test]
+    fn test_extract_tabstop() {
+        fn vec_of_tab_elms(s: &str) -> Vec<(usize, usize)> {
+            let mut pos = 0;
+            let mut vec = Vec::new();
+            for char in s.chars() {
+                if let Some((SnippetElement::Tabstop(stop), end)) =
+                    Snippet::extract_tabstop(s, pos)
+                {
+                    vec.push((stop, end));
+                }
+                pos += char.len_utf8();
+            }
+            vec
+        }
+
+        let s = "start $1${2:second ${3:third}} $0";
+        assert_eq!(&[(1, 8), (0, 33)][..], &vec_of_tab_elms(s)[..]);
+
+        let s = "start ${1}${2:second ${3:third}} $0and ${4}fourth";
+        assert_eq!(&[(1, 10), (0, 35), (4, 43)][..], &vec_of_tab_elms(s)[..]);
+
+        let s = "$s$1first${2}$second$3${4}${5}$6and${7}$8fourth$9$$$10$$${11}$$$12$$$13$$${14}$$${15}";
+        assert_eq!(
+            &[
+                (1, 4),
+                (2, 13),
+                (3, 22),
+                (4, 26),
+                (5, 30),
+                (6, 32),
+                (7, 39),
+                (8, 41),
+                (9, 49),
+                (10, 54),
+                (11, 61),
+                (12, 66),
+                (13, 71),
+                (14, 78),
+                (15, 85)
+            ][..],
+            &vec_of_tab_elms(s)[..]
+        );
+
+        let s = "$s$1ένα${2}$τρία$3${4}${5}$6τέσσερα${7}$8πέντε$9$$$10$$${11}$$$12$$$13$$${14}$$${15}";
+        assert_eq!(
+            &[
+                (1, 4),
+                (2, 14),
+                (3, 25),
+                (4, 29),
+                (5, 33),
+                (6, 35),
+                (7, 53),
+                (8, 55),
+                (9, 67),
+                (10, 72),
+                (11, 79),
+                (12, 84),
+                (13, 89),
+                (14, 96),
+                (15, 103)
+            ][..],
+            &vec_of_tab_elms(s)[..]
+        );
+    }
+
+    #[test]
+    fn test_extract_placeholder() {
+        use super::SnippetElement::*;
+        let s1 = "${1:first ${2:second ${3:third ${4:fourth ${5:fifth}}}}}";
+
+        assert_eq!(
+            (
+                PlaceHolder(
+                    1,
+                    vec![
+                        Text("first ".into()),
+                        PlaceHolder(
+                            2,
+                            vec![
+                                Text("second ".into()),
+                                PlaceHolder(
+                                    3,
+                                    vec![
+                                        Text("third ".into()),
+                                        PlaceHolder(
+                                            4,
+                                            vec![
+                                                Text("fourth ".into()),
+                                                PlaceHolder(
+                                                    5,
+                                                    vec![Text("fifth".into())]
+                                                )
+                                            ]
+                                        )
+                                    ]
+                                )
+                            ]
+                        )
+                    ]
+                ),
+                56
+            ),
+            Snippet::extract_placeholder(s1, 0).unwrap()
+        );
+
+        let s1 = "${1:first}${2:second}${3:third }${4:fourth ${5:fifth}}}}}";
+        assert_eq!(
+            (PlaceHolder(1, vec![Text("first".to_owned())]), 10),
+            Snippet::extract_placeholder(s1, 0).unwrap()
+        );
+        assert_eq!(
+            (PlaceHolder(2, vec![Text("second".to_owned())]), 21),
+            Snippet::extract_placeholder(s1, 10).unwrap()
+        );
+        assert_eq!(
+            (PlaceHolder(3, vec![Text("third ".to_owned())]), 32),
+            Snippet::extract_placeholder(s1, 21).unwrap()
+        );
+
+        assert_eq!(
+            (
+                PlaceHolder(
+                    4,
+                    vec![
+                        Text("fourth ".into()),
+                        PlaceHolder(5, vec![Text("fifth".into())])
+                    ]
+                ),
+                54
+            ),
+            Snippet::extract_placeholder(s1, 32).unwrap()
+        );
+    }
+
+    #[test]
+    fn test_extract_text() {
+        use SnippetElement::*;
+
+        // 1. ====================================================================================
+
+        let s = "start $1${2:second ${3:third}} $0";
+        let (snip_elm, end) = Snippet::extract_text(s, 0, &['$'], &[]).unwrap();
+        assert_eq!((Text("start ".to_owned()), 6), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$'], &[]).unwrap();
+        assert_eq!((Text("1".to_owned()), 8), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$'], &[]).unwrap();
+        assert_eq!((Text("{2:second ".to_owned()), 19), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$'], &[]).unwrap();
+        assert_eq!((Text("{3:third}} ".to_owned()), 31), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$'], &[]).unwrap();
+        assert_eq!((Text("0".to_owned()), 33), (snip_elm, end));
+
+        // 2. ====================================================================================
+
+        let s = "start $1${2:second ${3:third}} $0";
+
+        let (snip_elm, end) = Snippet::extract_text(s, 0, &['{'], &[]).unwrap();
+        assert_eq!((Text("start $1$".to_owned()), 9), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['{'], &[]).unwrap();
+        assert_eq!((Text("2:second $".to_owned()), 20), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['{'], &[]).unwrap();
+        assert_eq!((Text("3:third}} $0".to_owned()), 33), (snip_elm, end));
+
+        // 3. ====================================================================================
+
+        let s = "start $1${2:second ${3:third}} $0";
+
+        let (snip_elm, end) = Snippet::extract_text(s, 0, &['}'], &[]).unwrap();
+        assert_eq!(
+            (Text("start $1${2:second ${3:third".to_owned()), 28),
+            (snip_elm, end)
+        );
+
+        assert_eq!(None, Snippet::extract_text(s, end + 1, &['}'], &[]));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 2, &['}'], &[]).unwrap();
+        assert_eq!((Text(" $0".to_owned()), 33), (snip_elm, end));
+
+        // 4. ====================================================================================
+
+        let s = "start $1${2:second ${3:third}} $0";
+
+        let (snip_elm, end) = Snippet::extract_text(s, 0, &['\\'], &[]).unwrap();
+        assert_eq!((Text(s.to_owned()), 33), (snip_elm, end));
+
+        // 5. ====================================================================================
+
+        let s = "start \\$1${2:second \\${3:third}} $0";
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, 0, &['$', '\\'], &[]).unwrap();
+        assert_eq!((Text("start $1".to_owned()), 9), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '\\'], &[]).unwrap();
+        assert_eq!(
+            (Text("{2:second ${3:third}} ".to_owned()), 33),
+            (snip_elm, end)
+        );
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '\\'], &[]).unwrap();
+        assert_eq!((Text("0".to_owned()), 35), (snip_elm, end));
+
+        // 6. ====================================================================================
+
+        let s = "\\{start $1${2:second $\\{3:third}} $0}";
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, 0, &['{', '\\'], &[]).unwrap();
+        assert_eq!((Text("{start $1$".to_owned()), 11), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['{', '\\'], &[]).unwrap();
+        assert_eq!(
+            (Text("2:second ${3:third}} $0}".to_owned()), 37),
+            (snip_elm, end)
+        );
+
+        // 7. ====================================================================================
+
+        let s = "{start $1${2}:second $\\{3:third}} $0}";
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, 0, &['}', '\\'], &[]).unwrap();
+        assert_eq!((Text("{start $1${2".to_owned()), 12), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['}', '\\'], &[]).unwrap();
+        assert_eq!((Text(":second $".to_owned()), 22), (snip_elm, end));
+
+        assert_eq!(None, Snippet::extract_text(s, end, &['}', '\\'], &[]));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['}', '\\'], &[]).unwrap();
+        assert_eq!((Text("{3:third".to_owned()), 31), (snip_elm, end));
+
+        assert_eq!(None, Snippet::extract_text(s, end + 1, &['}', '\\'], &[]));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 2, &['}', '\\'], &[]).unwrap();
+        assert_eq!((Text(" $0".to_owned()), 36), (snip_elm, end));
+
+        // 8. ====================================================================================
+
+        let s = "{start $1${2}:second $\\{3:third}} $0}";
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, 0, &['$', '\\'], &['}']).unwrap();
+        assert_eq!((Text("{start ".to_owned()), 7), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '\\'], &['}']).unwrap();
+        assert_eq!((Text("1".to_owned()), 9), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '\\'], &['}']).unwrap();
+        assert_eq!((Text("{2}:second ".to_owned()), 21), (snip_elm, end));
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, end + 1, &['$', '\\'], &['}'])
+        );
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 2, &['$', '\\'], &['}']).unwrap();
+        assert_eq!((Text("{3:third}} ".to_owned()), 34), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '\\'], &['}']).unwrap();
+        assert_eq!((Text("0}".to_owned()), 37), (snip_elm, end));
+
+        // 9. ====================================================================================
+
+        let s = "{start $1${2}:second $\\{3:third}} $0}";
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, 0, &['$', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("{start ".to_owned()), 7), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("1".to_owned()), 9), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("{2".to_owned()), 12), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text(":second ".to_owned()), 21), (snip_elm, end));
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, end + 1, &['$', '}', '\\'], &[])
+        );
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 2, &['$', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("{3:third".to_owned()), 31), (snip_elm, end));
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, end + 1, &['$', '}', '\\'], &[])
+        );
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 2, &['$', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text(" ".to_owned()), 34), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("0".to_owned()), 36), (snip_elm, end));
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, end + 1, &['$', '}', '\\'], &[])
+        );
+
+        // 10. ====================================================================================
+
+        let s = "{start $1${2}:second $\\{3:third}} $0}";
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, 0, &['$', '{', '}', '\\'], &[])
+        );
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("start ".to_owned()), 7), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("1".to_owned()), 9), (snip_elm, end));
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[])
+        );
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 2, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("2".to_owned()), 12), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text(":second ".to_owned()), 21), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("{3:third".to_owned()), 31), (snip_elm, end));
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[])
+        );
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 2, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text(" ".to_owned()), 34), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("0".to_owned()), 36), (snip_elm, end));
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[])
+        );
+
+        // 11. ====================================================================================
+
+        let s = "{start\\\\ $1${2}:second\\ $\\{3:third}} $0}";
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, 0, &['$', '{', '}', '\\'], &[])
+        );
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("start\\ ".to_owned()), 9), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("1".to_owned()), 11), (snip_elm, end));
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[])
+        );
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 2, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("2".to_owned()), 14), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text(":second".to_owned()), 22), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text(" ".to_owned()), 24), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("{3:third".to_owned()), 34), (snip_elm, end));
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[])
+        );
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 2, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text(" ".to_owned()), 37), (snip_elm, end));
+
+        let (snip_elm, end) =
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[]).unwrap();
+        assert_eq!((Text("0".to_owned()), 39), (snip_elm, end));
+
+        assert_eq!(
+            None,
+            Snippet::extract_text(s, end + 1, &['$', '{', '}', '\\'], &[])
+        );
     }
 }
diff --git a/lapce-data/src/config.rs b/lapce-data/src/config.rs
index e9a45ba739..09aadcbeaa 100644
--- a/lapce-data/src/config.rs
+++ b/lapce-data/src/config.rs
@@ -1,99 +1,177 @@
 use std::{
-    io::Write,
+    collections::HashMap,
     path::{Path, PathBuf},
-    sync::Arc,
+    sync::{atomic::AtomicBool, Arc},
 };
 
-use anyhow::Result;
-use directories::ProjectDirs;
 use druid::{
-    piet::{PietText, Text, TextLayout, TextLayoutBuilder},
+    piet::{PietText, Svg, Text, TextLayout, TextLayoutBuilder},
     Color, ExtEventSink, FontFamily, Size, Target,
 };
 use indexmap::IndexMap;
-use lapce_proxy::plugin::PluginCatalog;
+use lapce_core::directory::Directory;
+use lapce_proxy::plugin::wasi::find_all_volts;
+use lapce_rpc::plugin::VoltID;
+use lsp_types::{CompletionItemKind, SymbolKind};
+use once_cell::sync::Lazy;
 use parking_lot::RwLock;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use structdesc::FieldNames;
 use thiserror::Error;
+use toml_edit::easy as toml;
 
 use crate::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
     data::{LapceWorkspace, LapceWorkspaceType},
+    svg::SvgStore,
 };
 
+pub const LOGO: &str = include_str!("../../extra/images/logo.svg");
 const DEFAULT_SETTINGS: &str = include_str!("../../defaults/settings.toml");
 const DEFAULT_LIGHT_THEME: &str = include_str!("../../defaults/light-theme.toml");
 const DEFAULT_DARK_THEME: &str = include_str!("../../defaults/dark-theme.toml");
-pub const LOGO: &str = include_str!("../../extra/images/logo.svg");
+const DEFAULT_ICON_THEME: &str = include_str!("../../defaults/icon-theme.toml");
+
+static DEFAULT_CONFIG: Lazy<config::Config> = Lazy::new(LapceConfig::default_config);
+static DEFAULT_LAPCE_CONFIG: Lazy<LapceConfig> =
+    Lazy::new(LapceConfig::default_lapce_config);
 
 pub struct LapceTheme {}
 
 impl LapceTheme {
-    pub const LAPCE_WARN: &'static str = "lapce.warn";
-    pub const LAPCE_ERROR: &'static str = "lapce.error";
-    pub const LAPCE_ACTIVE_TAB: &'static str = "lapce.active_tab";
-    pub const LAPCE_INACTIVE_TAB: &'static str = "lapce.inactive_tab";
-    pub const LAPCE_DROPDOWN_SHADOW: &'static str = "lapce.dropdown_shadow";
-    pub const LAPCE_BORDER: &'static str = "lapce.border";
-    pub const LAPCE_SCROLL_BAR: &'static str = "lapce.scroll_bar";
-
-    pub const EDITOR_BACKGROUND: &'static str = "editor.background";
-    pub const EDITOR_FOREGROUND: &'static str = "editor.foreground";
-    pub const EDITOR_DIM: &'static str = "editor.dim";
-    pub const EDITOR_FOCUS: &'static str = "editor.focus";
-    pub const EDITOR_CARET: &'static str = "editor.caret";
-    pub const EDITOR_SELECTION: &'static str = "editor.selection";
-    pub const EDITOR_CURRENT_LINE: &'static str = "editor.current_line";
-    pub const EDITOR_LINK: &'static str = "editor.link";
-
-    pub const SOURCE_CONTROL_ADDED: &'static str = "source_control.added";
-    pub const SOURCE_CONTROL_REMOVED: &'static str = "source_control.removed";
-    pub const SOURCE_CONTROL_MODIFIED: &'static str = "source_control.modified";
-
-    pub const TERMINAL_CURSOR: &'static str = "terminal.cursor";
-    pub const TERMINAL_BACKGROUND: &'static str = "terminal.background";
-    pub const TERMINAL_FOREGROUND: &'static str = "terminal.foreground";
-    pub const TERMINAL_RED: &'static str = "terminal.red";
-    pub const TERMINAL_BLUE: &'static str = "terminal.blue";
-    pub const TERMINAL_GREEN: &'static str = "terminal.green";
-    pub const TERMINAL_YELLOW: &'static str = "terminal.yellow";
-    pub const TERMINAL_BLACK: &'static str = "terminal.black";
-    pub const TERMINAL_WHITE: &'static str = "terminal.white";
-    pub const TERMINAL_CYAN: &'static str = "terminal.cyan";
-    pub const TERMINAL_MAGENTA: &'static str = "terminal.magenta";
-
-    pub const TERMINAL_BRIGHT_RED: &'static str = "terminal.bright_red";
-    pub const TERMINAL_BRIGHT_BLUE: &'static str = "terminal.bright_blue";
-    pub const TERMINAL_BRIGHT_GREEN: &'static str = "terminal.bright_green";
-    pub const TERMINAL_BRIGHT_YELLOW: &'static str = "terminal.bright_yellow";
-    pub const TERMINAL_BRIGHT_BLACK: &'static str = "terminal.bright_black";
-    pub const TERMINAL_BRIGHT_WHITE: &'static str = "terminal.bright_white";
-    pub const TERMINAL_BRIGHT_CYAN: &'static str = "terminal.bright_cyan";
-    pub const TERMINAL_BRIGHT_MAGENTA: &'static str = "terminal.bright_magenta";
-
-    pub const PALETTE_BACKGROUND: &'static str = "palette.background";
-    pub const PALETTE_CURRENT: &'static str = "palette.current";
-
-    pub const COMPLETION_BACKGROUND: &'static str = "completion.background";
-    pub const COMPLETION_CURRENT: &'static str = "completion.current";
-
-    pub const HOVER_BACKGROUND: &'static str = "hover.background";
-
-    pub const ACTIVITY_BACKGROUND: &'static str = "activity.background";
-    pub const ACTIVITY_CURRENT: &'static str = "activity.current";
-
-    pub const PANEL_BACKGROUND: &'static str = "panel.background";
-    pub const PANEL_CURRENT: &'static str = "panel.current";
-    pub const PANEL_HOVERED: &'static str = "panel.hovered";
-
-    pub const STATUS_BACKGROUND: &'static str = "status.background";
-    pub const STATUS_MODAL_NORMAL: &'static str = "status.modal.normal";
-    pub const STATUS_MODAL_INSERT: &'static str = "status.modal.insert";
-    pub const STATUS_MODAL_VISUAL: &'static str = "status.modal.visual";
-    pub const STATUS_MODAL_TERMINAL: &'static str = "status.modal.terminal";
-
+    pub const LAPCE_WARN: &str = "lapce.warn";
+    pub const LAPCE_ERROR: &str = "lapce.error";
+    pub const LAPCE_DROPDOWN_SHADOW: &str = "lapce.dropdown_shadow";
+    pub const LAPCE_BORDER: &str = "lapce.border";
+    pub const LAPCE_SCROLL_BAR: &str = "lapce.scroll_bar";
+
+    pub const LAPCE_BUTTON_PRIMARY_BACKGROUND: &str =
+        "lapce.button.primary.background";
+    pub const LAPCE_BUTTON_PRIMARY_FOREGROUND: &str =
+        "lapce.button.primary.foreground";
+
+    pub const LAPCE_TAB_ACTIVE_BACKGROUND: &str = "lapce.tab.active.background";
+    pub const LAPCE_TAB_ACTIVE_FOREGROUND: &str = "lapce.tab.active.foreground";
+    pub const LAPCE_TAB_ACTIVE_UNDERLINE: &str = "lapce.tab.active.underline";
+
+    pub const LAPCE_TAB_INACTIVE_BACKGROUND: &str = "lapce.tab.inactive.background";
+    pub const LAPCE_TAB_INACTIVE_FOREGROUND: &str = "lapce.tab.inactive.foreground";
+    pub const LAPCE_TAB_INACTIVE_UNDERLINE: &str = "lapce.tab.inactive.underline";
+
+    pub const LAPCE_TAB_SEPARATOR: &str = "lapce.tab.separator";
+
+    pub const LAPCE_ICON_ACTIVE: &str = "lapce.icon.active";
+    pub const LAPCE_ICON_INACTIVE: &str = "lapce.icon.inactive";
+
+    pub const LAPCE_REMOTE_ICON: &str = "lapce.remote.icon";
+    pub const LAPCE_REMOTE_LOCAL: &str = "lapce.remote.local";
+    pub const LAPCE_REMOTE_CONNECTED: &str = "lapce.remote.connected";
+    pub const LAPCE_REMOTE_CONNECTING: &str = "lapce.remote.connecting";
+    pub const LAPCE_REMOTE_DISCONNECTED: &str = "lapce.remote.disconnected";
+
+    pub const LAPCE_PLUGIN_NAME: &str = "lapce.plugin.name";
+    pub const LAPCE_PLUGIN_DESCRIPTION: &str = "lapce.plugin.description";
+    pub const LAPCE_PLUGIN_AUTHOR: &str = "lapce.plugin.author";
+
+    pub const EDITOR_BACKGROUND: &str = "editor.background";
+    pub const EDITOR_FOREGROUND: &str = "editor.foreground";
+    pub const EDITOR_DIM: &str = "editor.dim";
+    pub const EDITOR_FOCUS: &str = "editor.focus";
+    pub const EDITOR_CARET: &str = "editor.caret";
+    pub const EDITOR_SELECTION: &str = "editor.selection";
+    pub const EDITOR_CURRENT_LINE: &str = "editor.current_line";
+    pub const EDITOR_LINK: &str = "editor.link";
+    pub const EDITOR_VISIBLE_WHITESPACE: &str = "editor.visible_whitespace";
+    pub const EDITOR_INDENT_GUIDE: &str = "editor.indent_guide";
+    pub const EDITOR_DRAG_DROP_BACKGROUND: &str = "editor.drag_drop_background";
+    pub const EDITOR_STICKY_HEADER_BACKGROUND: &str =
+        "editor.sticky_header_background";
+    pub const EDITOR_DRAG_DROP_TAB_BACKGROUND: &str =
+        "editor.drag_drop_tab_background";
+
+    pub const INLAY_HINT_FOREGROUND: &str = "inlay_hint.foreground";
+    pub const INLAY_HINT_BACKGROUND: &str = "inlay_hint.background";
+
+    pub const ERROR_LENS_ERROR_FOREGROUND: &str = "error_lens.error.foreground";
+    pub const ERROR_LENS_ERROR_BACKGROUND: &str = "error_lens.error.background";
+    pub const ERROR_LENS_WARNING_FOREGROUND: &str = "error_lens.warning.foreground";
+    pub const ERROR_LENS_WARNING_BACKGROUND: &str = "error_lens.warning.background";
+    pub const ERROR_LENS_OTHER_FOREGROUND: &str = "error_lens.other.foreground";
+    pub const ERROR_LENS_OTHER_BACKGROUND: &str = "error_lens.other.background";
+
+    pub const COMPLETION_LENS_FOREGROUND: &str = "completion_lens.foreground";
+
+    pub const SOURCE_CONTROL_ADDED: &str = "source_control.added";
+    pub const SOURCE_CONTROL_REMOVED: &str = "source_control.removed";
+    pub const SOURCE_CONTROL_MODIFIED: &str = "source_control.modified";
+
+    pub const TERMINAL_CURSOR: &str = "terminal.cursor";
+    pub const TERMINAL_BACKGROUND: &str = "terminal.background";
+    pub const TERMINAL_FOREGROUND: &str = "terminal.foreground";
+    pub const TERMINAL_RED: &str = "terminal.red";
+    pub const TERMINAL_BLUE: &str = "terminal.blue";
+    pub const TERMINAL_GREEN: &str = "terminal.green";
+    pub const TERMINAL_YELLOW: &str = "terminal.yellow";
+    pub const TERMINAL_BLACK: &str = "terminal.black";
+    pub const TERMINAL_WHITE: &str = "terminal.white";
+    pub const TERMINAL_CYAN: &str = "terminal.cyan";
+    pub const TERMINAL_MAGENTA: &str = "terminal.magenta";
+
+    pub const TERMINAL_BRIGHT_RED: &str = "terminal.bright_red";
+    pub const TERMINAL_BRIGHT_BLUE: &str = "terminal.bright_blue";
+    pub const TERMINAL_BRIGHT_GREEN: &str = "terminal.bright_green";
+    pub const TERMINAL_BRIGHT_YELLOW: &str = "terminal.bright_yellow";
+    pub const TERMINAL_BRIGHT_BLACK: &str = "terminal.bright_black";
+    pub const TERMINAL_BRIGHT_WHITE: &str = "terminal.bright_white";
+    pub const TERMINAL_BRIGHT_CYAN: &str = "terminal.bright_cyan";
+    pub const TERMINAL_BRIGHT_MAGENTA: &str = "terminal.bright_magenta";
+
+    pub const PALETTE_BACKGROUND: &str = "palette.background";
+    pub const PALETTE_FOREGROUND: &str = "palette.foreground";
+    pub const PALETTE_CURRENT_BACKGROUND: &str = "palette.current.background";
+    pub const PALETTE_CURRENT_FOREGROUND: &str = "palette.current.foreground";
+
+    pub const COMPLETION_BACKGROUND: &str = "completion.background";
+    pub const COMPLETION_CURRENT: &str = "completion.current";
+
+    pub const HOVER_BACKGROUND: &str = "hover.background";
+
+    pub const ACTIVITY_BACKGROUND: &str = "activity.background";
+    pub const ACTIVITY_CURRENT: &str = "activity.current";
+
+    pub const PANEL_BACKGROUND: &str = "panel.background";
+    pub const PANEL_FOREGROUND: &str = "panel.foreground";
+    pub const PANEL_FOREGROUND_DIM: &str = "panel.foreground.dim";
+    pub const PANEL_CURRENT_BACKGROUND: &str = "panel.current.background";
+    pub const PANEL_CURRENT_FOREGROUND: &str = "panel.current.foreground";
+    pub const PANEL_CURRENT_FOREGROUND_DIM: &str = "panel.current.foreground.dim";
+    pub const PANEL_HOVERED_BACKGROUND: &str = "panel.hovered.background";
+    pub const PANEL_HOVERED_FOREGROUND: &str = "panel.hovered.foreground";
+    pub const PANEL_HOVERED_FOREGROUND_DIM: &str = "panel.hovered.foreground.dim";
+
+    pub const STATUS_BACKGROUND: &str = "status.background";
+    pub const STATUS_FOREGROUND: &str = "status.foreground";
+    pub const STATUS_MODAL_NORMAL_BACKGROUND: &str =
+        "status.modal.normal.background";
+    pub const STATUS_MODAL_NORMAL_FOREGROUND: &str =
+        "status.modal.normal.foreground";
+    pub const STATUS_MODAL_INSERT_BACKGROUND: &str =
+        "status.modal.insert.background";
+    pub const STATUS_MODAL_INSERT_FOREGROUND: &str =
+        "status.modal.insert.foreground";
+    pub const STATUS_MODAL_VISUAL_BACKGROUND: &str =
+        "status.modal.visual.background";
+    pub const STATUS_MODAL_VISUAL_FOREGROUND: &str =
+        "status.modal.visual.foreground";
+    pub const STATUS_MODAL_TERMINAL_BACKGROUND: &str =
+        "status.modal.terminal.background";
+    pub const STATUS_MODAL_TERMINAL_FOREGROUND: &str =
+        "status.modal.terminal.foreground";
+
+    pub const PALETTE_INPUT_LINE_HEIGHT: druid::Key<f64> =
+        druid::Key::new("lapce.palette_input_line_height");
+    pub const PALETTE_INPUT_LINE_PADDING: druid::Key<f64> =
+        druid::Key::new("lapce.palette_input_line_padding");
     pub const INPUT_LINE_HEIGHT: druid::Key<f64> =
         druid::Key::new("lapce.input_line_height");
     pub const INPUT_LINE_PADDING: druid::Key<f64> =
@@ -117,17 +195,156 @@ pub enum LoadThemeError {
     Read(std::io::Error),
 }
 
+pub struct LapceIcons {}
+
+impl LapceIcons {
+    pub const WINDOW_CLOSE: &str = "window.close";
+    pub const WINDOW_RESTORE: &str = "window.restore";
+    pub const WINDOW_MAXIMIZE: &str = "window.maximize";
+    pub const WINDOW_MINIMIZE: &str = "window.minimize";
+
+    pub const LINK: &str = "link";
+    pub const ERROR: &str = "error";
+    pub const ADD: &str = "add";
+    pub const CLOSE: &str = "close";
+    pub const REMOTE: &str = "remote";
+    pub const PROBLEM: &str = "error";
+    pub const UNSAVED: &str = "unsaved";
+    pub const WARNING: &str = "warning";
+    pub const TERMINAL: &str = "terminal";
+    pub const SETTINGS: &str = "settings";
+    pub const LIGHTBULB: &str = "lightbulb";
+    pub const EXTENSIONS: &str = "extensions";
+    pub const BREADCRUMB_SEPARATOR: &str = "breadcrumb_separator";
+
+    pub const FILE: &str = "file";
+    pub const FILE_EXPLORER: &str = "file_explorer";
+    pub const FILE_PICKER_UP: &str = "file_picker_up";
+
+    pub const IMAGE_LOADING: &str = "image_loading";
+    pub const IMAGE_ERROR: &str = "image_error";
+
+    pub const SCM: &str = "scm.icon";
+    pub const SCM_DIFF_MODIFIED: &str = "scm.diff.modified";
+    pub const SCM_DIFF_ADDED: &str = "scm.diff.added";
+    pub const SCM_DIFF_REMOVED: &str = "scm.diff.removed";
+    pub const SCM_DIFF_RENAMED: &str = "scm.diff.renamed";
+    pub const SCM_CHANGE_ADD: &str = "scm.change.add";
+    pub const SCM_CHANGE_REMOVE: &str = "scm.change.remove";
+
+    pub const PALETTE_MENU: &str = "palette.menu";
+
+    pub const DROPDOWN_ARROW: &str = "dropdown.arrow";
+
+    pub const LOCATION_BACKWARD: &str = "location.backward";
+    pub const LOCATION_FORWARD: &str = "location.forward";
+
+    pub const ITEM_OPENED: &str = "item.opened";
+    pub const ITEM_CLOSED: &str = "item.closed";
+
+    pub const DIRECTORY_CLOSED: &str = "directory.closed";
+    pub const DIRECTORY_OPENED: &str = "directory.opened";
+
+    pub const PANEL_RESTORE: &str = "panel.restore";
+    pub const PANEL_MAXIMISE: &str = "panel.maximise";
+
+    pub const SPLIT_HORIZONTAL: &str = "split.horizontal";
+
+    pub const TAB_PREVIOUS: &str = "tab.previous";
+    pub const TAB_NEXT: &str = "tab.next";
+
+    pub const SIDEBAR_LEFT: &str = "sidebar.left.on";
+    pub const SIDEBAR_LEFT_OFF: &str = "sidebar.left.off";
+    pub const SIDEBAR_RIGHT: &str = "sidebar.right.on";
+    pub const SIDEBAR_RIGHT_OFF: &str = "sidebar.right.off";
+
+    pub const LAYOUT_PANEL: &str = "layout.panel.on";
+    pub const LAYOUT_PANEL_OFF: &str = "layout.panel.off";
+
+    pub const SEARCH: &'static str = "search.icon";
+    pub const SEARCH_CLEAR: &'static str = "search.clear";
+    pub const SEARCH_FORWARD: &'static str = "search.forward";
+    pub const SEARCH_BACKWARD: &'static str = "search.backward";
+    pub const SEARCH_CASE_SENSITIVE: &'static str = "search.case_sensitive";
+
+    pub const FILE_TYPE_CODE: &str = "file-code";
+    pub const FILE_TYPE_MEDIA: &str = "file-media";
+    pub const FILE_TYPE_BINARY: &str = "file-binary";
+    pub const FILE_TYPE_ARCHIVE: &str = "file-zip";
+    pub const FILE_TYPE_SUBMODULE: &str = "file-submodule";
+    pub const FILE_TYPE_SYMLINK_FILE: &str = "file-symlink-file";
+    pub const FILE_TYPE_SYMLINK_DIRECTORY: &str = "file-symlink-directory";
+
+    pub const SYMBOL_KIND_ARRAY: &str = "symbol_kind.array";
+    pub const SYMBOL_KIND_BOOLEAN: &str = "symbol_kind.boolean";
+    pub const SYMBOL_KIND_CLASS: &str = "symbol_kind.class";
+    pub const SYMBOL_KIND_CONSTANT: &str = "symbol_kind.constant";
+    pub const SYMBOL_KIND_ENUM_MEMBER: &str = "symbol_kind.enum_member";
+    pub const SYMBOL_KIND_ENUM: &str = "symbol_kind.enum";
+    pub const SYMBOL_KIND_EVENT: &str = "symbol_kind.event";
+    pub const SYMBOL_KIND_FIELD: &str = "symbol_kind.field";
+    pub const SYMBOL_KIND_FILE: &str = "symbol_kind.file";
+    pub const SYMBOL_KIND_FUNCTION: &str = "symbol_kind.function";
+    pub const SYMBOL_KIND_INTERFACE: &str = "symbol_kind.interface";
+    pub const SYMBOL_KIND_KEY: &str = "symbol_kind.key";
+    pub const SYMBOL_KIND_METHOD: &str = "symbol_kind.method";
+    pub const SYMBOL_KIND_NAMESPACE: &str = "symbol_kind.namespace";
+    pub const SYMBOL_KIND_NUMBER: &str = "symbol_kind.number";
+    pub const SYMBOL_KIND_OBJECT: &str = "symbol_kind.namespace";
+    pub const SYMBOL_KIND_OPERATOR: &str = "symbol_kind.operator";
+    pub const SYMBOL_KIND_PROPERTY: &str = "symbol_kind.property";
+    pub const SYMBOL_KIND_STRING: &str = "symbol_kind.string";
+    pub const SYMBOL_KIND_STRUCT: &str = "symbol_kind.struct";
+    pub const SYMBOL_KIND_TYPE_PARAMETER: &str = "symbol_kind.type_parameter";
+    pub const SYMBOL_KIND_VARIABLE: &str = "symbol_kind.variable";
+
+    pub const COMPLETION_ITEM_KIND_CLASS: &str = "completion_item_kind.class";
+    pub const COMPLETION_ITEM_KIND_CONSTANT: &str = "completion_item_kind.constant";
+    pub const COMPLETION_ITEM_KIND_ENUM_MEMBER: &str =
+        "completion_item_kind.enum_member";
+    pub const COMPLETION_ITEM_KIND_ENUM: &str = "completion_item_kind.enum";
+    pub const COMPLETION_ITEM_KIND_FIELD: &str = "completion_item_kind.field";
+    pub const COMPLETION_ITEM_KIND_FUNCTION: &str = "completion_item_kind.function";
+    pub const COMPLETION_ITEM_KIND_INTERFACE: &str =
+        "completion_item_kind.interface";
+    pub const COMPLETION_ITEM_KIND_KEYWORD: &str = "completion_item_kind.keyword";
+    pub const COMPLETION_ITEM_KIND_METHOD: &str = "completion_item_kind.method";
+    pub const COMPLETION_ITEM_KIND_MODULE: &str = "completion_item_kind.module";
+    pub const COMPLETION_ITEM_KIND_PROPERTY: &str = "completion_item_kind.property";
+    pub const COMPLETION_ITEM_KIND_SNIPPET: &str = "completion_item_kind.snippet";
+    pub const COMPLETION_ITEM_KIND_STRING: &str = "completion_item_kind.string";
+    pub const COMPLETION_ITEM_KIND_STRUCT: &str = "completion_item_kind.struct";
+    pub const COMPLETION_ITEM_KIND_VARIABLE: &str = "completion_item_kind.variable";
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub enum ClickMode {
+    #[default]
+    #[serde(rename = "single")]
+    SingleClick,
+    #[serde(rename = "file")]
+    DoubleClickFile,
+    #[serde(rename = "all")]
+    DoubleClickAll,
+}
+
 pub trait GetConfig {
-    fn get_config(&self) -> &Config;
+    fn get_config(&self) -> &LapceConfig;
 }
 
 #[derive(FieldNames, Debug, Clone, Deserialize, Serialize, Default)]
 #[serde(rename_all = "kebab-case")]
-pub struct LapceConfig {
+pub struct CoreConfig {
     #[field_names(desc = "modal編集の有効化 (Vim like)")]
     pub modal: bool,
     #[field_names(desc = "Lapceのcolor themeを設定します")]
     pub color_theme: String,
+    #[field_names(desc = "Set the icon theme of Lapce")]
+    pub icon_theme: String,
+    #[field_names(
+        desc = "Enable customised titlebar and disable OS native one (Linux, BSD, Windows)"
+    )]
+    pub custom_titlebar: bool,
 }
 
 #[derive(FieldNames, Debug, Clone, Deserialize, Serialize, Default)]
@@ -139,14 +356,42 @@ pub struct EditorConfig {
     pub font_size: usize,
     #[field_names(desc = "code-lensのfont sizeを設定します")]
     pub code_lens_font_size: usize,
-    #[field_names(desc = "editorの行の高さを設定します")]
-    pub line_height: usize,
+    #[field_names(
+        desc = "Set the editor line height. 5.0より小さい場合、行の高さはfont sizeの倍数になります。"
+    )]
+    line_height: f64,
     #[field_names(desc = "tabの幅を設定します")]
     pub tab_width: usize,
     #[field_names(desc = "開いたeditorをtabで表示する場合")]
     pub show_tab: bool,
-    #[field_names(desc = "editorが最後の行を超えてscrollできる場合")]
+    #[field_names(desc = "fileに対してnavigation breadcrumbsが表示されるかどうか")]
+    pub show_bread_crumbs: bool,
+    #[field_names(desc = "editorが最後の行を超えてscrollできるかどうか")]
     pub scroll_beyond_last_line: bool,
+    #[field_names(
+        desc = "cursorの上下に表示される最小の線数を設定する"
+    )]
+    pub cursor_surrounding_lines: usize,
+    #[field_names(
+        desc = "scroll時にeditor上部に関数やclassなどのcode contextを表示"
+    )]
+    pub sticky_header: bool,
+    #[field_names(
+        desc = "現在の完了済のitemのdocumentをeditorで表示する場合"
+    )]
+    pub completion_show_documentation: bool,
+    #[field_names(
+        desc = "parameterを入力する際に、editorに関数のsignatureを表示させたい場合"
+    )]
+    pub show_signature: bool,
+    #[field_names(
+        desc = "signature viewがcodeblockをlabelに入れるべきかどうか。 これは、labelに無効なcodeを提供するLSPではうまく機能しないかもしれません。"
+    )]
+    pub signature_label_code_block: bool,
+    #[field_names(
+        desc = "matching pairの自動closeを無効にするかどうか"
+    )]
+    pub auto_closing_matching_pairs: bool,
     #[field_names(
         desc = "hover時に情報が表示されるまでの時間(ms)"
     )]
@@ -159,11 +404,166 @@ pub struct EditorConfig {
         desc = "Whether it should format the document on save (if there is an available formatter)"
     )]
     pub format_on_save: bool,
+
+    #[field_names(desc = "If matching brackets are highlighted")]
+    pub highlight_matching_brackets: bool,
+
+    #[field_names(desc = "If scope lines are highlighted")]
+    pub highlight_scope_lines: bool,
+
+    #[field_names(desc = "If inlay hints should be displayed")]
+    pub enable_inlay_hints: bool,
+
+    #[field_names(
+        desc = "Set the inlay hint font family. If empty, it uses the editor font family."
+    )]
+    pub inlay_hint_font_family: String,
+    #[field_names(
+        desc = "Set the inlay hint font size. If less than 5 or greater than editor font size, it uses the editor font size."
+    )]
+    pub inlay_hint_font_size: usize,
+    #[field_names(desc = "If diagnostics should be displayed inline")]
+    pub enable_error_lens: bool,
+    #[field_names(
+        desc = "Whether error lens should go to the end of view line, or only to the end of the diagnostic"
+    )]
+    pub error_lens_end_of_line: bool,
+    #[field_names(
+        desc = "Set error lens font family. If empty, it uses the inlay hint font family."
+    )]
+    pub error_lens_font_family: String,
+    #[field_names(
+        desc = "Set the error lens font size. If 0 it uses the inlay hint font size."
+    )]
+    pub error_lens_font_size: usize,
+    #[field_names(
+        desc = "If the editor should display the completion item as phantom text"
+    )]
+    pub enable_completion_lens: bool,
+    #[field_names(
+        desc = "Set completion lens font family. If empty, it uses the inlay hint font family."
+    )]
+    pub completion_lens_font_family: String,
+    #[field_names(
+        desc = "Set the completion lens font size. If 0 it uses the inlay hint font size."
+    )]
+    pub completion_lens_font_size: usize,
+    #[field_names(
+        desc = "Set the cursor blink interval (in milliseconds). Set to 0 to completely disable."
+    )]
+    pub blink_interval: u64, // TODO: change to u128 when upgrading config-rs to >0.11
+    #[field_names(
+        desc = "Whether the multiple cursor selection is case sensitive."
+    )]
+    pub multicursor_case_sensitive: bool,
+    #[field_names(
+        desc = "Whether the multiple cursor selection only selects whole words."
+    )]
+    pub multicursor_whole_words: bool,
+    #[field_names(
+        desc = "How the editor should render whitespace characters.\nOptions: none, all, boundary, trailing."
+    )]
+    pub render_whitespace: String,
+    #[field_names(desc = "Whether the editor show indent guide.")]
+    pub show_indent_guide: bool,
+    #[field_names(
+        desc = "Set the auto save delay (in milliseconds), Set to 0 to completely disable"
+    )]
+    pub autosave_interval: u64,
+    #[field_names(
+        desc = "Whether the document should be formatted when an autosave is triggered (required Format on Save)"
+    )]
+    pub format_on_autosave: bool,
+    #[field_names(
+        desc = "If enabled the cursor treats leading soft tabs as if they are hard tabs."
+    )]
+    pub atomic_soft_tabs: bool,
+    #[field_names(
+        desc = "Use a double click to interact with the file explorer.\nOptions: single (default), file or all."
+    )]
+    pub double_click: ClickMode,
+    #[field_names(desc = "Move the focus as you type in the global search box")]
+    pub move_focus_while_search: bool,
+    #[field_names(
+        desc = "Set the default number of visible lines above and below the diff block (-1 for infinite)"
+    )]
+    pub diff_context_lines: i32,
+    #[field_names(
+        desc = "Scroll speed modifier. The scroll delta will be multiplied by whatever the value is povided here. Defaults to 1."
+    )]
+    pub scroll_speed_modifier: f64,
 }
 
 impl EditorConfig {
+    pub fn line_height(&self) -> usize {
+        const SCALE_OR_SIZE_LIMIT: f64 = 5.0;
+
+        let line_height = if self.line_height < SCALE_OR_SIZE_LIMIT {
+            self.line_height * self.font_size as f64
+        } else {
+            self.line_height
+        };
+
+        // Prevent overlapping lines
+        (line_height.round() as usize).max(self.font_size)
+    }
+
     pub fn font_family(&self) -> FontFamily {
-        FontFamily::new_unchecked(self.font_family.clone())
+        if self.font_family.is_empty() {
+            FontFamily::SYSTEM_UI
+        } else {
+            FontFamily::new_unchecked(self.font_family.clone())
+        }
+    }
+
+    pub fn inlay_hint_font_family(&self) -> FontFamily {
+        if self.inlay_hint_font_family.is_empty() {
+            self.font_family()
+        } else {
+            FontFamily::new_unchecked(self.inlay_hint_font_family.clone())
+        }
+    }
+
+    pub fn inlay_hint_font_size(&self) -> usize {
+        if self.inlay_hint_font_size < 5
+            || self.inlay_hint_font_size > self.font_size
+        {
+            self.font_size
+        } else {
+            self.inlay_hint_font_size
+        }
+    }
+
+    pub fn error_lens_font_family(&self) -> FontFamily {
+        if self.error_lens_font_family.is_empty() {
+            self.inlay_hint_font_family()
+        } else {
+            FontFamily::new_unchecked(self.error_lens_font_family.clone())
+        }
+    }
+
+    pub fn error_lens_font_size(&self) -> usize {
+        if self.error_lens_font_size == 0 {
+            self.inlay_hint_font_size()
+        } else {
+            self.error_lens_font_size
+        }
+    }
+
+    pub fn completion_lens_font_family(&self) -> FontFamily {
+        if self.completion_lens_font_family.is_empty() {
+            self.inlay_hint_font_family()
+        } else {
+            FontFamily::new_unchecked(self.completion_lens_font_family.clone())
+        }
+    }
+
+    pub fn completion_lens_font_size(&self) -> usize {
+        if self.completion_lens_font_size == 0 {
+            self.inlay_hint_font_size()
+        } else {
+            self.completion_lens_font_size
+        }
     }
 }
 
@@ -175,9 +575,12 @@ pub struct UIConfig {
     )]
     font_family: String,
 
-    #[field_names(desc = "uiのbase font sizeを設定する")]
+    #[field_names(desc = "UIのbase font sizeを設定する")]
     font_size: usize,
 
+    #[field_names(desc = "UIのicon sizeを設定する")]
+    icon_size: usize,
+
     #[field_names(
         desc = "panel headerとeditor tab headerの高さを設定する"
     )]
@@ -189,14 +592,27 @@ pub struct UIConfig {
     #[field_names(desc = "editor tabの最小幅を設定する")]
     tab_min_width: usize,
 
-    #[field_names(desc = "activity barの幅を設定する")]
-    activity_width: usize,
-
     #[field_names(desc = "scroll barの幅を設定する")]
     scroll_width: usize,
 
     #[field_names(desc = "uiのdrop shadowの幅を制御します")]
     drop_shadow_width: usize,
+
+    #[field_names(desc = "Controls the width of the preview editor")]
+    preview_editor_width: usize,
+
+    #[field_names(
+        desc = "Set the hover font family. If empty, it uses the UI font family"
+    )]
+    hover_font_family: String,
+    #[field_names(desc = "Set the hover font size. If 0, uses the UI font size")]
+    hover_font_size: usize,
+
+    #[field_names(desc = "Trim whitespace from search results")]
+    trim_search_results_whitespace: bool,
+
+    #[field_names(desc = "Set the line height for list items")]
+    list_line_height: usize,
 }
 
 impl UIConfig {
@@ -204,7 +620,7 @@ impl UIConfig {
         if self.font_family.is_empty() {
             FontFamily::SYSTEM_UI
         } else {
-            FontFamily::new_unchecked(self.font_family.clone())
+            FontFamily::new_unchecked(self.font_family.as_str())
         }
     }
 
@@ -212,6 +628,14 @@ impl UIConfig {
         self.font_size.max(6).min(32)
     }
 
+    pub fn icon_size(&self) -> usize {
+        if self.icon_size == 0 {
+            self.font_size() + 2
+        } else {
+            self.icon_size.max(6).min(32)
+        }
+    }
+
     pub fn header_height(&self) -> usize {
         let font_size = self.font_size();
         self.header_height.max(font_size)
@@ -226,10 +650,6 @@ impl UIConfig {
         self.tab_min_width
     }
 
-    pub fn activity_width(&self) -> usize {
-        self.activity_width
-    }
-
     pub fn scroll_width(&self) -> usize {
         self.scroll_width
     }
@@ -237,6 +657,34 @@ impl UIConfig {
     pub fn drop_shadow_width(&self) -> usize {
         self.drop_shadow_width
     }
+
+    pub fn preview_editor_width(&self) -> usize {
+        self.preview_editor_width
+    }
+
+    pub fn hover_font_family(&self) -> FontFamily {
+        if self.hover_font_family.is_empty() {
+            self.font_family()
+        } else {
+            FontFamily::new_unchecked(self.hover_font_family.as_str())
+        }
+    }
+
+    pub fn hover_font_size(&self) -> usize {
+        if self.hover_font_size == 0 {
+            self.font_size()
+        } else {
+            self.hover_font_size
+        }
+    }
+
+    pub fn trim_search_results_whitespace(&self) -> bool {
+        self.trim_search_results_whitespace
+    }
+
+    pub fn list_line_height(&self) -> usize {
+        self.list_line_height
+    }
 }
 
 #[derive(FieldNames, Debug, Clone, Deserialize, Serialize, Default)]
@@ -259,16 +707,18 @@ pub struct TerminalConfig {
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize, Default)]
-pub struct ThemeConfig {
+#[serde(rename_all = "kebab-case")]
+pub struct ColorThemeConfig {
     #[serde(skip)]
     pub path: PathBuf,
     pub name: String,
+    pub high_contrast: Option<bool>,
     pub base: ThemeBaseConfig,
     pub syntax: IndexMap<String, String>,
     pub ui: IndexMap<String, String>,
 }
 
-impl ThemeConfig {
+impl ColorThemeConfig {
     fn resolve_color(
         colors: &IndexMap<String, String>,
         base: &ThemeBaseColor,
@@ -277,27 +727,19 @@ impl ThemeConfig {
         colors
             .iter()
             .map(|(name, hex)| {
-                if let Some(stripped) = hex.strip_prefix('$') {
-                    if let Some(c) = base.get(stripped) {
-                        return (name.to_string(), c.clone());
-                    }
-                    if let Some(default) = default {
-                        if let Some(c) = default.get(name) {
-                            return (name.to_string(), c.clone());
-                        }
-                    }
-                    return (name.to_string(), Color::rgb8(0, 0, 0));
-                }
-
-                if let Ok(c) = Color::from_hex_str(hex) {
-                    return (name.to_string(), c);
-                }
-                if let Some(default) = default {
-                    if let Some(c) = default.get(name) {
-                        return (name.to_string(), c.clone());
-                    }
-                }
-                (name.to_string(), Color::rgb8(0, 0, 0))
+                let color = if let Some(stripped) = hex.strip_prefix('$') {
+                    base.get(stripped).cloned()
+                } else {
+                    Color::from_hex_str(hex).ok()
+                };
+
+                let color = color
+                    .or_else(|| {
+                        default.and_then(|default| default.get(name).cloned())
+                    })
+                    .unwrap_or(Color::rgb8(0, 0, 0));
+
+                (name.to_string(), color)
             })
             .collect()
     }
@@ -336,62 +778,19 @@ pub struct ThemeBaseConfig {
 
 impl ThemeBaseConfig {
     pub fn resolve(&self, default: Option<&ThemeBaseColor>) -> ThemeBaseColor {
+        let default = default.cloned().unwrap_or_default();
         ThemeBaseColor {
-            white: Color::from_hex_str(&self.white).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.white.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
-            black: Color::from_hex_str(&self.black).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.black.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
-            grey: Color::from_hex_str(&self.grey).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.grey.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
-            blue: Color::from_hex_str(&self.blue).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.blue.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
-            red: Color::from_hex_str(&self.red).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.red.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
-            yellow: Color::from_hex_str(&self.yellow).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.yellow.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
-            orange: Color::from_hex_str(&self.orange).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.orange.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
-            green: Color::from_hex_str(&self.green).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.green.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
-            purple: Color::from_hex_str(&self.purple).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.purple.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
-            cyan: Color::from_hex_str(&self.cyan).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.cyan.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
-            magenta: Color::from_hex_str(&self.magenta).unwrap_or_else(|_| {
-                default
-                    .map(|d| d.magenta.clone())
-                    .unwrap_or_else(|| Color::rgb8(0, 0, 0))
-            }),
+            white: Color::from_hex_str(&self.white).unwrap_or(default.white),
+            black: Color::from_hex_str(&self.black).unwrap_or(default.black),
+            grey: Color::from_hex_str(&self.grey).unwrap_or(default.grey),
+            blue: Color::from_hex_str(&self.blue).unwrap_or(default.blue),
+            red: Color::from_hex_str(&self.red).unwrap_or(default.red),
+            yellow: Color::from_hex_str(&self.yellow).unwrap_or(default.yellow),
+            orange: Color::from_hex_str(&self.orange).unwrap_or(default.orange),
+            green: Color::from_hex_str(&self.green).unwrap_or(default.green),
+            purple: Color::from_hex_str(&self.purple).unwrap_or(default.purple),
+            cyan: Color::from_hex_str(&self.cyan).unwrap_or(default.cyan),
+            magenta: Color::from_hex_str(&self.magenta).unwrap_or(default.magenta),
         }
     }
 
@@ -413,8 +812,53 @@ impl ThemeBaseConfig {
     }
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize, Default)]
+#[serde(rename_all = "kebab-case")]
+pub struct IconThemeConfig {
+    #[serde(skip)]
+    pub path: PathBuf,
+    pub name: String,
+    pub use_editor_color: Option<bool>,
+    pub ui: IndexMap<String, String>,
+    pub foldername: IndexMap<String, String>,
+    pub filename: IndexMap<String, String>,
+    pub extension: IndexMap<String, String>,
+}
+
+impl IconThemeConfig {
+    pub fn resolve_path_to_icon(&self, path: &Path) -> Option<PathBuf> {
+        if let Some((_, icon)) = self.filename.get_key_value(
+            path.file_name()
+                .unwrap_or_default()
+                .to_str()
+                .unwrap_or_default(),
+        ) {
+            Some(self.path.join(icon))
+        } else if let Some((_, icon)) = self.extension.get_key_value(
+            path.extension()
+                .unwrap_or_default()
+                .to_str()
+                .unwrap_or_default(),
+        ) {
+            Some(self.path.join(icon))
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub enum ThemeColorPreference {
+    #[default]
+    Light,
+    Dark,
+    HighContrastDark,
+    HighContrastLight,
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct ThemeColor {
+    pub color_preference: ThemeColorPreference,
     pub base: ThemeBaseColor,
     pub syntax: HashMap<String, Color>,
     pub ui: HashMap<String, Color>,
@@ -454,7 +898,7 @@ impl Default for ThemeBaseColor {
 }
 
 impl ThemeBaseColor {
-    fn get(&self, name: &str) -> Option<&Color> {
+    pub fn get(&self, name: &str) -> Option<&Color> {
         Some(match name {
             "white" => &self.white,
             "black" => &self.black,
@@ -479,32 +923,85 @@ impl ThemeBaseColor {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Default)]
-pub struct Config {
+/// Used for creating a `DropdownData` for a setting
+#[derive(Debug, Clone)]
+pub struct DropdownInfo {
+    /// The currently selected item.
+    pub active_index: usize,
+    pub items: im::Vector<String>,
+}
+
+#[derive(Clone, Deserialize, Default)]
+#[serde(rename_all = "kebab-case")]
+pub struct LapceConfig {
     #[serde(skip)]
     pub id: u64,
-    pub lapce: LapceConfig,
+    pub core: CoreConfig,
     pub ui: UIConfig,
     pub editor: EditorConfig,
     pub terminal: TerminalConfig,
-    pub theme: ThemeConfig,
+    pub color_theme: ColorThemeConfig,
+    pub icon_theme: IconThemeConfig,
+    #[serde(flatten)]
+    pub plugins: HashMap<String, HashMap<String, serde_json::Value>>,
     #[serde(skip)]
-    pub default_theme: ThemeConfig,
+    pub default_color_theme: ColorThemeConfig,
+    #[serde(skip)]
+    pub default_icon_theme: IconThemeConfig,
     #[serde(skip)]
     pub color: ThemeColor,
     #[serde(skip)]
-    pub available_themes: HashMap<String, (String, config::Config)>,
+    pub available_color_themes: HashMap<String, (String, config::Config)>,
+    #[serde(skip)]
+    pub available_icon_themes:
+        HashMap<String, (String, config::Config, Option<PathBuf>)>,
     #[serde(skip)]
     tab_layout_info: Arc<RwLock<HashMap<(FontFamily, usize), f64>>>,
+    #[serde(skip)]
+    svg_store: Arc<RwLock<SvgStore>>,
+    /// A list of the themes that are available. This is primarily for populating
+    /// the theme picker, and serves as a cache.
+    #[serde(skip)]
+    color_theme_list: im::Vector<String>,
+    #[serde(skip)]
+    icon_theme_list: im::Vector<String>,
+}
+impl LapceConfig {
+    /// Get the dropdown information for the specific setting, used for the settings UI.
+    /// This should aim to efficiently return the data, because it is used to determine whether to
+    /// update the dropdown items.
+    pub fn get_dropdown_info(&self, kind: &str, key: &str) -> Option<DropdownInfo> {
+        match (kind, key) {
+            ("core", "color-theme") => Some(DropdownInfo {
+                active_index: self
+                    .color_theme_list
+                    .index_of(&self.color_theme.name)
+                    .unwrap_or(0),
+                items: self.color_theme_list.clone(),
+            }),
+            ("core", "icon-theme") => Some(DropdownInfo {
+                active_index: self
+                    .icon_theme_list
+                    .index_of(&self.icon_theme.name)
+                    .unwrap_or(0),
+                items: self.icon_theme_list.clone(),
+            }),
+            _ => None,
+        }
+    }
 }
 
 pub struct ConfigWatcher {
     event_sink: ExtEventSink,
+    delay_handler: Arc<AtomicBool>,
 }
 
 impl ConfigWatcher {
     pub fn new(event_sink: ExtEventSink) -> Self {
-        Self { event_sink }
+        Self {
+            event_sink,
+            delay_handler: Arc::new(AtomicBool::new(false)),
+        }
     }
 }
 
@@ -515,206 +1012,385 @@ impl notify::EventHandler for ConfigWatcher {
                 notify::EventKind::Create(_)
                 | notify::EventKind::Modify(_)
                 | notify::EventKind::Remove(_) => {
-                    let _ = self.event_sink.submit_command(
-                        LAPCE_UI_COMMAND,
-                        LapceUICommand::ReloadConfig,
-                        Target::Auto,
-                    );
+                    if self
+                        .delay_handler
+                        .compare_exchange(
+                            false,
+                            true,
+                            std::sync::atomic::Ordering::Relaxed,
+                            std::sync::atomic::Ordering::Relaxed,
+                        )
+                        .is_ok()
+                    {
+                        let config_mutex = self.delay_handler.clone();
+                        let event_sink = self.event_sink.clone();
+                        std::thread::spawn(move || {
+                            std::thread::sleep(std::time::Duration::from_millis(
+                                500,
+                            ));
+                            let _ = event_sink.submit_command(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::ReloadConfig,
+                                Target::Auto,
+                            );
+                            config_mutex
+                                .store(false, std::sync::atomic::Ordering::Relaxed);
+                        });
+                    }
                 }
-                _ => (),
+                _ => {}
             }
         }
     }
 }
 
-impl Config {
-    pub fn load(workspace: &LapceWorkspace) -> Result<Self> {
-        let default_settings = Self::default_settings();
-        let mut default_config: Config =
-            default_settings.clone().try_into().unwrap();
-        default_config.resolve_colors(None);
-
-        let settings =
-            Self::merge_settings(default_settings.clone(), workspace, None);
-        let mut config: Config = settings.try_into()?;
-        let available_themes = Self::load_themes();
-        if let Some((_, theme)) =
-            available_themes.get(&config.lapce.color_theme.to_lowercase())
+impl LapceConfig {
+    pub fn load(workspace: &LapceWorkspace, disabled_volts: &[VoltID]) -> Self {
+        let config = Self::merge_config(workspace, None, None);
+        let mut lapce_config: LapceConfig = config
+            .try_deserialize()
+            .unwrap_or_else(|_| DEFAULT_LAPCE_CONFIG.clone());
+
+        lapce_config.available_color_themes =
+            Self::load_color_themes(disabled_volts);
+        lapce_config.available_icon_themes = Self::load_icon_themes(disabled_volts);
+        lapce_config.resolve_theme(workspace);
+
+        lapce_config.color_theme_list = lapce_config
+            .available_color_themes
+            .values()
+            .map(|(name, _)| name.clone())
+            .collect();
+        lapce_config.color_theme_list.sort();
+
+        lapce_config.icon_theme_list = lapce_config
+            .available_icon_themes
+            .values()
+            .map(|(name, _, _)| name.clone())
+            .collect();
+        lapce_config.icon_theme_list.sort();
+
+        lapce_config
+    }
+
+    fn resolve_theme(&mut self, workspace: &LapceWorkspace) {
+        let mut default_lapce_config = DEFAULT_LAPCE_CONFIG.clone();
+        if let Some((_, color_theme_config)) = self
+            .available_color_themes
+            .get(&self.core.color_theme.to_lowercase())
         {
-            if let Ok(theme_settings) =
-                default_settings.clone().with_merged(theme.clone())
+            if let Ok(mut theme_lapce_config) = config::Config::builder()
+                .add_source(DEFAULT_CONFIG.clone())
+                .add_source(color_theme_config.clone())
+                .build()
+                .and_then(|theme| theme.try_deserialize::<LapceConfig>())
             {
-                if let Ok(mut theme_config) = theme_settings.try_into::<Config>() {
-                    theme_config.resolve_colors(Some(&default_config));
-                    default_config = theme_config;
-                }
+                theme_lapce_config.resolve_colors(Some(&default_lapce_config));
+                default_lapce_config = theme_lapce_config;
             }
-            config = Self::merge_settings(
-                default_settings,
+        }
+
+        let color_theme_config = self
+            .available_color_themes
+            .get(&self.core.color_theme.to_lowercase())
+            .map(|(_, config)| config);
+
+        let icon_theme_config = self
+            .available_icon_themes
+            .get(&self.core.icon_theme.to_lowercase())
+            .map(|(_, config, _)| config);
+
+        let icon_theme_path = self
+            .available_icon_themes
+            .get(&self.core.icon_theme.to_lowercase())
+            .map(|(_, _, path)| path);
+
+        if color_theme_config.is_some() || icon_theme_config.is_some() {
+            if let Ok(new) = Self::merge_config(
                 workspace,
-                Some(theme.clone()),
+                color_theme_config.cloned(),
+                icon_theme_config.cloned(),
             )
-            .try_into()?;
+            .try_deserialize::<LapceConfig>()
+            {
+                self.core = new.core;
+                self.ui = new.ui;
+                self.editor = new.editor;
+                self.terminal = new.terminal;
+                self.color_theme = new.color_theme;
+                self.icon_theme = new.icon_theme;
+                if let Some(icon_theme_path) = icon_theme_path {
+                    self.icon_theme.path =
+                        icon_theme_path.clone().unwrap_or_default();
+                }
+                self.plugins = new.plugins;
+            }
         }
-        config.update_id();
-        config.available_themes = available_themes;
-        config.resolve_colors(Some(&default_config));
-        config.default_theme = default_config.theme.clone();
-
-        Ok(config)
+        self.resolve_colors(Some(&default_lapce_config));
+        self.default_color_theme = default_lapce_config.color_theme.clone();
+        self.default_icon_theme = default_lapce_config.icon_theme.clone();
+        self.update_id();
     }
 
-    fn merge_settings(
-        mut settings: config::Config,
+    fn merge_config(
         workspace: &LapceWorkspace,
-        theme: Option<config::Config>,
+        color_theme_config: Option<config::Config>,
+        icon_theme_config: Option<config::Config>,
     ) -> config::Config {
-        if let Some(theme) = theme {
-            let _ = settings.merge(theme);
+        let mut config = DEFAULT_CONFIG.clone();
+        if let Some(theme) = color_theme_config {
+            config = config::Config::builder()
+                .add_source(config.clone())
+                .add_source(theme)
+                .build()
+                .unwrap_or_else(|_| config.clone());
+        }
+
+        if let Some(theme) = icon_theme_config {
+            config = config::Config::builder()
+                .add_source(config.clone())
+                .add_source(theme)
+                .build()
+                .unwrap_or_else(|_| config.clone());
         }
 
         if let Some(path) = Self::settings_file() {
-            let _ =
-                settings.merge(config::File::from(path.as_path()).required(false));
+            config = config::Config::builder()
+                .add_source(config.clone())
+                .add_source(config::File::from(path.as_path()).required(false))
+                .build()
+                .unwrap_or_else(|_| config.clone());
         }
 
         match workspace.kind {
             LapceWorkspaceType::Local => {
                 if let Some(path) = workspace.path.as_ref() {
                     let path = path.join("./.lapce/settings.toml");
-                    let _ = settings
-                        .merge(config::File::from(path.as_path()).required(false));
+                    config = config::Config::builder()
+                        .add_source(config.clone())
+                        .add_source(
+                            config::File::from(path.as_path()).required(false),
+                        )
+                        .build()
+                        .unwrap_or_else(|_| config.clone());
                 }
             }
-            LapceWorkspaceType::RemoteSSH(_, _) => {}
+            LapceWorkspaceType::RemoteSSH(_) => {}
+            #[cfg(windows)]
             LapceWorkspaceType::RemoteWSL => {}
         }
 
-        settings
+        config
     }
 
-    fn resolve_colors(&mut self, default_config: Option<&Config>) {
+    fn resolve_colors(&mut self, default_config: Option<&LapceConfig>) {
         self.color.base = self
-            .theme
+            .color_theme
             .base
             .resolve(default_config.map(|c| &c.color.base));
         self.color.ui = self
-            .theme
+            .color_theme
             .resolve_ui_color(&self.color.base, default_config.map(|c| &c.color.ui));
-        self.color.syntax = self.theme.resolve_syntax_color(
+        self.color.syntax = self.color_theme.resolve_syntax_color(
             &self.color.base,
             default_config.map(|c| &c.color.syntax),
         );
+
+        let fg = self
+            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+            .as_rgba();
+        let bg = self
+            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
+            .as_rgba();
+        let is_light = fg.0 + fg.1 + fg.2 > bg.0 + bg.1 + bg.2;
+        let high_contrast = self.color_theme.high_contrast.unwrap_or(false);
+        self.color.color_preference = match (is_light, high_contrast) {
+            (true, true) => ThemeColorPreference::HighContrastLight,
+            (false, true) => ThemeColorPreference::HighContrastDark,
+            (true, false) => ThemeColorPreference::Light,
+            (false, false) => ThemeColorPreference::Dark,
+        };
     }
 
-    fn load_themes() -> HashMap<String, (String, config::Config)> {
+    fn load_color_themes(
+        disabled_volts: &[VoltID],
+    ) -> HashMap<String, (String, config::Config)> {
         let mut themes = Self::load_local_themes().unwrap_or_default();
-        if let Some(plugin_themes) = Self::load_plugin_themes() {
-            for (key, theme) in plugin_themes.into_iter() {
-                themes.insert(key, theme);
-            }
+
+        for (key, theme) in Self::load_plugin_color_themes(disabled_volts) {
+            themes.insert(key, theme);
         }
 
-        let (name, theme) = Self::load_theme_from_str(DEFAULT_LIGHT_THEME).unwrap();
+        let (name, theme) =
+            Self::load_color_theme_from_str(DEFAULT_LIGHT_THEME).unwrap();
         themes.insert(name.to_lowercase(), (name, theme));
-        let (name, theme) = Self::load_theme_from_str(DEFAULT_DARK_THEME).unwrap();
+        let (name, theme) =
+            Self::load_color_theme_from_str(DEFAULT_DARK_THEME).unwrap();
         themes.insert(name.to_lowercase(), (name, theme));
 
         themes
     }
 
+    fn load_icon_themes(
+        disabled_volts: &[VoltID],
+    ) -> HashMap<String, (String, config::Config, Option<PathBuf>)> {
+        let mut themes = HashMap::new();
+
+        for (key, (name, theme, path)) in
+            Self::load_plugin_icon_themes(disabled_volts)
+        {
+            themes.insert(key, (name, theme, Some(path)));
+        }
+
+        let (name, theme) =
+            Self::load_icon_theme_from_str(DEFAULT_ICON_THEME).unwrap();
+        themes.insert(name.to_lowercase(), (name, theme, None));
+
+        themes
+    }
+
     fn load_local_themes() -> Option<HashMap<String, (String, config::Config)>> {
-        let themes_folder = Config::themes_folder()?;
+        let themes_folder = Directory::themes_directory()?;
         let themes: HashMap<String, (String, config::Config)> =
             std::fs::read_dir(themes_folder)
                 .ok()?
                 .filter_map(|entry| {
-                    entry.ok().and_then(|entry| Self::load_theme(&entry.path()))
+                    entry
+                        .ok()
+                        .and_then(|entry| Self::load_color_theme(&entry.path()))
                 })
                 .collect();
         Some(themes)
     }
 
-    fn load_plugin_themes() -> Option<HashMap<String, (String, config::Config)>> {
-        let mut catalog = PluginCatalog::new();
-        catalog.reload();
-
+    fn load_plugin_color_themes(
+        disabled_volts: &[VoltID],
+    ) -> HashMap<String, (String, config::Config)> {
         let mut themes: HashMap<String, (String, config::Config)> = HashMap::new();
+        for meta in find_all_volts() {
+            if disabled_volts.contains(&meta.id()) {
+                continue;
+            }
+            if let Some(plugin_themes) = meta.color_themes.as_ref() {
+                for theme_path in plugin_themes {
+                    if let Some((key, theme)) =
+                        Self::load_color_theme(&PathBuf::from(theme_path))
+                    {
+                        themes.insert(key, theme);
+                    }
+                }
+            }
+        }
+        themes
+    }
 
-        for (_, plugin) in catalog.items.iter() {
-            if let Some(plugin_themes) = plugin.themes.as_ref() {
+    fn load_plugin_icon_themes(
+        disabled_volts: &[VoltID],
+    ) -> HashMap<String, (String, config::Config, PathBuf)> {
+        let mut themes: HashMap<String, (String, config::Config, PathBuf)> =
+            HashMap::new();
+        for meta in find_all_volts() {
+            if disabled_volts.contains(&meta.id()) {
+                continue;
+            }
+            if let Some(plugin_themes) = meta.icon_themes.as_ref() {
                 for theme_path in plugin_themes {
                     if let Some((key, theme)) =
-                        Self::load_theme(&PathBuf::from(theme_path))
+                        Self::load_icon_theme(&PathBuf::from(theme_path))
                     {
                         themes.insert(key, theme);
                     }
                 }
             }
         }
-        Some(themes)
+        themes
+    }
+
+    fn load_color_theme_from_str(s: &str) -> Option<(String, config::Config)> {
+        let config = config::Config::builder()
+            .add_source(config::File::from_str(s, config::FileFormat::Toml))
+            .build()
+            .ok()?;
+        let table = config.get_table("color-theme").ok()?;
+        let name = table.get("name")?.to_string();
+        Some((name, config))
     }
 
-    fn load_theme_from_str(s: &str) -> Option<(String, config::Config)> {
-        let settings = config::Config::new()
-            .with_merged(config::File::from_str(s, config::FileFormat::Toml))
+    fn load_icon_theme_from_str(s: &str) -> Option<(String, config::Config)> {
+        let config = config::Config::builder()
+            .add_source(config::File::from_str(s, config::FileFormat::Toml))
+            .build()
             .ok()?;
-        let table = settings.get_table("theme").ok()?;
+        let table = config.get_table("icon-theme").ok()?;
         let name = table.get("name")?.to_string();
-        Some((name, settings))
+        Some((name, config))
     }
 
-    fn load_theme(path: &Path) -> Option<(String, (String, config::Config))> {
+    fn load_color_theme(path: &Path) -> Option<(String, (String, config::Config))> {
         if !path.is_file() {
             return None;
         }
-        let settings = config::Config::new()
-            .with_merged(config::File::from(path))
+        let config = config::Config::builder()
+            .add_source(config::File::from(path))
+            .build()
             .ok()?;
-        let table = settings.get_table("theme").ok()?;
+        let table = config.get_table("color-theme").ok()?;
         let name = table.get("name")?.to_string();
-        Some((name.to_lowercase(), (name, settings)))
+        Some((name.to_lowercase(), (name, config)))
     }
 
-    fn default_settings() -> config::Config {
-        config::Config::default()
-            .with_merged(config::File::from_str(
+    fn load_icon_theme(
+        path: &Path,
+    ) -> Option<(String, (String, config::Config, PathBuf))> {
+        if !path.is_file() {
+            return None;
+        }
+        let config = config::Config::builder()
+            .add_source(config::File::from(path))
+            .build()
+            .ok()?;
+        let table = config.get_table("icon-theme").ok()?;
+        let name = table.get("name")?.to_string();
+        Some((
+            name.to_lowercase(),
+            (name, config, path.parent().unwrap().to_path_buf()),
+        ))
+    }
+
+    fn default_config() -> config::Config {
+        config::Config::builder()
+            .add_source(config::File::from_str(
                 DEFAULT_SETTINGS,
                 config::FileFormat::Toml,
             ))
+            .build()
             .unwrap()
     }
 
+    fn default_lapce_config() -> LapceConfig {
+        let mut default_lapce_config: LapceConfig =
+            DEFAULT_CONFIG.clone().try_deserialize().unwrap();
+        default_lapce_config.resolve_colors(None);
+        default_lapce_config
+    }
+
     pub fn export_theme(&self) -> String {
         let mut table = toml::value::Table::new();
-        let mut theme = self.theme.clone();
+        let mut theme = self.color_theme.clone();
         theme.name = "".to_string();
         theme.syntax.sort_keys();
         theme.ui.sort_keys();
-        table.insert("theme".to_string(), toml::Value::try_from(&theme).unwrap());
+        table.insert(
+            "color-theme".to_string(),
+            toml::Value::try_from(&theme).unwrap(),
+        );
         table.insert("ui".to_string(), toml::Value::try_from(&self.ui).unwrap());
         let value = toml::Value::Table(table);
-        toml::to_string(&value).unwrap()
+        toml::to_string_pretty(&value).unwrap()
     }
 
-    pub fn dir() -> Option<PathBuf> {
-        ProjectDirs::from("", "", "Lapce").map(|d| PathBuf::from(d.config_dir()))
-    }
-
-    pub fn log_file() -> Option<PathBuf> {
-        let path = Self::dir().map(|d| {
-            d.join(if !cfg!(debug_assertions) {
-                "lapce.log"
-            } else {
-                "debug-lapce.log"
-            })
-        })?;
-
-        if let Some(dir) = path.parent() {
-            if !dir.exists() {
-                let _ = std::fs::create_dir_all(dir);
-            }
-        }
+    pub fn keymaps_file() -> Option<PathBuf> {
+        let path = Directory::config_directory()?.join("keymaps.toml");
 
         if !path.exists() {
             let _ = std::fs::OpenOptions::new()
@@ -726,20 +1402,12 @@ impl Config {
         Some(path)
     }
 
-    pub fn settings_file() -> Option<PathBuf> {
-        let path = Self::dir().map(|d| {
-            d.join(if !cfg!(debug_assertions) {
-                "settings.toml"
-            } else {
-                "debug-settings.toml"
-            })
-        })?;
+    pub fn log_file() -> Option<PathBuf> {
+        let time = chrono::Local::now().format("%Y%m%d-%H%M%S");
 
-        if let Some(dir) = path.parent() {
-            if !dir.exists() {
-                let _ = std::fs::create_dir_all(dir);
-            }
-        }
+        let file_name = format!("{time}.log");
+
+        let path = Directory::logs_directory()?.join(file_name);
 
         if !path.exists() {
             let _ = std::fs::OpenOptions::new()
@@ -751,41 +1419,37 @@ impl Config {
         Some(path)
     }
 
-    /// Get the path to the themes folder
-    /// Themes are stored within as individual toml files
-    pub fn themes_folder() -> Option<PathBuf> {
-        let path = Self::dir()?.join("themes");
-
-        if let Some(dir) = path.parent() {
-            if !dir.exists() {
-                let _ = std::fs::create_dir_all(dir);
-            }
-        }
+    pub fn settings_file() -> Option<PathBuf> {
+        let path = Directory::config_directory()?.join("settings.toml");
 
         if !path.exists() {
-            let _ = std::fs::create_dir(&path);
+            let _ = std::fs::OpenOptions::new()
+                .create_new(true)
+                .write(true)
+                .open(&path);
         }
 
         Some(path)
     }
 
-    fn get_file_table() -> Option<toml::value::Table> {
+    fn get_file_table() -> Option<toml_edit::Document> {
         let path = Self::settings_file()?;
-        let content = std::fs::read(&path).ok()?;
-        let toml_value: toml::Value = toml::from_slice(&content).ok()?;
-        let table = toml_value.as_table()?.clone();
-        Some(table)
+        let content = std::fs::read_to_string(path).ok()?;
+        let document: toml_edit::Document = content.parse().ok()?;
+        Some(document)
     }
 
     pub fn reset_setting(parent: &str, key: &str) -> Option<()> {
         let mut main_table = Self::get_file_table().unwrap_or_default();
 
         // Find the container table
-        let mut table = &mut main_table;
+        let mut table = main_table.as_table_mut();
         for key in parent.split('.') {
             if !table.contains_key(key) {
-                table
-                    .insert(key.to_string(), toml::Value::Table(Default::default()));
+                table.insert(
+                    key,
+                    toml_edit::Item::Table(toml_edit::Table::default()),
+                );
             }
             table = table.get_mut(key)?.as_table_mut()?;
         }
@@ -794,30 +1458,36 @@ impl Config {
 
         // Store
         let path = Self::settings_file()?;
-        std::fs::write(&path, toml::to_string(&main_table).ok()?.as_bytes()).ok()?;
+        std::fs::write(path, main_table.to_string().as_bytes()).ok()?;
 
         Some(())
     }
 
-    pub fn update_file(parent: &str, key: &str, value: toml::Value) -> Option<()> {
+    pub fn update_file(
+        parent: &str,
+        key: &str,
+        value: toml_edit::Value,
+    ) -> Option<()> {
         let mut main_table = Self::get_file_table().unwrap_or_default();
 
         // Find the container table
-        let mut table = &mut main_table;
+        let mut table = main_table.as_table_mut();
         for key in parent.split('.') {
             if !table.contains_key(key) {
-                table
-                    .insert(key.to_string(), toml::Value::Table(Default::default()));
+                table.insert(
+                    key,
+                    toml_edit::Item::Table(toml_edit::Table::default()),
+                );
             }
             table = table.get_mut(key)?.as_table_mut()?;
         }
 
         // Update key
-        table.insert(key.to_string(), value);
+        table.insert(key, toml_edit::Item::Value(value));
 
         // Store
         let path = Self::settings_file()?;
-        std::fs::write(&path, toml::to_string(&main_table).ok()?.as_bytes()).ok()?;
+        std::fs::write(path, main_table.to_string().as_bytes()).ok()?;
 
         Some(())
     }
@@ -825,27 +1495,42 @@ impl Config {
     fn update_id(&mut self) {
         self.id = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
-            .map(|d| d.as_secs())
+            .map(|d| d.as_millis() as u64)
             .unwrap_or(0);
     }
 
-    pub fn set_theme(&mut self, theme: &str, preview: bool) -> bool {
-        self.update_id();
-
-        self.lapce.color_theme = theme.to_string();
-
-        if !preview
-            && Config::update_file(
-                "lapce",
+    pub fn set_color_theme(
+        &mut self,
+        workspace: &LapceWorkspace,
+        theme: &str,
+        preview: bool,
+    ) {
+        self.core.color_theme = theme.to_string();
+        self.resolve_theme(workspace);
+        if !preview {
+            LapceConfig::update_file(
+                "core",
                 "color-theme",
-                toml::Value::String(theme.to_string()),
-            )
-            .is_none()
-        {
-            return false;
+                toml_edit::Value::from(theme),
+            );
         }
+    }
 
-        true
+    pub fn set_icon_theme(
+        &mut self,
+        workspace: &LapceWorkspace,
+        theme: &str,
+        preview: bool,
+    ) {
+        self.core.icon_theme = theme.to_string();
+        self.resolve_theme(workspace);
+        if !preview {
+            LapceConfig::update_file(
+                "core",
+                "icon-theme",
+                toml_edit::Value::from(theme),
+            );
+        }
     }
 
     /// Get the color by the name from the current theme if it exists
@@ -860,6 +1545,27 @@ impl Config {
             .unwrap_or_else(|| panic!("Key not found: {name}"))
     }
 
+    pub fn get_hover_color(&self, color: &Color) -> Color {
+        let (r, g, b, a) = color.as_rgba();
+        let shift = 0.05;
+        match self.color.color_preference {
+            ThemeColorPreference::Dark => {
+                Color::rgba(r + -shift, g + -shift, b + -shift, a)
+            }
+            ThemeColorPreference::Light => {
+                Color::rgba(r + shift, g + shift, b + shift, a)
+            }
+            ThemeColorPreference::HighContrastDark => {
+                let shift = shift * 2.0;
+                Color::rgba(r + -shift, g + -shift, b + -shift, a)
+            }
+            ThemeColorPreference::HighContrastLight => {
+                let shift = shift * 2.0;
+                Color::rgba(r + shift, g + shift, b + shift, a)
+            }
+        }
+    }
+
     /// Retrieve a color value whose key starts with "style."
     pub fn get_style_color(&self, name: &str) -> Option<&Color> {
         self.color.syntax.get(name)
@@ -867,14 +1573,13 @@ impl Config {
 
     /// Calculate the width of the character "W" (being the widest character)
     /// in the editor's current font family at the specified font size.
-    pub fn char_width(&self, text: &mut PietText, font_size: f64) -> f64 {
-        Self::editor_text_size_internal(
-            self.editor.font_family(),
-            font_size,
-            text,
-            "W",
-        )
-        .width
+    pub fn char_width(
+        &self,
+        text: &mut PietText,
+        font_size: f64,
+        font_family: FontFamily,
+    ) -> f64 {
+        Self::text_size_internal(font_family, font_size, text, "W").width
     }
 
     pub fn terminal_font_family(&self) -> FontFamily {
@@ -897,14 +1602,18 @@ impl Config {
         if self.terminal.line_height > 0 {
             self.terminal.line_height
         } else {
-            self.editor.line_height
+            self.editor.line_height()
         }
     }
 
     /// Calculate the width of the character "W" (being the widest character)
     /// in the editor's current font family and current font size.
     pub fn editor_char_width(&self, text: &mut PietText) -> f64 {
-        self.char_width(text, self.editor.font_size as f64)
+        self.char_width(
+            text,
+            self.editor.font_size as f64,
+            self.editor.font_family(),
+        )
     }
 
     /// Calculate the width of `text_to_measure` in the editor's current font family and font size.
@@ -913,7 +1622,7 @@ impl Config {
         text: &mut PietText,
         text_to_measure: &str,
     ) -> f64 {
-        Self::editor_text_size_internal(
+        Self::text_size_internal(
             self.editor.font_family(),
             self.editor.font_size as f64,
             text,
@@ -928,7 +1637,7 @@ impl Config {
         text: &mut PietText,
         text_to_measure: &str,
     ) -> Size {
-        Self::editor_text_size_internal(
+        Self::text_size_internal(
             self.editor.font_family(),
             self.editor.font_size as f64,
             text,
@@ -936,9 +1645,48 @@ impl Config {
         )
     }
 
+    /// Calculate the width of the character "W" (being the widest character)
+    /// in the editor's current font family and current font size.
+    pub fn terminal_char_width(&self, text: &mut PietText) -> f64 {
+        self.char_width(
+            text,
+            self.terminal_font_size() as f64,
+            self.terminal_font_family(),
+        )
+    }
+
+    /// Calculate the width of `text_to_measure` in the editor's current font family and font size.
+    pub fn terminal_text_width(
+        &self,
+        text: &mut PietText,
+        text_to_measure: &str,
+    ) -> f64 {
+        Self::text_size_internal(
+            self.terminal_font_family(),
+            self.terminal_font_size() as f64,
+            text,
+            text_to_measure,
+        )
+        .width
+    }
+
+    /// Calculate the size of `text_to_measure` in the terminal's current font family and font size.
+    pub fn terminal_text_size(
+        &self,
+        text: &mut PietText,
+        text_to_measure: &str,
+    ) -> Size {
+        Self::text_size_internal(
+            self.terminal_font_family(),
+            self.terminal_font_size() as f64,
+            text,
+            text_to_measure,
+        )
+    }
+
     /// Efficiently calculate the size of a piece of text, without allocating.
     /// This function should not be made public, use one of the public wrapper functions instead.
-    fn editor_text_size_internal(
+    fn text_size_internal(
         font_family: FontFamily,
         font_size: f64,
         text: &mut PietText,
@@ -975,96 +1723,6 @@ impl Config {
         text_layout.size()
     }
 
-    pub fn update_recent_workspaces(workspaces: Vec<LapceWorkspace>) -> Option<()> {
-        let path = Self::recent_workspaces_file()?;
-        let mut array = toml::value::Array::new();
-        for workspace in workspaces {
-            if let Some(path) = workspace.path.as_ref() {
-                let mut table = toml::value::Table::new();
-                table.insert(
-                    "kind".to_string(),
-                    toml::Value::String(match workspace.kind {
-                        LapceWorkspaceType::Local => "local".to_string(),
-                        LapceWorkspaceType::RemoteSSH(user, host) => {
-                            format!("ssh://{}@{}", user, host)
-                        }
-                        LapceWorkspaceType::RemoteWSL => "wsl".to_string(),
-                    }),
-                );
-                table.insert(
-                    "path".to_string(),
-                    toml::Value::String(path.to_str()?.to_string()),
-                );
-                table.insert(
-                    "last_open".to_string(),
-                    toml::Value::Integer(workspace.last_open as i64),
-                );
-                array.push(toml::Value::Table(table));
-            }
-        }
-        let mut table = toml::value::Table::new();
-        table.insert("workspaces".to_string(), toml::Value::Array(array));
-        let content = toml::to_string(&table).ok()?;
-
-        let mut file = std::fs::OpenOptions::new()
-            .write(true)
-            .truncate(true)
-            .open(&path)
-            .ok()?;
-        file.write_all(content.as_bytes()).ok()?;
-        None
-    }
-
-    pub fn recent_workspaces() -> Option<Vec<LapceWorkspace>> {
-        let path = Self::recent_workspaces_file()?;
-        let content = std::fs::read_to_string(&path).ok()?;
-        let value: toml::Value = toml::from_str(&content).ok()?;
-        Some(
-            value
-                .get("workspaces")
-                .and_then(|v| v.as_array())?
-                .iter()
-                .filter_map(|value| {
-                    let path = PathBuf::from(value.get("path")?.as_str()?);
-                    let kind = value.get("kind")?.as_str()?;
-                    let kind = match kind {
-                        s if kind.starts_with("ssh://") => {
-                            let mut parts = s[6..].split('@');
-                            let user = parts.next()?.to_string();
-                            let host = parts.next()?.to_string();
-                            LapceWorkspaceType::RemoteSSH(user, host)
-                        }
-                        "wsl" => LapceWorkspaceType::RemoteWSL,
-                        _ => LapceWorkspaceType::Local,
-                    };
-                    let last_open = value
-                        .get("last_open")
-                        .and_then(|v| v.as_integer())
-                        .unwrap_or(0) as u64;
-                    let workspace = LapceWorkspace {
-                        kind,
-                        path: Some(path),
-                        last_open,
-                    };
-                    Some(workspace)
-                })
-                .collect(),
-        )
-    }
-
-    pub fn recent_workspaces_file() -> Option<PathBuf> {
-        let proj_dirs = ProjectDirs::from("", "", "Lapce")?;
-        let _ = std::fs::create_dir_all(proj_dirs.config_dir());
-        let path = proj_dirs.config_dir().join("workspaces.toml");
-        {
-            let _ = std::fs::OpenOptions::new()
-                .create_new(true)
-                .write(true)
-                .open(&path);
-        }
-        Some(path)
-    }
-
     pub fn tab_width(
         &self,
         text: &mut PietText,
@@ -1092,4 +1750,149 @@ impl Config {
             .insert((font_family, font_size), width);
         self.editor.tab_width as f64 * width
     }
+
+    pub fn logo_svg(&self) -> Svg {
+        self.svg_store.read().logo_svg()
+    }
+
+    pub fn ui_svg(&self, icon: &'static str) -> Svg {
+        let svg = self.icon_theme.ui.get(icon).and_then(|path| {
+            let path = self.icon_theme.path.join(path);
+            self.svg_store.write().get_svg_on_disk(&path)
+        });
+
+        svg.unwrap_or_else(|| {
+            let name = self.default_icon_theme.ui.get(icon).unwrap();
+            self.svg_store.write().get_default_svg(name)
+        })
+    }
+
+    pub fn folder_svg(&self, path: &Path) -> Option<(Svg, Option<&Color>)> {
+        self.icon_theme
+            .foldername
+            .get_key_value(
+                path.file_name()
+                    .unwrap_or_default()
+                    .to_str()
+                    .unwrap_or_default(),
+            )
+            .and_then(|(_, path)| {
+                let path = self.icon_theme.path.join(path);
+                self.svg_store.write().get_svg_on_disk(&path)
+            })
+            .map(|svg| {
+                let color = if self.icon_theme.use_editor_color.unwrap_or(false) {
+                    Some(self.get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE))
+                } else {
+                    None
+                };
+                (svg, color)
+            })
+    }
+
+    pub fn file_svg(&self, path: &Path) -> (Svg, Option<&Color>) {
+        let svg = self
+            .icon_theme
+            .resolve_path_to_icon(path)
+            .and_then(|p| self.svg_store.write().get_svg_on_disk(&p));
+        if let Some(svg) = svg {
+            let color = if self.icon_theme.use_editor_color.unwrap_or(false) {
+                Some(self.get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE))
+            } else {
+                None
+            };
+            (svg, color)
+        } else {
+            (
+                self.ui_svg(LapceIcons::FILE),
+                Some(self.get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)),
+            )
+        }
+    }
+
+    pub fn symbol_svg(&self, kind: &SymbolKind) -> Option<Svg> {
+        let kind_str = match *kind {
+            SymbolKind::ARRAY => LapceIcons::SYMBOL_KIND_ARRAY,
+            SymbolKind::BOOLEAN => LapceIcons::SYMBOL_KIND_BOOLEAN,
+            SymbolKind::CLASS => LapceIcons::SYMBOL_KIND_CLASS,
+            SymbolKind::CONSTANT => LapceIcons::SYMBOL_KIND_CONSTANT,
+            SymbolKind::ENUM_MEMBER => LapceIcons::SYMBOL_KIND_ENUM_MEMBER,
+            SymbolKind::ENUM => LapceIcons::SYMBOL_KIND_ENUM,
+            SymbolKind::EVENT => LapceIcons::SYMBOL_KIND_EVENT,
+            SymbolKind::FIELD => LapceIcons::SYMBOL_KIND_FIELD,
+            SymbolKind::FILE => LapceIcons::SYMBOL_KIND_FILE,
+            SymbolKind::INTERFACE => LapceIcons::SYMBOL_KIND_INTERFACE,
+            SymbolKind::KEY => LapceIcons::SYMBOL_KIND_KEY,
+            SymbolKind::FUNCTION => LapceIcons::SYMBOL_KIND_FUNCTION,
+            SymbolKind::METHOD => LapceIcons::SYMBOL_KIND_METHOD,
+            SymbolKind::OBJECT => LapceIcons::SYMBOL_KIND_OBJECT,
+            SymbolKind::NAMESPACE => LapceIcons::SYMBOL_KIND_NAMESPACE,
+            SymbolKind::NUMBER => LapceIcons::SYMBOL_KIND_NUMBER,
+            SymbolKind::OPERATOR => LapceIcons::SYMBOL_KIND_OPERATOR,
+            SymbolKind::TYPE_PARAMETER => LapceIcons::SYMBOL_KIND_TYPE_PARAMETER,
+            SymbolKind::PROPERTY => LapceIcons::SYMBOL_KIND_PROPERTY,
+            SymbolKind::STRING => LapceIcons::SYMBOL_KIND_STRING,
+            SymbolKind::STRUCT => LapceIcons::SYMBOL_KIND_STRUCT,
+            SymbolKind::VARIABLE => LapceIcons::SYMBOL_KIND_VARIABLE,
+            _ => return None,
+        };
+
+        Some(self.ui_svg(kind_str))
+    }
+
+    pub fn completion_svg(
+        &self,
+        kind: Option<CompletionItemKind>,
+    ) -> Option<(Svg, Option<Color>)> {
+        let kind = kind?;
+        let kind_str = match kind {
+            CompletionItemKind::METHOD => LapceIcons::COMPLETION_ITEM_KIND_METHOD,
+            CompletionItemKind::FUNCTION => {
+                LapceIcons::COMPLETION_ITEM_KIND_FUNCTION
+            }
+            CompletionItemKind::ENUM => LapceIcons::COMPLETION_ITEM_KIND_ENUM,
+            CompletionItemKind::ENUM_MEMBER => {
+                LapceIcons::COMPLETION_ITEM_KIND_ENUM_MEMBER
+            }
+            CompletionItemKind::CLASS => LapceIcons::COMPLETION_ITEM_KIND_CLASS,
+            CompletionItemKind::VARIABLE => LapceIcons::SYMBOL_KIND_VARIABLE,
+            CompletionItemKind::STRUCT => LapceIcons::SYMBOL_KIND_STRUCT,
+            CompletionItemKind::KEYWORD => LapceIcons::COMPLETION_ITEM_KIND_KEYWORD,
+            CompletionItemKind::CONSTANT => {
+                LapceIcons::COMPLETION_ITEM_KIND_CONSTANT
+            }
+            CompletionItemKind::PROPERTY => {
+                LapceIcons::COMPLETION_ITEM_KIND_PROPERTY
+            }
+            CompletionItemKind::FIELD => LapceIcons::COMPLETION_ITEM_KIND_FIELD,
+            CompletionItemKind::INTERFACE => {
+                LapceIcons::COMPLETION_ITEM_KIND_INTERFACE
+            }
+            CompletionItemKind::SNIPPET => LapceIcons::COMPLETION_ITEM_KIND_SNIPPET,
+            CompletionItemKind::MODULE => LapceIcons::COMPLETION_ITEM_KIND_MODULE,
+            _ => LapceIcons::COMPLETION_ITEM_KIND_STRING,
+        };
+        let theme_str = match kind {
+            CompletionItemKind::METHOD => "method",
+            CompletionItemKind::FUNCTION => "method",
+            CompletionItemKind::ENUM => "enum",
+            CompletionItemKind::ENUM_MEMBER => "enum-member",
+            CompletionItemKind::CLASS => "class",
+            CompletionItemKind::VARIABLE => "field",
+            CompletionItemKind::STRUCT => "structure",
+            CompletionItemKind::KEYWORD => "keyword",
+            CompletionItemKind::CONSTANT => "constant",
+            CompletionItemKind::PROPERTY => "property",
+            CompletionItemKind::FIELD => "field",
+            CompletionItemKind::INTERFACE => "interface",
+            CompletionItemKind::SNIPPET => "snippet",
+            CompletionItemKind::MODULE => "builtinType",
+            _ => "string",
+        };
+
+        Some((
+            self.ui_svg(kind_str),
+            self.get_style_color(theme_str).cloned(),
+        ))
+    }
 }
diff --git a/lapce-data/src/data.rs b/lapce-data/src/data.rs
index b1d3491fc6..47d59c1a1d 100644
--- a/lapce-data/src/data.rs
+++ b/lapce-data/src/data.rs
@@ -1,6 +1,10 @@
 use std::{
     cell::RefCell,
-    collections::HashMap,
+    cmp::Ordering,
+    collections::{HashMap, HashSet},
+    env,
+    fmt::Display,
+    io::{BufReader, Read, Write},
     path::{Path, PathBuf},
     rc::Rc,
     sync::Arc,
@@ -8,64 +12,78 @@ use std::{
     time::Instant,
 };
 
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use crossbeam_channel::{unbounded, Receiver, Sender};
-use directories::BaseDirs;
 use druid::{
     piet::PietText, theme, Command, Data, Env, EventCtx, ExtEventSink,
     FileDialogOptions, Lens, Point, Rect, Size, Target, Vec2, WidgetId, WindowId,
 };
-
+use im::Vector;
+use itertools::Itertools;
 use lapce_core::{
     command::{FocusCommand, MultiSelectionCommand},
     cursor::{Cursor, CursorMode},
+    directory::Directory,
     editor::EditType,
-    language::LapceLanguage,
-    mode::MotionMode,
+    meta,
+    mode::{Mode, MotionMode},
     movement::Movement,
     register::Register,
     selection::Selection,
 };
 use lapce_rpc::{
-    buffer::BufferId, plugin::PluginDescription, source_control::FileDiff,
+    buffer::BufferId,
+    core::{CoreMessage, CoreNotification},
+    plugin::{VoltID, VoltInfo},
+    proxy::ProxyResponse,
+    source_control::FileDiff,
     terminal::TermId,
+    RpcMessage,
 };
-use lsp_types::{Diagnostic, Position, ProgressToken, TextEdit};
+use lapce_xi_rope::{Rope, RopeDelta};
+use lsp_types::{Diagnostic, DiagnosticSeverity, Position, ProgressToken, TextEdit};
 use notify::Watcher;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use xi_rope::{Rope, RopeDelta, Transformer};
 
 use crate::{
+    about::AboutData,
     alert::{AlertContentData, AlertData},
     command::{
-        CommandKind, EnsureVisiblePosition, LapceCommand, LapceUICommand,
-        LapceWorkbenchCommand, LAPCE_COMMAND, LAPCE_OPEN_FILE, LAPCE_OPEN_FOLDER,
-        LAPCE_UI_COMMAND,
+        CommandKind, EnsureVisiblePosition, InitBufferContentCb, LapceCommand,
+        LapceUICommand, LapceWorkbenchCommand, LAPCE_COMMAND, LAPCE_OPEN_FILE,
+        LAPCE_OPEN_FOLDER, LAPCE_UI_COMMAND,
     },
     completion::CompletionData,
-    config::{Config, ConfigWatcher, GetConfig, LapceTheme},
+    config::{ConfigWatcher, GetConfig, LapceConfig, LapceTheme},
     db::{
         EditorInfo, EditorTabChildInfo, EditorTabInfo, LapceDb, SplitContentInfo,
         SplitInfo, TabsInfo, WindowInfo, WorkspaceInfo,
     },
     document::{BufferContent, Document, LocalBufferKind},
-    editor::{EditorLocation, LapceEditorBufferData, TabRect},
+    editor::{EditorLocation, EditorPosition, LapceEditorBufferData, Line, TabRect},
     explorer::FileExplorerData,
     find::Find,
     hover::HoverData,
+    images::ImageCache,
     keypress::KeyPressData,
     palette::{PaletteData, PaletteType, PaletteViewData},
-    panel::PanelPosition,
+    panel::{
+        PanelContainerPosition, PanelData, PanelKind, PanelOrder, PanelPosition,
+    },
     picker::FilePickerData,
     plugin::PluginData,
     problem::ProblemData,
     proxy::{LapceProxy, ProxyStatus, TermEvent},
+    rename::RenameData,
     search::SearchData,
     settings::LapceSettingsPanelData,
+    signature::SignatureData,
     source_control::SourceControlData,
     split::{SplitDirection, SplitMoveDirection},
-    terminal::TerminalSplitData,
+    terminal::TerminalPanelData,
+    title::TitleData,
+    update::ReleaseInfo,
 };
 
 /// `LapceData` is the topmost structure in a tree of structures that holds
@@ -82,41 +100,127 @@ pub struct LapceData {
     pub keypress: Arc<KeyPressData>,
     /// The persistent state of the program, such as recent workspaces.
     pub db: Arc<LapceDb>,
+    /// The order of panels in each postion
+    pub panel_orders: PanelOrder,
+    /// The latest release information
+    pub latest_release: Arc<Option<ReleaseInfo>>,
+    /// whether the update is in progress
+    pub update_in_process: bool,
+    /// log file path
+    #[data(ignore)]
+    pub log_file: Arc<Option<PathBuf>>,
+    /// The window on focus
+    pub active_window: Arc<WindowId>,
 }
 
 impl LapceData {
     /// Create a new `LapceData` struct by loading configuration, and state
     /// previously written to the Lapce database.
-    pub fn load(event_sink: ExtEventSink) -> Self {
+    pub fn load(
+        event_sink: ExtEventSink,
+        paths: Vec<PathBuf>,
+        log_file: Option<PathBuf>,
+    ) -> Self {
+        let _ = lapce_proxy::register_lapce_path();
+
+        let log_file = Arc::new(log_file);
         let db = Arc::new(LapceDb::new().unwrap());
         let mut windows = im::HashMap::new();
-        let config = Config::load(&LapceWorkspace::default()).unwrap_or_default();
+        let config = LapceConfig::load(&LapceWorkspace::default(), &[]);
         let keypress = Arc::new(KeyPressData::new(&config, event_sink.clone()));
-
-        if let Ok(app) = db.get_app() {
-            for info in app.windows.iter() {
+        let panel_orders = db
+            .get_panel_orders()
+            .unwrap_or_else(|_| Self::default_panel_orders());
+        let latest_release = Arc::new(None);
+
+        let dirs: Vec<&PathBuf> = paths.iter().filter(|p| p.is_dir()).collect();
+        let files: Vec<&PathBuf> = paths.iter().filter(|p| p.is_file()).collect();
+        if !dirs.is_empty() {
+            let (size, mut pos) = db
+                .get_last_window_info()
+                .map(|i| (i.size, i.pos))
+                .unwrap_or_else(|_| (Size::new(800.0, 600.0), Point::new(0.0, 0.0)));
+            for dir in dirs {
+                #[cfg(windows)]
+                let workspace_type =
+                    if !env::var("WSL_DISTRO_NAME").unwrap_or_default().is_empty()
+                        || !env::var("WSL_INTEROP").unwrap_or_default().is_empty()
+                    {
+                        LapceWorkspaceType::RemoteWSL
+                    } else {
+                        LapceWorkspaceType::Local
+                    };
+
+                #[cfg(not(windows))]
+                let workspace_type = LapceWorkspaceType::Local;
+
+                let info = WindowInfo {
+                    size,
+                    pos,
+                    maximised: false,
+                    tabs: TabsInfo {
+                        active_tab: 0,
+                        workspaces: vec![LapceWorkspace {
+                            kind: workspace_type,
+                            path: Some(dir.to_path_buf()),
+                            last_open: 0,
+                        }],
+                    },
+                };
+                pos += (50.0, 50.0);
                 let window = LapceWindowData::new(
                     keypress.clone(),
+                    latest_release.clone(),
+                    false,
+                    log_file.clone(),
+                    None,
+                    panel_orders.clone(),
                     event_sink.clone(),
-                    info,
+                    &info,
                     db.clone(),
                 );
                 windows.insert(window.window_id, window);
             }
+        } else if files.is_empty() {
+            if let Ok(app) = db.get_app() {
+                for info in app.windows.iter() {
+                    let window = LapceWindowData::new(
+                        keypress.clone(),
+                        latest_release.clone(),
+                        false,
+                        log_file.clone(),
+                        None,
+                        panel_orders.clone(),
+                        event_sink.clone(),
+                        info,
+                        db.clone(),
+                    );
+                    windows.insert(window.window_id, window);
+                }
+            }
         }
 
         if windows.is_empty() {
-            let info = db.get_last_window_info().unwrap_or_else(|_| WindowInfo {
-                size: Size::new(800.0, 600.0),
-                pos: Point::new(0.0, 0.0),
+            let (size, pos) = db
+                .get_last_window_info()
+                .map(|i| (i.size, i.pos))
+                .unwrap_or_else(|_| (Size::new(800.0, 600.0), Point::new(0.0, 0.0)));
+            let info = WindowInfo {
+                size,
+                pos,
                 maximised: false,
                 tabs: TabsInfo {
                     active_tab: 0,
                     workspaces: vec![],
                 },
-            });
+            };
             let window = LapceWindowData::new(
                 keypress.clone(),
+                latest_release.clone(),
+                false,
+                log_file.clone(),
+                None,
+                panel_orders.clone(),
                 event_sink.clone(),
                 &info,
                 db.clone(),
@@ -124,51 +228,165 @@ impl LapceData {
             windows.insert(window.window_id, window);
         }
 
-        thread::spawn(move || {
-            if let Ok(plugins) = LapceData::load_plugin_descriptions() {
+        if let Some((window_id, _)) = windows.iter().next() {
+            for file in files {
                 let _ = event_sink.submit_command(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::UpdatePluginDescriptions(plugins),
-                    Target::Auto,
+                    LapceUICommand::OpenFile(file.to_path_buf(), false),
+                    Target::Window(*window_id),
                 );
             }
+        }
+
+        #[cfg(feature = "updater")]
+        {
+            let local_event_sink = event_sink.clone();
+            std::thread::spawn(move || loop {
+                if let Ok(release) = crate::update::get_latest_release() {
+                    let _ = local_event_sink.submit_command(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::UpdateLatestRelease(release),
+                        Target::Global,
+                    );
+                }
+                std::thread::sleep(std::time::Duration::from_secs(60 * 60));
+            });
+        }
+
+        std::thread::spawn(move || {
+            let _ = Self::listen_local_socket(event_sink);
         });
+
         Self {
+            active_window: Arc::new(
+                windows
+                    .iter()
+                    .next()
+                    .map(|(w, _)| *w)
+                    .unwrap_or_else(WindowId::next),
+            ),
+
             windows,
             keypress,
             db,
+            panel_orders,
+            latest_release,
+            update_in_process: false,
+            log_file,
         }
     }
 
+    pub fn default_panel_orders() -> PanelOrder {
+        let mut order = PanelOrder::new();
+        order.insert(
+            PanelPosition::LeftTop,
+            im::vector![
+                PanelKind::FileExplorer,
+                PanelKind::SourceControl,
+                PanelKind::Plugin,
+            ],
+        );
+        order.insert(
+            PanelPosition::BottomLeft,
+            im::vector![PanelKind::Terminal, PanelKind::Search, PanelKind::Problem,],
+        );
+
+        order
+    }
+
     pub fn reload_env(&self, env: &mut Env) {
         env.set(theme::SCROLLBAR_WIDTH, 10.0);
         env.set(theme::SCROLLBAR_EDGE_WIDTH, 0.0);
         env.set(theme::SCROLLBAR_PAD, 0.0);
         env.set(theme::SCROLLBAR_MAX_OPACITY, 0.7);
+        env.set(LapceTheme::PALETTE_INPUT_LINE_HEIGHT, 18.0);
+        env.set(LapceTheme::PALETTE_INPUT_LINE_PADDING, 4.0);
         env.set(LapceTheme::INPUT_LINE_HEIGHT, 20.0);
         env.set(LapceTheme::INPUT_LINE_PADDING, 5.0);
         env.set(LapceTheme::INPUT_FONT_SIZE, 13u64);
     }
 
-    fn load_plugin_descriptions() -> Result<Vec<PluginDescription>> {
-        let plugins: Vec<String> =
-            reqwest::blocking::get("https://lapce.github.io/plugins.json")?
-                .json()?;
-        let plugins: Vec<PluginDescription> = plugins
-            .iter()
-            .filter_map(|plugin| LapceData::load_plugin_description(plugin).ok())
-            .collect();
-        Ok(plugins)
+    fn listen_local_socket(event_sink: ExtEventSink) -> Result<()> {
+        let local_socket = Directory::local_socket()
+            .ok_or_else(|| anyhow!("can't get local socket folder"))?;
+        let _ = std::fs::remove_file(&local_socket);
+        let socket =
+            interprocess::local_socket::LocalSocketListener::bind(local_socket)?;
+
+        for stream in socket.incoming().flatten() {
+            let event_sink = event_sink.clone();
+            thread::spawn(move || -> Result<()> {
+                let mut reader = BufReader::new(stream);
+                loop {
+                    let msg: CoreMessage = lapce_rpc::stdio::read_msg(&mut reader)?;
+
+                    if let RpcMessage::Notification(CoreNotification::OpenPaths {
+                        window_tab_id,
+                        folders,
+                        files,
+                    }) = msg
+                    {
+                        let window_tab_id =
+                            window_tab_id.map(|(window_id, tab_id)| {
+                                (
+                                    WindowId::from_usize(window_id),
+                                    WidgetId::from_usize(tab_id),
+                                )
+                            });
+                        let _ = event_sink.submit_command(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::OpenPaths {
+                                window_tab_id,
+                                folders,
+                                files,
+                            },
+                            Target::Global,
+                        );
+                    } else {
+                        log::trace!("Unhandled message: {msg:?}");
+                    }
+
+                    let stream_ref = reader.get_mut();
+                    let _ = stream_ref.write_all(b"received");
+                    let _ = stream_ref.flush();
+                }
+            });
+        }
+        Ok(())
     }
 
-    fn load_plugin_description(plugin: &str) -> Result<PluginDescription> {
-        let url = format!(
-            "https://raw.githubusercontent.com/{}/master/plugin.toml",
-            plugin
-        );
-        let content = reqwest::blocking::get(url)?.text()?;
-        let plugin: PluginDescription = toml::from_str(&content)?;
-        Ok(plugin)
+    pub fn try_open_in_existing_process(paths: &[PathBuf]) -> Result<()> {
+        let local_socket = Directory::local_socket()
+            .ok_or_else(|| anyhow!("can't get local socket folder"))?;
+        let mut socket =
+            interprocess::local_socket::LocalSocketStream::connect(local_socket)?;
+        let folders: Vec<_> = paths.iter().filter(|p| p.is_dir()).cloned().collect();
+        let files: Vec<_> = paths.iter().filter(|p| p.is_file()).cloned().collect();
+        let msg: CoreMessage =
+            RpcMessage::Notification(CoreNotification::OpenPaths {
+                window_tab_id: None,
+                folders,
+                files,
+            });
+        lapce_rpc::stdio::write_msg(&mut socket, msg)?;
+
+        let (tx, rx) = crossbeam_channel::bounded(1);
+        thread::spawn(move || {
+            let mut buf = [0; 100];
+            let received = if let Ok(n) = socket.read(&mut buf) {
+                &buf[..n] == b"received"
+            } else {
+                false
+            };
+            tx.send(received)
+        });
+
+        let received = rx.recv_timeout(std::time::Duration::from_millis(500))?;
+        if !received {
+            return Err(anyhow!("didn't receive response"));
+        }
+
+        Ok(())
     }
 }
 
@@ -183,9 +401,10 @@ impl LapceData {
 /// normally only one window tab), size, position etc. and `Arc` references to
 /// state that is common to this instance of Lapce, such as configuration and the
 /// keymap setup.
-#[derive(Clone)]
+#[derive(Clone, Data)]
 pub struct LapceWindowData {
     /// The unique identifier for the Window. Generated by Druid.
+    #[data(ignore)]
     pub window_id: WindowId,
     /// The set of tabs within the window. These tabs are high-level
     /// constructs, in particular they are not **editor tabs**, which are
@@ -201,10 +420,9 @@ pub struct LapceWindowData {
     /// The index of the active window tab.
     pub active: usize,
     /// The Id of the active window tab.
-    pub active_id: WidgetId,
+    pub active_id: Arc<WidgetId>,
     pub keypress: Arc<KeyPressData>,
-    pub config: Arc<Config>,
-    pub plugins: Arc<Vec<PluginDescription>>,
+    pub config: Arc<LapceConfig>,
     pub db: Arc<LapceDb>,
     pub watcher: Arc<notify::RecommendedWatcher>,
     /// The size of the window.
@@ -212,23 +430,22 @@ pub struct LapceWindowData {
     pub maximised: bool,
     /// The position of the window.
     pub pos: Point,
-}
-
-impl Data for LapceWindowData {
-    fn same(&self, other: &Self) -> bool {
-        self.active == other.active
-            && self.tabs.same(&other.tabs)
-            && self.size.same(&other.size)
-            && self.pos.same(&other.pos)
-            && self.maximised.same(&other.maximised)
-            && self.keypress.same(&other.keypress)
-            && self.plugins.same(&other.plugins)
-    }
+    pub panel_orders: PanelOrder,
+    pub latest_release: Arc<Option<ReleaseInfo>>,
+    pub update_in_progress: bool,
+    #[data(ignore)]
+    pub log_file: Arc<Option<PathBuf>>,
 }
 
 impl LapceWindowData {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         keypress: Arc<KeyPressData>,
+        latest_release: Arc<Option<ReleaseInfo>>,
+        update_in_progress: bool,
+        log_file: Arc<Option<PathBuf>>,
+        current_panels: Option<PanelData>,
+        panel_orders: PanelOrder,
         event_sink: ExtEventSink,
         info: &WindowInfo,
         db: Arc<LapceDb>,
@@ -247,6 +464,11 @@ impl LapceWindowData {
                 workspace.clone(),
                 db.clone(),
                 keypress.clone(),
+                latest_release.clone(),
+                update_in_progress,
+                log_file.clone(),
+                current_panels.clone(),
+                panel_orders.clone(),
                 event_sink.clone(),
             );
             tabs.insert(tab_id, tab);
@@ -265,6 +487,11 @@ impl LapceWindowData {
                 LapceWorkspace::default(),
                 db.clone(),
                 keypress.clone(),
+                latest_release.clone(),
+                update_in_progress,
+                log_file.clone(),
+                current_panels,
+                panel_orders.clone(),
                 event_sink.clone(),
             );
             tabs.insert(tab_id, tab);
@@ -272,14 +499,14 @@ impl LapceWindowData {
             active_tab_id = tab_id;
         }
 
-        let config = Arc::new(
-            Config::load(&LapceWorkspace {
+        let config = Arc::new(LapceConfig::load(
+            &LapceWorkspace {
                 kind: LapceWorkspaceType::Local,
                 path: None,
                 last_open: 0,
-            })
-            .unwrap_or_default(),
-        );
+            },
+            &[],
+        ));
         let _ = event_sink.submit_command(
             LAPCE_UI_COMMAND,
             LapceUICommand::Focus,
@@ -288,26 +515,25 @@ impl LapceWindowData {
 
         let mut watcher =
             notify::recommended_watcher(ConfigWatcher::new(event_sink)).unwrap();
-        if let Some(path) = Config::settings_file() {
+        if let Some(path) = LapceConfig::settings_file() {
             let _ = watcher.watch(&path, notify::RecursiveMode::Recursive);
         }
-        if let Some(path) = Config::themes_folder() {
+        if let Some(path) = Directory::themes_directory() {
             let _ = watcher.watch(&path, notify::RecursiveMode::Recursive);
         }
-        if let Some(path) = KeyPressData::file() {
+        if let Some(path) = LapceConfig::keymaps_file() {
             let _ = watcher.watch(&path, notify::RecursiveMode::Recursive);
         }
-        if let Some(base) = BaseDirs::new() {
-            let path = base.home_dir().join(".lapce").join("plugins");
+        if let Some(path) = Directory::plugins_directory() {
             let _ = watcher.watch(&path, notify::RecursiveMode::Recursive);
         }
+
         Self {
             window_id,
             tabs,
             tabs_order: Arc::new(tabs_order),
             active,
-            plugins: Arc::new(Vec::new()),
-            active_id: active_tab_id,
+            active_id: Arc::new(active_tab_id),
             keypress,
             config,
             db,
@@ -315,6 +541,10 @@ impl LapceWindowData {
             size: info.size,
             pos: info.pos,
             maximised: info.maximised,
+            panel_orders,
+            latest_release,
+            update_in_progress,
+            log_file,
         }
     }
 
@@ -326,7 +556,7 @@ impl LapceWindowData {
             .enumerate()
             .map(|(i, w)| {
                 let tab = self.tabs.get(w).unwrap();
-                if tab.id == self.active_id {
+                if tab.id == *self.active_id {
                     active_tab = i;
                 }
                 (*tab.workspace).clone()
@@ -344,64 +574,15 @@ impl LapceWindowData {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct EditorDiagnostic {
-    pub range: Option<(usize, usize)>,
+    pub range: (usize, usize),
     pub diagnostic: Diagnostic,
+    /// Line counter for the editor diagnostic.
+    /// Contains the total number of message lines and related information lines
     pub lines: usize,
 }
 
-#[derive(Clone, Copy, PartialEq, Data, Serialize, Deserialize, Hash, Eq, Debug)]
-pub enum PanelKind {
-    FileExplorer,
-    SourceControl,
-    Plugin,
-    Terminal,
-    Search,
-    Problem,
-}
-
-impl PanelKind {
-    pub fn svg_name(&self) -> &'static str {
-        match &self {
-            PanelKind::FileExplorer => "file-explorer.svg",
-            PanelKind::SourceControl => "git-icon.svg",
-            PanelKind::Plugin => "plugin-icon.svg",
-            PanelKind::Terminal => "terminal.svg",
-            PanelKind::Search => "search.svg",
-            PanelKind::Problem => "error.svg",
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct PanelData {
-    pub active: PanelKind,
-    pub widgets: Vec<PanelKind>,
-    pub shown: bool,
-    pub maximized: bool,
-}
-
-impl PanelData {
-    pub fn is_shown(&self) -> bool {
-        self.shown && !self.widgets.is_empty()
-    }
-
-    pub fn is_maximized(&self) -> bool {
-        self.maximized && !self.widgets.is_empty()
-    }
-}
-
-#[derive(Clone, Data)]
-pub struct PanelSize {
-    pub left: f64,
-    pub left_split: f64,
-    pub bottom: f64,
-    pub bottom_split: f64,
-    pub right: f64,
-    pub right_split: f64,
-}
-
 #[derive(Clone)]
 pub struct WorkProgress {
     pub token: ProgressToken,
@@ -410,28 +591,36 @@ pub struct WorkProgress {
     pub percentage: Option<u32>,
 }
 
-#[derive(Clone, PartialEq, Data)]
+#[derive(Clone, PartialEq, Eq, Data)]
 pub enum FocusArea {
     Palette,
     Editor,
+    Rename,
     Panel(PanelKind),
     FilePicker,
+    BranchPicker,
 }
 
 #[derive(Clone)]
 pub enum DragContent {
-    EditorTab(WidgetId, usize, EditorTabChild, TabRect),
+    EditorTab(WidgetId, usize, EditorTabChild, Box<TabRect>),
+    Panel(PanelKind, Rect),
 }
 
-#[derive(Clone, Lens)]
+#[derive(Clone, Lens, Data)]
 pub struct LapceTabData {
+    #[data(ignore)]
     pub id: WidgetId,
-    pub window_id: WindowId,
+    pub window_id: Arc<WindowId>,
+    pub multiple_tab: bool,
     pub workspace: Arc<LapceWorkspace>,
+    pub title: Arc<TitleData>,
     pub main_split: LapceMainSplitData,
     pub completion: Arc<CompletionData>,
+    pub signature: Arc<SignatureData>,
     pub hover: Arc<HoverData>,
-    pub terminal: Arc<TerminalSplitData>,
+    pub rename: Arc<RenameData>,
+    pub terminal: Arc<TerminalPanelData>,
     pub palette: Arc<PaletteData>,
     pub find: Arc<Find>,
     pub source_control: Arc<SourceControlData>,
@@ -439,96 +628,104 @@ pub struct LapceTabData {
     pub search: Arc<SearchData>,
     pub plugin: Arc<PluginData>,
     pub picker: Arc<FilePickerData>,
-    pub plugins: Arc<Vec<PluginDescription>>,
-    pub installed_plugins: Arc<HashMap<String, PluginDescription>>,
     pub file_explorer: Arc<FileExplorerData>,
+    #[data(ignore)]
     pub proxy: Arc<LapceProxy>,
     pub proxy_status: Arc<ProxyStatus>,
     pub keypress: Arc<KeyPressData>,
     pub settings: Arc<LapceSettingsPanelData>,
+    pub about: Arc<AboutData>,
     pub alert: Arc<AlertData>,
+    pub message_widget_id: Arc<WidgetId>,
+    #[data(ignore)]
     pub term_tx: Arc<Sender<(TermId, TermEvent)>>,
+    #[data(ignore)]
     pub term_rx: Option<Receiver<(TermId, TermEvent)>>,
+    #[data(ignore)]
     pub window_origin: Rc<RefCell<Point>>,
-    pub panels: im::HashMap<PanelPosition, Arc<PanelData>>,
-    pub panel_active: PanelPosition,
-    pub panel_size: PanelSize,
-    pub config: Arc<Config>,
-    pub focus: WidgetId,
+    pub panel: Arc<PanelData>,
+    pub config: Arc<LapceConfig>,
+    pub images: Arc<ImageCache>,
+    pub focus: Arc<WidgetId>,
     pub focus_area: FocusArea,
+    #[data(ignore)]
     pub db: Arc<LapceDb>,
-    pub progresses: im::Vector<WorkProgress>,
-    pub drag: Arc<Option<(Vec2, DragContent)>>,
-}
-
-impl Data for LapceTabData {
-    fn same(&self, other: &Self) -> bool {
-        self.main_split.same(&other.main_split)
-            && self.completion.same(&other.completion)
-            && self.hover.same(&other.hover)
-            && self.palette.same(&other.palette)
-            && self.workspace.same(&other.workspace)
-            && self.source_control.same(&other.source_control)
-            && self.panels.same(&other.panels)
-            && self.panel_size.same(&other.panel_size)
-            && self.config.same(&other.config)
-            && self.terminal.same(&other.terminal)
-            && self.focus == other.focus
-            && self.focus_area == other.focus_area
-            && self.panel_active == other.panel_active
-            && self.proxy_status.same(&other.proxy_status)
-            && self.find.same(&other.find)
-            && self.alert.same(&other.alert)
-            && self.progresses.ptr_eq(&other.progresses)
-            && self.file_explorer.same(&other.file_explorer)
-            && self.plugin.same(&other.plugin)
-            && self.problem.same(&other.problem)
-            && self.search.same(&other.search)
-            && self.installed_plugins.same(&other.installed_plugins)
-            && self.picker.same(&other.picker)
-            && self.drag.same(&other.drag)
-            && self.keypress.same(&other.keypress)
-            && self.settings.same(&other.settings)
-    }
+    pub progresses: Arc<Vec<WorkProgress>>,
+    pub drag: Arc<Option<(Vec2, Vec2, DragContent)>>,
+    pub latest_release: Arc<Option<ReleaseInfo>>,
+    pub update_in_progress: bool,
+    #[data(ignore)]
+    pub log_file: Arc<Option<PathBuf>>,
 }
 
 impl GetConfig for LapceTabData {
-    fn get_config(&self) -> &Config {
+    fn get_config(&self) -> &LapceConfig {
         &self.config
     }
 }
 
 impl LapceTabData {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         window_id: WindowId,
         tab_id: WidgetId,
         workspace: LapceWorkspace,
         db: Arc<LapceDb>,
         keypress: Arc<KeyPressData>,
+        latest_release: Arc<Option<ReleaseInfo>>,
+        update_in_progress: bool,
+        log_file: Arc<Option<PathBuf>>,
+        current_panels: Option<PanelData>,
+        panel_orders: PanelOrder,
         event_sink: ExtEventSink,
     ) -> Self {
-        let config = Arc::new(Config::load(&workspace).unwrap_or_default());
-
+        let disabled_volts = db.get_disabled_volts().unwrap_or_default();
+        let workspace_disabled_volts = db
+            .get_workspace_disabled_volts(&workspace)
+            .unwrap_or_default();
+        let mut all_disabled_volts = disabled_volts.clone();
+        all_disabled_volts.extend_from_slice(&workspace_disabled_volts);
+
+        let config = Arc::new(LapceConfig::load(&workspace, &all_disabled_volts));
         let workspace_info = if workspace.path.is_some() {
             db.get_workspace_info(&workspace).ok()
         } else {
-            None
+            let mut info = db.get_workspace_info(&workspace).ok();
+            if let Some(info) = info.as_mut() {
+                info.split.children.clear();
+                if let Some(panels) = current_panels.clone() {
+                    info.panel = panels;
+                }
+            }
+            info
         };
 
         let (term_sender, term_receiver) = unbounded();
         let proxy = Arc::new(LapceProxy::new(
+            window_id,
             tab_id,
             workspace.clone(),
+            all_disabled_volts,
+            config.plugins.clone(),
             term_sender.clone(),
             event_sink.clone(),
         ));
-        let palette = Arc::new(PaletteData::new(proxy.clone()));
-        let completion = Arc::new(CompletionData::new());
+        let title = Arc::new(TitleData::new(config.clone()));
+        let palette = Arc::new(PaletteData::new(config.clone(), proxy.clone()));
+        let completion = Arc::new(CompletionData::new(config.clone()));
         let hover = Arc::new(HoverData::new());
+        let signature = Arc::new(SignatureData::new());
+        let rename = Arc::new(RenameData::new());
         let source_control = Arc::new(SourceControlData::new());
         let settings = Arc::new(LapceSettingsPanelData::new());
+        let about = Arc::new(AboutData::new());
         let alert = Arc::new(AlertData::new());
-        let plugin = Arc::new(PluginData::new());
+        let plugin = Arc::new(PluginData::new(
+            tab_id,
+            disabled_volts,
+            workspace_disabled_volts,
+            event_sink.clone(),
+        ));
         let file_explorer = Arc::new(FileExplorerData::new(
             tab_id,
             workspace.clone(),
@@ -538,6 +735,14 @@ impl LapceTabData {
         let search = Arc::new(SearchData::new());
         let file_picker = Arc::new(FilePickerData::new());
 
+        let unsaved_buffers = match db.get_unsaved_buffers() {
+            Ok(val) => val,
+            Err(err) => {
+                log::warn!("Error during unsaved buffer fetching : {:}", err);
+                im::HashMap::new()
+            }
+        };
+
         let mut main_split = LapceMainSplitData::new(
             tab_id,
             workspace_info.as_ref(),
@@ -547,7 +752,9 @@ impl LapceTabData {
             event_sink.clone(),
             Arc::new(workspace.clone()),
             db.clone(),
+            unsaved_buffers,
         );
+
         main_split.add_editor(
             source_control.editor_view_id,
             None,
@@ -583,6 +790,27 @@ impl LapceTabData {
             &config,
             event_sink.clone(),
         );
+        main_split.add_editor(
+            title.branches.filter_editor,
+            None,
+            LocalBufferKind::BranchesFilter,
+            &config,
+            event_sink.clone(),
+        );
+        main_split.add_editor(
+            plugin.search_editor,
+            None,
+            LocalBufferKind::PluginSearch,
+            &config,
+            event_sink.clone(),
+        );
+        main_split.add_editor(
+            rename.view_id,
+            None,
+            LocalBufferKind::Rename,
+            &config,
+            event_sink.clone(),
+        );
         main_split.add_editor(
             file_picker.editor_view_id,
             None,
@@ -591,51 +819,40 @@ impl LapceTabData {
             event_sink.clone(),
         );
 
-        let terminal = Arc::new(TerminalSplitData::new(proxy.clone()));
+        let terminal = Arc::new(TerminalPanelData::new(
+            Arc::new(workspace.clone()),
+            proxy.clone(),
+            &config,
+            event_sink.clone(),
+        ));
         let problem = Arc::new(ProblemData::new());
+        let panel = workspace_info
+            .map(|i| {
+                let mut panel = i.panel;
+                panel.order = panel_orders.clone();
+                panel
+            })
+            .or(current_panels)
+            .unwrap_or_else(|| PanelData::new(panel_orders));
 
-        let mut panels = im::HashMap::new();
-        panels.insert(
-            PanelPosition::LeftTop,
-            Arc::new(PanelData {
-                active: PanelKind::FileExplorer,
-                widgets: vec![
-                    PanelKind::FileExplorer,
-                    PanelKind::SourceControl,
-                    PanelKind::Plugin,
-                ],
-                shown: true,
-                maximized: false,
-            }),
-        );
-        panels.insert(
-            PanelPosition::BottomLeft,
-            Arc::new(PanelData {
-                active: PanelKind::Terminal,
-                widgets: vec![
-                    PanelKind::Terminal,
-                    PanelKind::Search,
-                    PanelKind::Problem,
-                ],
-                shown: true,
-                maximized: false,
-            }),
-        );
         let focus = (*main_split.active).unwrap_or(*main_split.split_id);
+
         let mut tab = Self {
             id: tab_id,
-            window_id,
+            multiple_tab: false,
+            window_id: Arc::new(window_id),
             workspace: Arc::new(workspace),
-            focus,
+            focus: Arc::new(focus),
+            title,
             main_split,
             completion,
+            signature,
             hover,
+            rename,
             terminal,
             plugin,
             problem,
             search,
-            plugins: Arc::new(Vec::new()),
-            installed_plugins: Arc::new(HashMap::new()),
             find: Arc::new(Find::new(0)),
             picker: file_picker,
             source_control,
@@ -645,25 +862,22 @@ impl LapceTabData {
             palette,
             proxy,
             settings,
+            about,
             alert,
+            message_widget_id: Arc::new(WidgetId::next()),
             proxy_status: Arc::new(ProxyStatus::Connecting),
             keypress,
             window_origin: Rc::new(RefCell::new(Point::ZERO)),
-            panels,
-            panel_size: PanelSize {
-                left: 250.0,
-                left_split: 0.5,
-                bottom: 300.0,
-                bottom_split: 0.5,
-                right: 250.0,
-                right_split: 0.5,
-            },
-            panel_active: PanelPosition::LeftTop,
+            panel: Arc::new(panel),
             config,
+            images: Arc::new(ImageCache::default()),
             focus_area: FocusArea::Editor,
             db,
-            progresses: im::Vector::new(),
+            progresses: Arc::new(Vec::new()),
             drag: Arc::new(None),
+            latest_release,
+            update_in_progress,
+            log_file,
         };
         tab.start_update_process(event_sink);
         tab
@@ -677,6 +891,7 @@ impl LapceTabData {
             .unwrap();
         WorkspaceInfo {
             split: main_split_data.split_info(self),
+            panel: (*self.panel).clone(),
         }
     }
 
@@ -707,6 +922,20 @@ impl LapceTabData {
         }
     }
 
+    /// Get information about the specific editor, with various data so that it can provide useful  
+    /// utility functions for the editor buffer.  
+    /// Note that if you edit the editor buffer or related fields, then you'll have to 'give it
+    /// back' to [`LapceTabData`] so that it can update the internals.  
+    /// ```rust,ignore
+    /// // Get the editor before it may be modified by the `editor_data`
+    /// let editor = data.main_split.editors.get(&view_id).unwrap().clone();
+    /// let mut editor_data = data.editor_view_content(view_id);
+    /// let doc = editor_data.doc.clone();
+    /// // Do some modification
+    /// Arc::make_mut(&mut editor_data.editor).cursor.set_offset(0, true, mods.alt());
+    /// // Give it back so that `LapceTabData` can update the internals
+    /// data.update_from_editor_buffer_data(editor_data, &editor, &doc);
+    /// ```
     pub fn editor_view_content(
         &self,
         editor_view_id: WidgetId,
@@ -730,7 +959,10 @@ impl LapceTabData {
             view_id: editor_view_id,
             main_split: self.main_split.clone(),
             completion: self.completion.clone(),
+            signature: self.signature.clone(),
             hover: self.hover.clone(),
+            rename: self.rename.clone(),
+            focus_area: self.focus_area.clone(),
             source_control: self.source_control.clone(),
             proxy: self.proxy.clone(),
             find: self.find.clone(),
@@ -765,15 +997,36 @@ impl LapceTabData {
         }
     }
 
-    pub fn panel_position(&self, kind: PanelKind) -> Option<PanelPosition> {
-        for (pos, panels) in self.panels.iter() {
-            if panels.widgets.contains(&kind) {
-                return Some(*pos);
-            }
+    pub fn is_drag_editor(&self) -> bool {
+        matches!(&*self.drag, Some((_, _, DragContent::EditorTab(..))))
+    }
+
+    /// Get the mode for the current editor or terminal
+    pub fn mode(&self) -> Mode {
+        if self.config.core.modal {
+            let mode = if self.focus_area == FocusArea::Panel(PanelKind::Terminal) {
+                self.terminal.active_terminal().map(|t| t.mode)
+            } else {
+                self.main_split.active_editor().map(|e| e.cursor.get_mode())
+            };
+
+            mode.unwrap_or(Mode::Normal)
+        } else {
+            Mode::Insert
         }
-        None
     }
 
+    /// Update the stored information with the changed editor buffer data.  
+    /// ```rust,ignore
+    /// // Get the editor before it may be modified by the `editor_data`
+    /// let editor = data.main_split.editors.get(&view_id).unwrap().clone();
+    /// let mut editor_data = data.editor_view_content(view_id);
+    /// let doc = editor_data.doc.clone();
+    /// // Do some modification
+    /// Arc::make_mut(&mut editor_data.editor).cursor.set_offset(0, true, mods.alt());
+    /// // Give it back so that `LapceTabData` can update the internals
+    /// data.update_from_editor_buffer_data(editor_data, &editor, &doc);
+    /// ```
     pub fn update_from_editor_buffer_data(
         &mut self,
         editor_buffer_data: LapceEditorBufferData,
@@ -781,7 +1034,9 @@ impl LapceTabData {
         doc: &Arc<Document>,
     ) {
         self.completion = editor_buffer_data.completion.clone();
+        self.signature = editor_buffer_data.signature.clone();
         self.hover = editor_buffer_data.hover.clone();
+        self.rename = editor_buffer_data.rename.clone();
         self.main_split = editor_buffer_data.main_split.clone();
         self.find = editor_buffer_data.find.clone();
         if !editor_buffer_data.editor.same(editor) {
@@ -819,9 +1074,10 @@ impl LapceTabData {
         &self,
         text: &mut PietText,
         tab_size: Size,
-        config: &Config,
+        completion_size: Size,
+        config: &LapceConfig,
     ) -> Point {
-        let line_height = self.config.editor.line_height as f64;
+        let line_height = self.config.editor.line_height() as f64;
 
         let editor = self.main_split.active_editor();
         let editor = match editor {
@@ -841,26 +1097,117 @@ impl LapceTabData {
             BufferContent::File(_) | BufferContent::Scratch(..) => {
                 let doc = self.main_split.editor_doc(editor.view_id);
                 let offset = self.completion.offset;
-                let (line, col) = doc.buffer().offset_to_line_col(offset);
-                let width = config.editor_char_width(text);
-                let x = col as f64 * width - line_height - 5.0;
-                let y = (line + 1) as f64 * line_height;
+                let (point_above, point_below) =
+                    doc.points_of_offset(text, offset, &editor.view, config);
+
                 let mut origin = *editor.window_origin.borrow()
                     - self.window_origin.borrow().to_vec2()
-                    + Vec2::new(x, y);
-                if origin.y + self.completion.size.height + 1.0 > tab_size.height {
-                    let height = self
-                        .completion
-                        .size
+                    + Vec2::new(point_below.x - line_height - 5.0, point_below.y);
+                if origin.y + completion_size.height + 1.0 > tab_size.height {
+                    let height = completion_size
                         .height
                         .min(self.completion.len() as f64 * line_height);
                     origin.y = editor.window_origin.borrow().y
                         - self.window_origin.borrow().y
-                        + line as f64 * line_height
+                        + point_above.y
                         - height;
                 }
-                if origin.x + self.completion.size.width + 1.0 > tab_size.width {
-                    origin.x = tab_size.width - self.completion.size.width - 1.0;
+                if origin.x + completion_size.width + 1.0 > tab_size.width {
+                    origin.x = tab_size.width - completion_size.width - 1.0;
+                }
+                if origin.x <= 0.0 {
+                    origin.x = 0.0;
+                }
+
+                origin
+            }
+        }
+    }
+
+    pub fn signature_origin(
+        &self,
+        text: &mut PietText,
+        tab_size: Size,
+        signature_size: Size,
+        label_offset: f64,
+        config: &LapceConfig,
+    ) -> Point {
+        let editor = self.main_split.active_editor();
+        let editor = match editor {
+            Some(editor) => editor,
+            None => return Point::ZERO,
+        };
+
+        match &editor.content {
+            BufferContent::File(_) | BufferContent::Scratch(_, _) => {
+                let doc = self.main_split.editor_doc(editor.view_id);
+                let offset = self.signature.offset;
+                let (point_above, _point_below) =
+                    doc.points_of_offset(text, offset, &editor.view, config);
+
+                let mut origin = *editor.window_origin.borrow()
+                    - self.window_origin.borrow().to_vec2()
+                    + Vec2::new(point_above.x - 5.0 - label_offset, point_above.y)
+                    - Vec2::new(0.0, signature_size.height);
+
+                // TODO: What about if the signature's position is past the tab size?
+
+                if origin.x + signature_size.width + 1.0 > tab_size.width {
+                    origin.x = tab_size.width - signature_size.width - 1.0;
+                }
+
+                if origin.x <= 0.0 {
+                    origin.x = 0.0;
+                }
+
+                origin
+            }
+            BufferContent::SettingsValue(_) | BufferContent::Local(_) => {
+                *editor.window_origin.borrow()
+                    - self.window_origin.borrow().to_vec2()
+            }
+        }
+    }
+
+    pub fn rename_origin(
+        &self,
+        text: &mut PietText,
+        tab_size: Size,
+        rename_size: Size,
+        config: &LapceConfig,
+    ) -> Point {
+        let editor = self.main_split.active_editor();
+        let editor = match editor {
+            Some(editor) => editor,
+            None => return Point::ZERO,
+        };
+
+        match &editor.content {
+            BufferContent::Local(_) => {
+                *editor.window_origin.borrow()
+                    - self.window_origin.borrow().to_vec2()
+            }
+            BufferContent::SettingsValue(..) => {
+                *editor.window_origin.borrow()
+                    - self.window_origin.borrow().to_vec2()
+            }
+            BufferContent::File(_) | BufferContent::Scratch(..) => {
+                let doc = self.main_split.editor_doc(editor.view_id);
+                let offset = self.rename.start;
+                let (point_above, point_below) =
+                    doc.points_of_offset(text, offset, &editor.view, config);
+
+                let mut origin = *editor.window_origin.borrow()
+                    - self.window_origin.borrow().to_vec2()
+                    + Vec2::new(point_below.x, point_below.y);
+                if origin.y + rename_size.height + 1.0 > tab_size.height {
+                    origin.y = editor.window_origin.borrow().y
+                        - self.window_origin.borrow().y
+                        + point_above.y
+                        - rename_size.height;
+                }
+                if origin.x + rename_size.width + 1.0 > tab_size.width {
+                    origin.x = tab_size.width - rename_size.width - 1.0;
                 }
                 if origin.x <= 0.0 {
                     origin.x = 0.0;
@@ -875,9 +1222,9 @@ impl LapceTabData {
         &self,
         text: &mut PietText,
         tab_size: Size,
-        config: &Config,
+        config: &LapceConfig,
     ) -> Point {
-        let line_height = self.config.editor.line_height as f64;
+        let line_height = self.config.editor.line_height() as f64;
 
         let editor = self.main_split.editors.get(&self.hover.editor_view_id);
         let editor = match editor {
@@ -897,25 +1244,19 @@ impl LapceTabData {
             BufferContent::File(_) | BufferContent::Scratch(..) => {
                 let doc = self.main_split.editor_doc(editor.view_id);
                 let offset = self.hover.offset;
-                let (line, col) = doc.buffer().offset_to_line_col(offset);
-                let point = doc.point_of_line_col(
-                    text,
-                    line,
-                    col,
-                    config.editor.font_size,
-                    config,
-                );
+                let (point, _) =
+                    doc.points_of_offset(text, offset, &editor.view, config);
                 let x = point.x;
-                let y = line as f64 * line_height;
+                let y = point.y;
+                let hover_size = *self.hover.content_size.borrow();
                 let mut origin = *editor.window_origin.borrow()
                     - self.window_origin.borrow().to_vec2()
-                    + Vec2::new(x, y - self.hover.content_size.borrow().height);
+                    + Vec2::new(x, y - hover_size.height);
                 if origin.y < 0.0 {
-                    origin.y +=
-                        self.hover.content_size.borrow().height + line_height;
+                    origin.y += hover_size.height + line_height;
                 }
-                if origin.x + self.hover.size.width + 1.0 > tab_size.width {
-                    origin.x = tab_size.width - self.hover.size.width - 1.0;
+                if origin.x + hover_size.width + 1.0 > tab_size.width {
+                    origin.x = tab_size.width - hover_size.width - 1.0;
                 }
                 if origin.x <= 0.0 {
                     origin.x = 0.0;
@@ -934,8 +1275,10 @@ impl LapceTabData {
             keypress: self.keypress.clone(),
             config: self.config.clone(),
             find: self.find.clone(),
+            db: self.db.clone(),
             focus_area: self.focus_area.clone(),
             terminal: self.terminal.clone(),
+            source_control: self.source_control.clone(),
         }
     }
 
@@ -948,11 +1291,27 @@ impl LapceTabData {
         _env: &Env,
     ) {
         match command {
+            LapceWorkbenchCommand::RestartToUpdate => {
+                if let Some(release) = (*self.latest_release).clone() {
+                    if release.version != *meta::VERSION {
+                        if let Ok(process_path) = env::current_exe() {
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::RestartToUpdate(
+                                    process_path,
+                                    release,
+                                ),
+                                Target::Global,
+                            ));
+                        }
+                    }
+                }
+            }
             LapceWorkbenchCommand::CloseFolder => {
                 if self.workspace.path.is_some() {
                     let mut workspace = (*self.workspace).clone();
                     workspace.path = None;
-                    let _ = ctx.submit_command(Command::new(
+                    ctx.submit_command(Command::new(
                         LAPCE_UI_COMMAND,
                         LapceUICommand::SetWorkspace(workspace),
                         Target::Auto,
@@ -1008,20 +1367,51 @@ impl LapceTabData {
                     }
                 }
             }
+            LapceWorkbenchCommand::RevealActiveFileInFileExplorer => {
+                let path = if let Some(editor) = self.main_split.active_editor() {
+                    match &editor.content {
+                        BufferContent::File(path) => path,
+                        _ => return,
+                    }
+                } else {
+                    return;
+                };
+
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::RevealInFileExplorer(path.to_owned()),
+                    Target::Auto,
+                ))
+            }
             LapceWorkbenchCommand::EnableModal => {
                 let config = Arc::make_mut(&mut self.config);
-                config.lapce.modal = true;
-                Config::update_file("lapce", "modal", toml::Value::Boolean(true));
+                config.core.modal = true;
+                LapceConfig::update_file(
+                    "core",
+                    "modal",
+                    toml_edit::Value::from(true),
+                );
             }
             LapceWorkbenchCommand::DisableModal => {
                 let config = Arc::make_mut(&mut self.config);
-                config.lapce.modal = false;
-                Config::update_file("lapce", "modal", toml::Value::Boolean(false));
+                config.core.modal = false;
+                LapceConfig::update_file(
+                    "core",
+                    "modal",
+                    toml_edit::Value::from(false),
+                );
+            }
+            LapceWorkbenchCommand::ChangeColorTheme => {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::RunPalette(Some(PaletteType::ColorTheme)),
+                    Target::Widget(self.palette.widget_id),
+                ));
             }
-            LapceWorkbenchCommand::ChangeTheme => {
+            LapceWorkbenchCommand::ChangeIconTheme => {
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::RunPalette(Some(PaletteType::Theme)),
+                    LapceUICommand::RunPalette(Some(PaletteType::IconTheme)),
                     Target::Widget(self.palette.widget_id),
                 ));
             }
@@ -1029,13 +1419,14 @@ impl LapceTabData {
                 self.main_split.new_file(ctx, &self.config);
             }
             LapceWorkbenchCommand::OpenLogFile => {
-                if let Some(path) = Config::log_file() {
+                if let Some(path) = (*self.log_file).clone() {
                     self.main_split.jump_to_location(
                         ctx,
                         None,
+                        false,
                         EditorLocation {
                             path,
-                            position: None,
+                            position: None::<usize>,
                             scroll_offset: None,
                             history: None,
                         },
@@ -1044,16 +1435,17 @@ impl LapceTabData {
                 }
             }
             LapceWorkbenchCommand::OpenSettings => {
-                self.main_split.open_settings(ctx, false);
+                self.main_split.open_settings(ctx, false, &self.config);
             }
             LapceWorkbenchCommand::OpenSettingsFile => {
-                if let Some(path) = Config::settings_file() {
+                if let Some(path) = LapceConfig::settings_file() {
                     self.main_split.jump_to_location(
                         ctx,
                         None,
+                        false,
                         EditorLocation {
                             path,
-                            position: None,
+                            position: None::<usize>,
                             scroll_offset: None,
                             history: None,
                         },
@@ -1061,17 +1453,40 @@ impl LapceTabData {
                     );
                 }
             }
+            LapceWorkbenchCommand::OpenSettingsDirectory
+            | LapceWorkbenchCommand::OpenProxyDirectory
+            | LapceWorkbenchCommand::OpenThemesDirectory
+            | LapceWorkbenchCommand::OpenLogsDirectory
+            | LapceWorkbenchCommand::OpenPluginsDirectory => {
+                use LapceWorkbenchCommand::*;
+                let dir = match command {
+                    OpenSettingsDirectory => Directory::config_directory(),
+                    OpenProxyDirectory => Directory::proxy_directory(),
+                    OpenThemesDirectory => Directory::themes_directory(),
+                    OpenLogsDirectory => Directory::logs_directory(),
+                    OpenPluginsDirectory => Directory::plugins_directory(),
+                    _ => return,
+                };
+                if let Some(dir) = dir {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::OpenURI(dir.to_string_lossy().to_string()),
+                        Target::Auto,
+                    ))
+                }
+            }
             LapceWorkbenchCommand::OpenKeyboardShortcuts => {
-                self.main_split.open_settings(ctx, true);
+                self.main_split.open_settings(ctx, true, &self.config);
             }
             LapceWorkbenchCommand::OpenKeyboardShortcutsFile => {
-                if let Some(path) = KeyPressData::file() {
+                if let Some(path) = LapceConfig::keymaps_file() {
                     self.main_split.jump_to_location(
                         ctx,
                         None,
+                        false,
                         EditorLocation {
                             path,
-                            position: None,
+                            position: None::<usize>,
                             scroll_offset: None,
                             history: None,
                         },
@@ -1100,6 +1515,13 @@ impl LapceTabData {
                     Target::Widget(self.palette.widget_id),
                 ));
             }
+            LapceWorkbenchCommand::PaletteWorkspaceSymbol => {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::RunPalette(Some(PaletteType::WorkspaceSymbol)),
+                    Target::Widget(self.palette.widget_id),
+                ));
+            }
             LapceWorkbenchCommand::PaletteCommand => {
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
@@ -1117,7 +1539,7 @@ impl LapceTabData {
             LapceWorkbenchCommand::NewWindowTab => {
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::NewTab,
+                    LapceUICommand::NewTab(None),
                     Target::Auto,
                 ));
             }
@@ -1145,10 +1567,17 @@ impl LapceTabData {
             LapceWorkbenchCommand::NewWindow => {
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::NewWindow(self.window_id),
+                    LapceUICommand::NewWindow(*self.window_id),
                     Target::Global,
                 ));
             }
+            LapceWorkbenchCommand::CloseWindow => {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::CloseWindow(*self.window_id),
+                    Target::Auto,
+                ));
+            }
             LapceWorkbenchCommand::ReloadWindow => {
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
@@ -1159,20 +1588,10 @@ impl LapceTabData {
             LapceWorkbenchCommand::ToggleMaximizedPanel => {
                 if let Some(data) = data {
                     if let Ok(kind) = serde_json::from_value::<PanelKind>(data) {
-                        for (_, panel) in self.panels.iter_mut() {
-                            if panel.widgets.contains(&kind) {
-                                if panel.active == kind {
-                                    let panel = Arc::make_mut(panel);
-                                    panel.maximized = !panel.maximized;
-                                }
-                                break;
-                            }
-                        }
+                        Arc::make_mut(&mut self.panel).toggle_maximize(&kind);
                     }
                 } else {
-                    let panel = self.panels.get_mut(&self.panel_active).unwrap();
-                    let panel = Arc::make_mut(panel);
-                    panel.maximized = !panel.maximized;
+                    Arc::make_mut(&mut self.panel).toggle_active_maximize();
                 }
             }
             LapceWorkbenchCommand::FocusEditor => {
@@ -1188,7 +1607,7 @@ impl LapceTabData {
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
                     LapceUICommand::Focus,
-                    Target::Widget(self.terminal.active),
+                    Target::Widget(self.terminal.widget_id),
                 ));
             }
 
@@ -1217,7 +1636,15 @@ impl LapceTabData {
                     }
                 }
             }
-
+            LapceWorkbenchCommand::TogglePanelLeftVisual => {
+                self.toggle_container_visual(ctx, &PanelContainerPosition::Left);
+            }
+            LapceWorkbenchCommand::TogglePanelRightVisual => {
+                self.toggle_container_visual(ctx, &PanelContainerPosition::Right);
+            }
+            LapceWorkbenchCommand::TogglePanelBottomVisual => {
+                self.toggle_container_visual(ctx, &PanelContainerPosition::Bottom);
+            }
             LapceWorkbenchCommand::ToggleSourceControlFocus => {
                 self.toggle_panel_focus(ctx, PanelKind::SourceControl);
             }
@@ -1258,20 +1685,24 @@ impl LapceTabData {
                     }
                 }
             }
+            LapceWorkbenchCommand::SourceControlInit => {
+                self.proxy.proxy_rpc.git_init();
+            }
             LapceWorkbenchCommand::SourceControlCommit => {
                 let diffs: Vec<FileDiff> = self
                     .source_control
                     .file_diffs
                     .iter()
                     .filter_map(
-                        |(diff, checked)| {
+                        |(_, (diff, checked))| {
                             if *checked {
-                                Some(diff.clone())
+                                Some(diff)
                             } else {
                                 None
                             }
                         },
                     )
+                    .cloned()
                     .collect();
                 if diffs.is_empty() {
                     return;
@@ -1281,26 +1712,111 @@ impl LapceTabData {
                     .local_docs
                     .get_mut(&LocalBufferKind::SourceControl)
                     .unwrap();
-                let message = doc.buffer().text().to_string();
+                let message = doc.buffer().to_string();
                 let message = message.trim();
                 if message.is_empty() {
                     return;
                 }
-                self.proxy.git_commit(message, diffs);
+                self.proxy.proxy_rpc.git_commit(message.to_string(), diffs);
                 Arc::make_mut(doc).reload(Rope::from(""), true);
                 let editor = self
                     .main_split
                     .editors
                     .get_mut(&self.source_control.editor_view_id)
                     .unwrap();
-                Arc::make_mut(editor).cursor = if self.config.lapce.modal {
+                Arc::make_mut(editor).cursor = if self.config.core.modal {
                     Cursor::new(CursorMode::Normal(0), None, None)
                 } else {
                     Cursor::new(CursorMode::Insert(Selection::caret(0)), None, None)
                 };
             }
+            LapceWorkbenchCommand::SourceControlCopyActiveFileRemoteUrl => {
+                if let Some(editor) = self.main_split.active_editor() {
+                    if let BufferContent::File(path) = &editor.content {
+                        let event_sink = ctx.get_external_handle();
+
+                        self.proxy.proxy_rpc.git_get_remote_file_url(
+                            path.clone(),
+                            move |result| {
+                                if let Ok(ProxyResponse::GitGetRemoteFileUrl {
+                                    file_url,
+                                }) = result
+                                {
+                                    let _ = event_sink.submit_command(
+                                        LAPCE_UI_COMMAND,
+                                        LapceUICommand::PutToClipboard(file_url),
+                                        Target::Auto,
+                                    );
+                                }
+                            },
+                        )
+                    }
+                }
+            }
+            LapceWorkbenchCommand::SourceControlDiscardActiveFileChanges => {
+                if let Some(editor) = self.main_split.active_editor() {
+                    if let BufferContent::File(path) = &editor.content {
+                        self.proxy
+                            .proxy_rpc
+                            .git_discard_files_changes(vec![path.clone()]);
+                    }
+                }
+            }
+            LapceWorkbenchCommand::SourceControlDiscardTargetFileChanges => {
+                if let Ok(v) = serde_json::from_value::<FileDiff>(data.unwrap()) {
+                    match v {
+                        FileDiff::Added(path) => {
+                            self.proxy.proxy_rpc.trash_path(
+                                path,
+                                Box::new(move |res| {
+                                    if let Err(err) = res {
+                                        log::warn!(
+                                            "Failed to trash path: {:?}",
+                                            err
+                                        );
+                                    }
+                                }),
+                            );
+                        }
+                        FileDiff::Deleted(path) => {
+                            self.proxy
+                                .proxy_rpc
+                                .git_discard_files_changes(vec![path]);
+                        }
+                        FileDiff::Modified(path) => {
+                            self.proxy
+                                .proxy_rpc
+                                .git_discard_files_changes(vec![path]);
+                        }
+                        FileDiff::Renamed(old_path, new_path) => {
+                            self.proxy
+                                .proxy_rpc
+                                .git_discard_files_changes(vec![old_path]);
+
+                            self.proxy.proxy_rpc.trash_path(
+                                new_path,
+                                Box::new(move |res| {
+                                    if let Err(err) = res {
+                                        log::warn!(
+                                            "Failed to trash path: {:?}",
+                                            err
+                                        );
+                                    }
+                                }),
+                            );
+                        }
+                    }
+                } else {
+                    log::error!("discard target file called without a target file");
+                }
+            }
+            LapceWorkbenchCommand::SourceControlDiscardWorkspaceChanges => {
+                self.proxy.proxy_rpc.git_discard_workspace_changes();
+            }
             LapceWorkbenchCommand::CheckoutBranch => match data {
-                Some(Value::String(branch)) => self.proxy.git_checkout(&branch),
+                Some(Value::String(branch)) => {
+                    self.proxy.proxy_rpc.git_checkout(branch)
+                }
                 _ => log::error!("checkout called without a branch"), // TODO: How do I show a result to the user here?
             },
 
@@ -1311,6 +1827,7 @@ impl LapceTabData {
                     Target::Widget(self.palette.widget_id),
                 ));
             }
+            #[cfg(windows)]
             LapceWorkbenchCommand::ConnectWsl => ctx.submit_command(Command::new(
                 LAPCE_UI_COMMAND,
                 LapceUICommand::SetWorkspace(LapceWorkspace {
@@ -1337,6 +1854,177 @@ impl LapceTabData {
             LapceWorkbenchCommand::InstallTheme => {
                 self.main_split.install_theme(ctx, &self.config);
             }
+            LapceWorkbenchCommand::ChangeFileLanguage => {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::RunPalette(Some(PaletteType::Language)),
+                    Target::Auto,
+                ))
+            }
+            LapceWorkbenchCommand::NextEditorTab => {
+                if let Some(active) = *self.main_split.active_tab {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::NextEditorTab,
+                        Target::Widget(active),
+                    ));
+                }
+            }
+            LapceWorkbenchCommand::PreviousEditorTab => {
+                if let Some(active) = *self.main_split.active_tab {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::PreviousEditorTab,
+                        Target::Widget(active),
+                    ));
+                }
+            }
+            LapceWorkbenchCommand::ToggleInlayHints => {
+                let config = Arc::make_mut(&mut self.config);
+                config.editor.enable_inlay_hints = !config.editor.enable_inlay_hints;
+                LapceConfig::update_file(
+                    "editor",
+                    "enable-inlay-hints",
+                    toml_edit::Value::from(config.editor.enable_inlay_hints),
+                );
+            }
+            LapceWorkbenchCommand::NewTerminalTab => {
+                let terminal_panel = Arc::make_mut(&mut self.terminal);
+                terminal_panel.new_tab(
+                    self.workspace.clone(),
+                    self.proxy.clone(),
+                    &self.config,
+                    ctx.get_external_handle(),
+                );
+                if !self.panel.is_panel_visible(&PanelKind::Terminal) {
+                    Arc::make_mut(&mut self.panel).show_panel(&PanelKind::Terminal);
+                }
+            }
+            LapceWorkbenchCommand::NextTerminalTab => {
+                let terminal_panel = Arc::make_mut(&mut self.terminal);
+                if terminal_panel.active >= terminal_panel.tabs_order.len() - 1 {
+                    terminal_panel.active = 0;
+                } else {
+                    terminal_panel.active += 1;
+                }
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::Focus,
+                    Target::Widget(terminal_panel.widget_id),
+                ));
+            }
+            LapceWorkbenchCommand::PreviousTerminalTab => {
+                let terminal_panel = Arc::make_mut(&mut self.terminal);
+                if terminal_panel.active == 0 {
+                    terminal_panel.active =
+                        terminal_panel.tabs_order.len().saturating_sub(1);
+                } else {
+                    terminal_panel.active -= 1;
+                }
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::Focus,
+                    Target::Widget(terminal_panel.widget_id),
+                ));
+            }
+            LapceWorkbenchCommand::CloseTerminalTab => {
+                let split_id = data
+                    .and_then(|d| serde_json::from_value::<usize>(d).ok())
+                    .map(WidgetId::from_usize);
+                let split_id = split_id
+                    .or_else(|| {
+                        self.terminal.active_terminal_split().map(|s| s.split_id)
+                    })
+                    .unwrap_or_else(WidgetId::next);
+                let terminal_panel = Arc::make_mut(&mut self.terminal);
+                terminal_panel.tabs.remove(&split_id);
+                terminal_panel.tabs_order = Arc::new(
+                    terminal_panel
+                        .tabs_order
+                        .iter()
+                        .filter(|w| *w != &split_id)
+                        .copied()
+                        .collect(),
+                );
+                if terminal_panel.tabs_order.is_empty() {
+                    if self.panel.is_panel_visible(&PanelKind::Terminal) {
+                        Arc::make_mut(&mut self.panel)
+                            .hide_panel(&PanelKind::Terminal);
+                    }
+                    if let Some(active) = *self.main_split.active_tab {
+                        ctx.submit_command(Command::new(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::Focus,
+                            Target::Widget(active),
+                        ));
+                    }
+                } else {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::Focus,
+                        Target::Widget(terminal_panel.widget_id),
+                    ));
+                }
+            }
+            LapceWorkbenchCommand::ShowAbout => {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::ShowAbout,
+                    Target::Widget(self.id),
+                ));
+            }
+            LapceWorkbenchCommand::SaveAll => {
+                let mut paths = HashSet::new();
+                for (_, editor) in self.main_split.editors.iter() {
+                    if let BufferContent::File(path) = &editor.content {
+                        if paths.contains(path) {
+                            continue;
+                        }
+                        paths.insert(path.to_path_buf());
+                        if let Some(doc) = self.main_split.open_docs.get(path) {
+                            if !doc.buffer().is_pristine() {
+                                ctx.submit_command(Command::new(
+                                    LAPCE_COMMAND,
+                                    LapceCommand {
+                                        kind: CommandKind::Focus(FocusCommand::Save),
+                                        data: None,
+                                    },
+                                    Target::Widget(editor.view_id),
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+            #[cfg(target_os = "macos")]
+            LapceWorkbenchCommand::InstallToPATH => {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::RunCommand(
+                        String::from("osascript"),
+                        vec![
+                            String::from("-e"),
+                            format!("do shell script \"ln -sf '{}' /usr/local/bin/lapce\" with administrator privileges", std::env::args().next().unwrap())
+                        ]),
+                    Target::Widget(self.id),
+                ));
+            }
+            #[cfg(target_os = "macos")]
+            LapceWorkbenchCommand::UninstallFromPATH => {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::RunCommand(
+                        String::from("osascript"),
+                        vec![
+                            String::from("-e"),
+                            String::from("do shell script \"rm /usr/local/bin/lapce\" with administrator privileges")
+                        ]),
+                    Target::Widget(self.id),
+                ));
+            }
+            LapceWorkbenchCommand::Quit => {
+                ctx.submit_command(druid::commands::QUIT_APP);
+            }
         }
     }
 
@@ -1357,18 +2045,26 @@ impl LapceTabData {
                     env,
                 );
             }
-            CommandKind::Focus(_cmd) => {
-                ctx.submit_command(Command::new(
-                    LAPCE_COMMAND,
-                    command.clone(),
-                    Target::Widget(self.focus),
-                ));
-            }
-            CommandKind::Edit(_) => {
+            CommandKind::Focus(_) | CommandKind::Edit(_) | CommandKind::Move(_) => {
+                let widget_id = if *self.focus != self.palette.input_editor {
+                    *self.focus
+                } else if let Some(active_tab) = self.main_split.active_tab.as_ref()
+                {
+                    self.main_split
+                        .editor_tabs
+                        .get(active_tab)
+                        .unwrap()
+                        .active_child()
+                        .map(|c| c.widget_id())
+                        .unwrap_or(*self.focus)
+                } else {
+                    *self.focus
+                };
+
                 ctx.submit_command(Command::new(
                     LAPCE_COMMAND,
                     command.clone(),
-                    Target::Widget(self.focus),
+                    Target::Widget(widget_id),
                 ));
             }
             _ => {}
@@ -1405,7 +2101,7 @@ impl LapceTabData {
                 }
                 TermEvent::UpdateContent(content) => {
                     if let Some(raw) = terminals.get_mut(&term_id) {
-                        raw.lock().update_content(&content);
+                        raw.lock().update_content(content);
                         last_event = receiver.try_recv().ok();
                         if last_event.is_some() {
                             if last_redraw.elapsed().as_millis() > 10 {
@@ -1430,30 +2126,15 @@ impl LapceTabData {
         }
     }
 
-    fn is_panel_visible(&self, kind: PanelKind) -> bool {
-        for (_, panel) in self.panels.iter() {
-            if panel.widgets.contains(&kind) {
-                return panel.active == kind && panel.shown;
-            }
-        }
-
-        false
-    }
-
     fn is_panel_focused(&self, kind: PanelKind) -> bool {
         // Moving between e.g. Search and Problems doesn't affect focus, so we need to also check
         // visibility.
-        self.focus_area == FocusArea::Panel(kind) && self.is_panel_visible(kind)
+        self.focus_area == FocusArea::Panel(kind)
+            && self.panel.is_panel_visible(&kind)
     }
 
     fn hide_panel(&mut self, ctx: &mut EventCtx, kind: PanelKind) {
-        for (_, panel) in self.panels.iter_mut() {
-            if panel.active == kind {
-                let panel = Arc::make_mut(panel);
-                panel.shown = false;
-                break;
-            }
-        }
+        Arc::make_mut(&mut self.panel).hide_panel(&kind);
         if let Some(active) = *self.main_split.active_tab {
             ctx.submit_command(Command::new(
                 LAPCE_UI_COMMAND,
@@ -1463,44 +2144,37 @@ impl LapceTabData {
         }
     }
 
-    fn show_panel(&mut self, ctx: &mut EventCtx, kind: PanelKind) {
-        for (_, panel) in self.panels.iter_mut() {
-            if panel.widgets.contains(&kind) {
-                let panel = Arc::make_mut(panel);
-                panel.shown = true;
-                panel.active = kind;
-                let focus_id = match kind {
-                    PanelKind::FileExplorer => self.file_explorer.widget_id,
-                    PanelKind::SourceControl => self.source_control.active,
-                    PanelKind::Plugin => self.plugin.widget_id,
-                    PanelKind::Terminal => self.terminal.widget_id,
-                    PanelKind::Search => self.search.active,
-                    PanelKind::Problem => self.problem.widget_id,
-                };
-                if let PanelKind::Search = kind {
-                    ctx.submit_command(Command::new(
-                        LAPCE_COMMAND,
-                        LapceCommand {
-                            kind: CommandKind::MultiSelection(
-                                MultiSelectionCommand::SelectAll,
-                            ),
-                            data: None,
-                        },
-                        Target::Widget(focus_id),
-                    ));
-                }
-                ctx.submit_command(Command::new(
-                    LAPCE_UI_COMMAND,
-                    LapceUICommand::Focus,
-                    Target::Widget(focus_id),
-                ));
-                break;
-            }
+    pub fn show_panel(&mut self, ctx: &mut EventCtx, kind: PanelKind) {
+        Arc::make_mut(&mut self.panel).show_panel(&kind);
+        let focus_id = match kind {
+            PanelKind::FileExplorer => self.file_explorer.widget_id,
+            PanelKind::SourceControl => self.source_control.active,
+            PanelKind::Plugin => self.plugin.widget_id,
+            PanelKind::Terminal => self.terminal.widget_id,
+            PanelKind::Search => self.search.active,
+            PanelKind::Problem => self.problem.widget_id,
+        };
+        if let PanelKind::Search = kind {
+            ctx.submit_command(Command::new(
+                LAPCE_COMMAND,
+                LapceCommand {
+                    kind: CommandKind::MultiSelection(
+                        MultiSelectionCommand::SelectAll,
+                    ),
+                    data: None,
+                },
+                Target::Widget(focus_id),
+            ));
         }
+        ctx.submit_command(Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::Focus,
+            Target::Widget(focus_id),
+        ));
     }
 
     fn toggle_panel_visual(&mut self, ctx: &mut EventCtx, kind: PanelKind) {
-        if self.is_panel_visible(kind) {
+        if self.panel.is_panel_visible(&kind) {
             self.hide_panel(ctx, kind);
         } else {
             self.show_panel(ctx, kind);
@@ -1512,7 +2186,7 @@ impl LapceTabData {
             PanelKind::FileExplorer | PanelKind::Plugin | PanelKind::Problem => {
                 // Some panels don't accept focus (yet). Fall back to visibility check
                 // in those cases.
-                self.is_panel_visible(kind)
+                self.panel.is_panel_visible(&kind)
             }
             PanelKind::Terminal | PanelKind::SourceControl | PanelKind::Search => {
                 self.is_panel_focused(kind)
@@ -1525,6 +2199,40 @@ impl LapceTabData {
         }
     }
 
+    pub fn toggle_container_visual(
+        &mut self,
+        ctx: &mut EventCtx,
+        position: &PanelContainerPosition,
+    ) {
+        let shown = !self.panel.is_container_shown(position);
+        let panel = Arc::make_mut(&mut self.panel);
+        panel.set_shown(&position.first(), shown);
+        panel.set_shown(&position.second(), shown);
+        if shown {
+            if let Some((kind, _)) =
+                self.panel.active_panel_at_position(&position.second())
+            {
+                self.show_panel(ctx, kind);
+            }
+            if let Some((kind, _)) =
+                self.panel.active_panel_at_position(&position.first())
+            {
+                self.show_panel(ctx, kind);
+            }
+        } else {
+            if let Some((kind, _)) =
+                self.panel.active_panel_at_position(&position.second())
+            {
+                self.hide_panel(ctx, kind);
+            }
+            if let Some((kind, _)) =
+                self.panel.active_panel_at_position(&position.first())
+            {
+                self.hide_panel(ctx, kind);
+            }
+        }
+    }
+
     pub fn read_picker_pwd(&mut self, ctx: &mut EventCtx) {
         let path = self.picker.pwd.clone();
         let event_sink = ctx.get_external_handle();
@@ -1549,7 +2257,7 @@ impl LapceTabData {
                 .get_mut(&self.picker.editor_view_id)
                 .unwrap();
             let editor = Arc::make_mut(editor);
-            editor.cursor = if self.config.lapce.modal {
+            editor.cursor = if self.config.core.modal {
                 Cursor::new(
                     CursorMode::Normal(doc.buffer().line_end_offset(0, false)),
                     None,
@@ -1567,39 +2275,8 @@ impl LapceTabData {
         }
     }
 
-    pub fn handle_file_change(&mut self, ctx: &mut EventCtx, event: &notify::Event) {
-        if self.file_explorer.workspace.is_some() {
-            match &event.kind {
-                notify::EventKind::Create(_)
-                | notify::EventKind::Modify(notify::event::ModifyKind::Name(_))
-                | notify::EventKind::Remove(_) => {
-                    for path in event.paths.iter() {
-                        if let Some(path) = path.parent() {
-                            FileExplorerData::read_dir(
-                                path,
-                                false,
-                                self.id,
-                                &self.proxy,
-                                ctx.get_external_handle(),
-                            );
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        // let doc = self
-        //     .main_split
-        //     .local_docs
-        //     .get_mut(&LocalBufferKind::Search)
-        //     .unwrap();
-        // let pattern = doc.buffer().text().to_string();
-        // ctx.submit_command(Command::new(
-        //     LAPCE_UI_COMMAND,
-        //     LapceUICommand::UpdateSearch(pattern),
-        //     Target::Widget(self.id),
-        // ));
+    pub fn handle_workspace_file_change(&self, _ctx: &mut EventCtx) {
+        self.file_explorer.reload();
     }
 }
 
@@ -1622,9 +2299,19 @@ impl Lens<LapceWindowData, LapceTabData> for LapceTabLens {
     ) -> V {
         let mut tab = data.tabs.get(&self.0).unwrap().clone();
         tab.keypress = data.keypress.clone();
-        tab.plugins = data.plugins.clone();
+        tab.latest_release = data.latest_release.clone();
+        tab.log_file = data.log_file.clone();
+        tab.update_in_progress = data.update_in_progress;
+        tab.log_file = data.log_file.clone();
+        tab.multiple_tab = data.tabs.len() > 1;
+        if !tab.panel.order.same(&data.panel_orders) {
+            Arc::make_mut(&mut tab.panel).order = data.panel_orders.clone();
+        }
         let result = f(&mut tab);
         data.keypress = tab.keypress.clone();
+        if !tab.panel.order.same(&data.panel_orders) {
+            data.panel_orders = tab.panel.order.clone();
+        }
         if !tab.same(data.tabs.get(&self.0).unwrap()) {
             data.tabs.insert(self.0, tab);
         }
@@ -1651,8 +2338,12 @@ impl Lens<LapceData, LapceWindowData> for LapceWindowLens {
     ) -> V {
         let mut win = data.windows.get(&self.0).unwrap().clone();
         win.keypress = data.keypress.clone();
+        win.latest_release = data.latest_release.clone();
+        win.update_in_progress = data.update_in_process;
+        win.panel_orders = data.panel_orders.clone();
         let result = f(&mut win);
         data.keypress = win.keypress.clone();
+        data.panel_orders = win.panel_orders.clone();
         if !win.same(data.windows.get(&self.0).unwrap()) {
             data.windows.insert(self.0, win);
         }
@@ -1660,7 +2351,7 @@ impl Lens<LapceData, LapceWindowData> for LapceWindowLens {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum SplitContent {
     EditorTab(WidgetId),
     Split(WidgetId),
@@ -1716,7 +2407,7 @@ impl SplitContent {
     }
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum EditorSplitContent {}
 
 #[derive(Clone, Debug)]
@@ -1777,6 +2468,8 @@ pub struct LapceMainSplitData {
     pub warning_count: usize,
     pub workspace: Arc<LapceWorkspace>,
     pub db: Arc<LapceDb>,
+    pub locations: Arc<Vec<EditorLocation>>,
+    pub current_location: usize,
 }
 
 impl LapceMainSplitData {
@@ -1798,6 +2491,20 @@ impl LapceMainSplitData {
         }
     }
 
+    pub fn content_doc_mut(
+        &mut self,
+        content: &BufferContent,
+    ) -> &mut Arc<Document> {
+        match content {
+            BufferContent::File(path) => self.open_docs.get_mut(path).unwrap(),
+            BufferContent::Local(kind) => self.local_docs.get_mut(kind).unwrap(),
+            BufferContent::SettingsValue(name, ..) => {
+                self.value_docs.get_mut(name).unwrap()
+            }
+            BufferContent::Scratch(id, _) => self.scratch_docs.get_mut(id).unwrap(),
+        }
+    }
+
     pub fn editor_doc(&self, editor_view_id: WidgetId) -> Arc<Document> {
         let editor = self.editors.get(&editor_view_id).unwrap();
         self.content_doc(&editor.content)
@@ -1807,33 +2514,29 @@ impl LapceMainSplitData {
         &mut self,
         path: &Path,
         rev: u64,
-        result: &Result<Value>,
+        edits: &Result<Vec<TextEdit>>,
     ) {
         let doc = self.open_docs.get(path).unwrap();
         if doc.rev() != rev {
             return;
         }
 
-        if let Ok(res) = result {
-            let edits: Result<Vec<TextEdit>, serde_json::Error> =
-                serde_json::from_value(res.clone());
-            if let Ok(edits) = edits {
-                if !edits.is_empty() {
-                    let doc = self.open_docs.get_mut(path).unwrap();
-
-                    let edits: Vec<(Selection, &str)> = edits
-                        .iter()
-                        .map(|edit| {
-                            let selection = Selection::region(
-                                doc.buffer().offset_of_position(&edit.range.start),
-                                doc.buffer().offset_of_position(&edit.range.end),
-                            );
-                            (selection, edit.new_text.as_str())
-                        })
-                        .collect();
+        if let Ok(edits) = edits {
+            if !edits.is_empty() {
+                let doc = self.open_docs.get_mut(path).unwrap();
 
-                    self.edit(path, &edits, EditType::Other);
-                }
+                let edits = edits
+                    .iter()
+                    .map(|edit| {
+                        let start =
+                            doc.buffer().offset_of_position(&edit.range.start);
+                        let end = doc.buffer().offset_of_position(&edit.range.end);
+                        let selection = Selection::region(start, end);
+                        (selection, edit.new_text.as_str())
+                    })
+                    .collect::<Vec<(Selection, &str)>>();
+
+                self.edit(path, &edits, EditType::Other);
             }
         }
     }
@@ -1843,7 +2546,7 @@ impl LapceMainSplitData {
         ctx: &mut EventCtx,
         path: &Path,
         rev: u64,
-        result: &Result<Value>,
+        result: &Result<Vec<TextEdit>>,
         exit_widget_id: Option<WidgetId>,
     ) {
         self.document_format(path, rev, result);
@@ -1858,66 +2561,63 @@ impl LapceMainSplitData {
     ) {
         let doc = self.open_docs.get(path).unwrap();
         let rev = doc.rev();
-        let buffer_id = doc.id();
         let event_sink = ctx.get_external_handle();
         let path = PathBuf::from(path);
-        self.proxy.save(
+        let tab_id = *self.tab_id;
+        self.proxy.proxy_rpc.save(
             rev,
-            buffer_id,
+            path.clone(),
             Box::new(move |result| {
-                if let Ok(_r) = result {
+                if let Ok(ProxyResponse::SaveResponse {}) = result {
                     let _ = event_sink.submit_command(
                         LAPCE_UI_COMMAND,
-                        LapceUICommand::BufferSave(path, rev, exit_widget_id),
-                        Target::Auto,
+                        LapceUICommand::BufferSave {
+                            path,
+                            rev,
+                            exit: exit_widget_id,
+                        },
+                        Target::Widget(tab_id),
                     );
                 }
             }),
         );
     }
 
-    fn initiate_diagnostics_offset(&mut self, path: &Path) {
-        if let Some(diagnostics) = self.diagnostics.get_mut(path) {
-            if let Some(doc) = self.open_docs.get(path) {
-                for diagnostic in Arc::make_mut(diagnostics).iter_mut() {
-                    if diagnostic.range.is_none() {
-                        diagnostic.range = Some((
-                            doc.buffer().offset_of_position(
-                                &diagnostic.diagnostic.range.start,
-                            ),
-                            doc.buffer().offset_of_position(
-                                &diagnostic.diagnostic.range.end,
-                            ),
-                        ));
-                    }
+    pub fn diagnostics_items(
+        &self,
+        severity: DiagnosticSeverity,
+    ) -> Vec<(&PathBuf, Vec<&EditorDiagnostic>)> {
+        self.diagnostics
+            .iter()
+            .filter_map(|(path, diagnostic)| {
+                if let Some(doc) = self.open_docs.get(path) {
+                    return match doc.diagnostics.as_ref() {
+                        Some(d) => {
+                            let diagnostics: Vec<&EditorDiagnostic> = d
+                                .iter()
+                                .filter(|d| d.diagnostic.severity == Some(severity))
+                                .collect();
+                            if !diagnostics.is_empty() {
+                                Some((path, diagnostics))
+                            } else {
+                                None
+                            }
+                        }
+                        None => None,
+                    };
                 }
-            }
-        }
-    }
-
-    fn update_diagnostics_offset(&mut self, path: &Path, delta: &RopeDelta) {
-        if let Some(diagnostics) = self.diagnostics.get_mut(path) {
-            if let Some(doc) = self.open_docs.get(path) {
-                let mut transformer = Transformer::new(delta);
-                for diagnostic in Arc::make_mut(diagnostics).iter_mut() {
-                    let (start, end) = diagnostic.range.unwrap();
-                    let (new_start, new_end) = (
-                        transformer.transform(start, false),
-                        transformer.transform(end, true),
-                    );
-                    diagnostic.range = Some((new_start, new_end));
-                    if start != new_start {
-                        diagnostic.diagnostic.range.start =
-                            doc.buffer().offset_to_position(new_start);
-                    }
-                    if end != new_end {
-                        diagnostic.diagnostic.range.end =
-                            doc.buffer().offset_to_position(new_end);
-                        doc.buffer().offset_to_position(new_end);
-                    }
+                let diagnostics: Vec<&EditorDiagnostic> = diagnostic
+                    .iter()
+                    .filter(|d| d.diagnostic.severity == Some(severity))
+                    .collect();
+                if !diagnostics.is_empty() {
+                    Some((path, diagnostics))
+                } else {
+                    None
                 }
-            }
-        }
+            })
+            .sorted_by_key(|(path, _)| *path)
+            .collect()
     }
 
     fn cursor_apply_delta(&mut self, path: &Path, delta: &RopeDelta) {
@@ -1936,7 +2636,6 @@ impl LapceMainSplitData {
         edits: &[(impl AsRef<Selection>, &str)],
         edit_type: EditType,
     ) -> Option<RopeDelta> {
-        self.initiate_diagnostics_offset(path);
         let doc = self.open_docs.get_mut(path)?;
 
         let buffer_len = doc.buffer().len();
@@ -1951,11 +2650,10 @@ impl LapceMainSplitData {
             }
         }
 
-        let (delta, _) = Arc::make_mut(doc).do_raw_edit(edits, edit_type);
+        let (delta, _, _) = Arc::make_mut(doc).do_raw_edit(edits, edit_type);
         if move_cursor {
             self.cursor_apply_delta(path, &delta);
         }
-        self.update_diagnostics_offset(path, &delta);
         Some(delta)
     }
 
@@ -1971,7 +2669,7 @@ impl LapceMainSplitData {
                 widget_id: WidgetId::next(),
                 split: *self.split_id,
                 active: 0,
-                children: vec![],
+                children: Vector::new(),
                 layout_rect: Rc::new(RefCell::new(Rect::ZERO)),
                 content_is_hot: Rc::new(RefCell::new(false)),
             };
@@ -2013,7 +2711,7 @@ impl LapceMainSplitData {
             widget_id: editor_tab_id,
             split: split_id,
             active: 0,
-            children: vec![],
+            children: Vector::new(),
             layout_rect: Rc::new(RefCell::new(Rect::ZERO)),
             content_is_hot: Rc::new(RefCell::new(false)),
         };
@@ -2038,11 +2736,25 @@ impl LapceMainSplitData {
         &mut self,
         _ctx: &mut EventCtx,
         editor_tab_id: WidgetId,
+        config: &LapceConfig,
     ) -> WidgetId {
         let editor_tab = self.editor_tabs.get_mut(&editor_tab_id).unwrap();
         let editor_tab = Arc::make_mut(editor_tab);
-        let child = EditorTabChild::Settings(WidgetId::next(), editor_tab_id);
-        editor_tab.children.push(child.clone());
+        let editor = LapceEditorData::new(
+            None,
+            None,
+            None,
+            BufferContent::Local(LocalBufferKind::Keymap),
+            config,
+        );
+        let keymap_input_view_id = editor.view_id;
+        self.editors.insert(editor.view_id, Arc::new(editor));
+        let child = EditorTabChild::Settings {
+            settings_widget_id: WidgetId::next(),
+            editor_tab_id,
+            keymap_input_view_id,
+        };
+        editor_tab.children.push_back(child.clone());
         child.widget_id()
     }
 
@@ -2050,7 +2762,7 @@ impl LapceMainSplitData {
         &mut self,
         _ctx: &mut EventCtx,
         editor_tab_id: WidgetId,
-        config: &Config,
+        config: &LapceConfig,
     ) -> WidgetId {
         let editor_tab = self.editor_tabs.get_mut(&editor_tab_id).unwrap();
         let editor_tab = Arc::make_mut(editor_tab);
@@ -2061,7 +2773,7 @@ impl LapceMainSplitData {
             BufferContent::Local(LocalBufferKind::Empty),
             config,
         ));
-        editor_tab.children.push(EditorTabChild::Editor(
+        editor_tab.children.push_back(EditorTabChild::Editor(
             editor.view_id,
             editor.editor_id,
             editor.find_view_id,
@@ -2074,41 +2786,104 @@ impl LapceMainSplitData {
         &mut self,
         ctx: &mut EventCtx,
         editor_tab_id: WidgetId,
+        same_tab: bool,
         path: Option<PathBuf>,
         scratch: bool,
-        config: &Config,
+        config: &LapceConfig,
     ) -> &mut LapceEditorData {
-        let editor_tab =
-            Arc::make_mut(self.editor_tabs.get_mut(&editor_tab_id).unwrap());
-
-        if !config.editor.show_tab || (path.is_none() && !scratch) {
-            if let EditorTabChild::Editor(id, _, _) = editor_tab.active_child() {
+        // If you're asking for no specific path, and you don't want scratch, then we just give you
+        // the editor data for the tab id you're asking for.
+        if path.is_none() && !scratch {
+            let editor_tab = self.editor_tabs.get(&editor_tab_id).unwrap();
+            if let Some(EditorTabChild::Editor(id, _, _)) = editor_tab.active_child()
+            {
                 return Arc::make_mut(self.editors.get_mut(id).unwrap());
             }
         }
 
         let mut editor_size = Size::ZERO;
-        for (i, child) in editor_tab.children.iter().enumerate() {
-            if let EditorTabChild::Editor(id, _, _) = child {
-                let editor = self.editors.get(id).unwrap();
-                let current_size = *editor.size.borrow();
-                if current_size.height > 0.0 {
-                    editor_size = current_size;
-                }
-                if let Some(path) = path.as_ref() {
-                    if editor.content == BufferContent::File(path.clone()) {
-                        editor_tab.active = i;
-                        ctx.submit_command(Command::new(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::Focus,
-                            Target::Widget(*id),
-                        ));
-                        return Arc::make_mut(self.editors.get_mut(id).unwrap());
+        let editor_tabs: Box<
+            dyn Iterator<Item = (&WidgetId, &mut Arc<LapceEditorTabData>)>,
+        > = if same_tab {
+            // If you want the same tab, then we'll only look at the tab you're asking for.
+            Box::new(
+                vec![(
+                    &editor_tab_id,
+                    self.editor_tabs.get_mut(&editor_tab_id).unwrap(),
+                )]
+                .into_iter(),
+            )
+        } else {
+            // Otherwise, we look at all the open tabs available
+            Box::new(self.editor_tabs.iter_mut().sorted_by(|(_, a), (_, b)| {
+                // Sort the active tab to the start of the iterator
+                if Some(a.widget_id) == *self.active_tab {
+                    return Ordering::Less;
+                }
+                if Some(b.widget_id) == *self.active_tab {
+                    return Ordering::Greater;
+                }
+                let a_rect = a.layout_rect.borrow();
+                let b_rect = b.layout_rect.borrow();
+
+                // Sort by the start position of the tab
+                if a_rect.y0 == b_rect.y0 {
+                    a_rect.x0.total_cmp(&b_rect.x0)
+                } else {
+                    a_rect.y0.total_cmp(&b_rect.y0)
+                }
+            }))
+        };
+
+        // Look for any editor tabs in our 'allowed set' that have the same path, and simply use
+        // that editor tab instead of creating a new one.
+        for (_, editor_tab) in editor_tabs {
+            let editor_tab = Arc::make_mut(editor_tab);
+            for (i, child) in editor_tab.children.iter().enumerate() {
+                if let EditorTabChild::Editor(id, _, _) = child {
+                    let editor = self.editors.get(id).unwrap();
+                    let current_size = *editor.size.borrow();
+                    if current_size.height > 0.0 {
+                        editor_size = current_size;
+                    }
+
+                    if let Some(path) = path.as_ref() {
+                        if editor.content == BufferContent::File(path.clone()) {
+                            editor_tab.active = i;
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::Focus,
+                                Target::Widget(*id),
+                            ));
+                            return Arc::make_mut(self.editors.get_mut(id).unwrap());
+                        }
+                    }
+                }
+            }
+        }
+
+        // If we're not showing tabs, or we're just asking for non-specific-path and non-scratch
+        // editors, then we'll return the active editor if it is pristine.
+        if !config.editor.show_tab || (path.is_none() && !scratch) {
+            let editor_tab =
+                Arc::make_mut(self.editor_tabs.get_mut(&editor_tab_id).unwrap());
+            if let Some(EditorTabChild::Editor(id, _, _)) = editor_tab.active_child()
+            {
+                let editor = self.editors.get_mut(id).unwrap();
+                if let BufferContent::File(path) = &editor.content {
+                    if let Some(doc) = self.open_docs.get(path) {
+                        if doc.buffer().is_pristine() {
+                            return Arc::make_mut(self.editors.get_mut(id).unwrap());
+                        }
                     }
                 }
             }
         }
 
+        // We didn't find an open editor that met our specifications, so we'll just have to create
+        // one.
+        let editor_tab =
+            Arc::make_mut(self.editor_tabs.get_mut(&editor_tab_id).unwrap());
         let new_editor = Arc::new(LapceEditorData::new(
             None,
             None,
@@ -2148,20 +2923,27 @@ impl LapceMainSplitData {
         return Arc::make_mut(self.editors.get_mut(&new_editor.view_id).unwrap());
     }
 
+    /// If the supplied `editor_view_id` is some, then this simply returns the editor data for it.  
+    /// Otherwise, we check the active tab (and friends if `same_tab` is false) to see if there is
+    /// an existing editor that matches the parameters. If not, we create a new editor.  
+    /// Note that this does not load the file into the editor. See
+    /// [`LapceMainSplitData::jump_to_location`] or [`LapceMainSplitData::go_to_location`] for
+    /// creating the editor and loading the file.
     fn get_editor_or_new(
         &mut self,
         ctx: &mut EventCtx,
         editor_view_id: Option<WidgetId>,
+        same_tab: bool,
         path: Option<PathBuf>,
         scratch: bool,
-        config: &Config,
+        config: &LapceConfig,
     ) -> &mut LapceEditorData {
         match editor_view_id {
             Some(view_id) => Arc::make_mut(self.editors.get_mut(&view_id).unwrap()),
             None => match *self.active_tab {
-                Some(active) => {
-                    self.get_editor_from_tab(ctx, active, path, scratch, config)
-                }
+                Some(active) => self.get_editor_from_tab(
+                    ctx, active, same_tab, path, scratch, config,
+                ),
                 None => {
                     let editor_tab_id = self.new_editor_tab(ctx, *self.split_id);
                     let view_id =
@@ -2176,30 +2958,99 @@ impl LapceMainSplitData {
         &mut self,
         ctx: &mut EventCtx,
         editor_view_id: Option<WidgetId>,
+        same_tab: bool,
         position: Position,
-        config: &Config,
+        config: &LapceConfig,
     ) {
-        let editor =
-            self.get_editor_or_new(ctx, editor_view_id, None, false, config);
-        if let BufferContent::File(path) = &editor.content {
+        let editor = self.get_editor_or_new(
+            ctx,
+            editor_view_id,
+            same_tab,
+            None,
+            false,
+            config,
+        );
+        let path = if let BufferContent::File(path) = &editor.content {
+            Some(path.clone())
+        } else {
+            None
+        };
+
+        if let Some(path) = path {
             let location = EditorLocation {
-                path: path.clone(),
+                path,
                 position: Some(position),
                 scroll_offset: None,
                 history: None,
             };
-            self.jump_to_location(ctx, editor_view_id, location, config);
+            self.jump_to_location(ctx, editor_view_id, same_tab, location, config);
+        }
+    }
+
+    /// Open the plugin information view, which display's the plugins readme, repo, and other
+    /// related bits
+    pub fn open_plugin_info(&mut self, ctx: &mut EventCtx, volt: &VoltInfo) {
+        let editor_tab_id = self
+            .active_tab
+            .as_ref()
+            .unwrap_or_else(|| self.new_editor_tab(ctx, *self.split_id));
+
+        let editor_tab =
+            Arc::make_mut(self.editor_tabs.get_mut(&editor_tab_id).unwrap());
+
+        let open_volt_id = volt.id();
+        let mut existing: Option<WidgetId> = None;
+        for (i, child) in editor_tab.children.iter().enumerate() {
+            if let EditorTabChild::Plugin { volt_id, .. } = child {
+                if &open_volt_id == volt_id {
+                    editor_tab.active = i;
+                    existing = Some(child.widget_id());
+                    break;
+                }
+            }
         }
+
+        let widget_id = existing.unwrap_or_else(|| {
+            let child = EditorTabChild::Plugin {
+                widget_id: WidgetId::next(),
+                volt_id: volt.id(),
+                volt_name: volt.display_name.clone(),
+                editor_tab_id: editor_tab.widget_id,
+            };
+
+            let new_tab = editor_tab.children.is_empty();
+            let index = if new_tab { 0 } else { editor_tab.active + 1 };
+            editor_tab.children.insert(index, child.clone());
+            if !new_tab {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::EditorTabAdd(index, child.clone()),
+                    Target::Widget(editor_tab.widget_id),
+                ));
+            }
+            editor_tab.active = index;
+            child.widget_id()
+        });
+        ctx.submit_command(Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::Focus,
+            Target::Widget(widget_id),
+        ));
     }
 
-    pub fn open_settings(&mut self, ctx: &mut EventCtx, show_key_bindings: bool) {
+    pub fn open_settings(
+        &mut self,
+        ctx: &mut EventCtx,
+        show_key_bindings: bool,
+        config: &LapceConfig,
+    ) {
         let widget_id = match *self.active_tab {
             Some(active) => {
                 let editor_tab =
                     Arc::make_mut(self.editor_tabs.get_mut(&active).unwrap());
                 let mut existing: Option<WidgetId> = None;
                 for (i, child) in editor_tab.children.iter().enumerate() {
-                    if let EditorTabChild::Settings(_, _) = child {
+                    if let EditorTabChild::Settings { .. } = child {
                         editor_tab.active = i;
                         existing = Some(child.widget_id());
                         break;
@@ -2209,10 +3060,20 @@ impl LapceMainSplitData {
                 if let Some(widget_id) = existing {
                     widget_id
                 } else {
-                    let child = EditorTabChild::Settings(
-                        WidgetId::next(),
-                        editor_tab.widget_id,
+                    let editor = LapceEditorData::new(
+                        None,
+                        None,
+                        None,
+                        BufferContent::Local(LocalBufferKind::Keymap),
+                        config,
                     );
+                    let keymap_input_view_id = editor.view_id;
+                    self.editors.insert(editor.view_id, Arc::new(editor));
+                    let child = EditorTabChild::Settings {
+                        settings_widget_id: WidgetId::next(),
+                        editor_tab_id: editor_tab.widget_id,
+                        keymap_input_view_id,
+                    };
                     editor_tab
                         .children
                         .insert(editor_tab.active + 1, child.clone());
@@ -2230,7 +3091,7 @@ impl LapceMainSplitData {
             }
             None => {
                 let editor_tab_id = self.new_editor_tab(ctx, *self.split_id);
-                self.editor_tab_new_settings(ctx, editor_tab_id)
+                self.editor_tab_new_settings(ctx, editor_tab_id, config)
             }
         };
         ctx.submit_command(Command::new(
@@ -2253,35 +3114,112 @@ impl LapceMainSplitData {
         }
     }
 
-    pub fn jump_to_location(
+    /// Jump to a specific location, getting/creating the editor as needed.
+    pub fn jump_to_location<P: EditorPosition + Send + 'static>(
+        &mut self,
+        ctx: &mut EventCtx,
+        editor_view_id: Option<WidgetId>,
+        same_tab: bool,
+        location: EditorLocation<P>,
+        config: &LapceConfig,
+    ) -> WidgetId {
+        self.jump_to_location_cb::<P, fn(&mut EventCtx, &mut LapceMainSplitData)>(
+            ctx,
+            editor_view_id,
+            same_tab,
+            location,
+            config,
+            None,
+        )
+    }
+
+    /// Jump to a specific location, getting/creating the editor as needed.  
+    /// This version allows a callback which will be called once the buffer is loaded.
+    pub fn jump_to_location_cb<
+        P: EditorPosition + Send + 'static,
+        F: Fn(&mut EventCtx, &mut LapceMainSplitData) + Send + 'static,
+    >(
         &mut self,
         ctx: &mut EventCtx,
         editor_view_id: Option<WidgetId>,
-        location: EditorLocation,
-        config: &Config,
+        same_tab: bool,
+        location: EditorLocation<P>,
+        config: &LapceConfig,
+        cb: Option<F>,
     ) -> WidgetId {
+        // If there's an active editor tab, save the jump location so that the user can quickly go
+        // back to it using the jump commands
+        if let Some(active_tab) = self.active_tab.as_ref() {
+            let editor_tab = self.editor_tabs.get(active_tab).unwrap();
+            if let Some(EditorTabChild::Editor(view_id, _, _)) =
+                editor_tab.active_child()
+            {
+                let editor = self.editors.get(view_id).unwrap();
+                if let BufferContent::File(path) = &editor.content {
+                    self.save_jump_location(
+                        path.to_path_buf(),
+                        editor.cursor.offset(),
+                        editor.scroll_offset,
+                    );
+                }
+            }
+        }
+        // Get an existing editor for the file, if it exists, otherwise create a new one
         let editor_view_id = self
             .get_editor_or_new(
                 ctx,
                 editor_view_id,
+                same_tab,
                 Some(location.path.clone()),
                 false,
                 config,
             )
             .view_id;
-        let doc = self.editor_doc(editor_view_id);
-        let editor = self.get_editor_or_new(
+        // Actually jump to the requisite location in our constructed editor
+        self.go_to_location_cb::<P, F>(
             ctx,
             Some(editor_view_id),
-            Some(location.path.clone()),
-            false,
+            same_tab,
+            location,
             config,
+            cb,
         );
-        editor.save_jump_location(&doc);
-        self.go_to_location(ctx, Some(editor_view_id), location, config);
         editor_view_id
     }
 
+    pub fn can_jump_location_backward(&self) -> bool {
+        self.current_location >= 1
+    }
+
+    pub fn can_jump_location_forward(&self) -> bool {
+        !(self.locations.is_empty()
+            || self.current_location >= self.locations.len() - 1)
+    }
+
+    pub fn save_jump_location(
+        &mut self,
+        path: PathBuf,
+        offset: usize,
+        scroll_offset: Vec2,
+    ) {
+        if let Some(last_location) = self.locations.last() {
+            if last_location.path == path
+                && last_location.position == Some(offset)
+                && last_location.scroll_offset == Some(scroll_offset)
+            {
+                return;
+            }
+        }
+        let location = EditorLocation {
+            path,
+            position: Some(offset),
+            scroll_offset: Some(scroll_offset),
+            history: None,
+        };
+        Arc::make_mut(&mut self.locations).push(location);
+        self.current_location = self.locations.len();
+    }
+
     fn get_name_for_new_file(&self) -> String {
         const PREFIX: &str = "Untitled-";
 
@@ -2305,36 +3243,46 @@ impl LapceMainSplitData {
             .unwrap_or(0)
             + 1;
 
-        return format!("{}{}", PREFIX, new_num);
+        format!("{PREFIX}{new_num}")
     }
 
-    pub fn install_theme(&mut self, ctx: &mut EventCtx, _config: &Config) {
+    pub fn install_theme(&mut self, ctx: &mut EventCtx, _config: &LapceConfig) {
         let tab = self.get_active_tab_mut(ctx);
-        let child = tab.active_child().clone();
-        match child {
-            EditorTabChild::Editor(view_id, _, _) => {
-                let editor = self.editors.get(&view_id).unwrap();
-                if let BufferContent::File(ref path) = editor.content {
-                    if let Some(folder) = Config::themes_folder() {
-                        if let Some(file_name) = path.file_name() {
-                            let _ = std::fs::copy(path, folder.join(file_name));
+        let child = tab.active_child().cloned();
+        if let Some(child) = child {
+            match child {
+                EditorTabChild::Editor(view_id, _, _) => {
+                    let editor = self.editors.get(&view_id).unwrap();
+                    if let BufferContent::File(ref path) = editor.content {
+                        if let Some(folder) = Directory::themes_directory() {
+                            if let Some(file_name) = path.file_name() {
+                                let _ = std::fs::copy(path, folder.join(file_name));
+                            }
                         }
                     }
                 }
+                EditorTabChild::Settings { .. } => {}
+                EditorTabChild::Plugin { .. } => {}
             }
-            EditorTabChild::Settings(_, _) => {}
         }
     }
 
-    pub fn export_theme(&mut self, ctx: &mut EventCtx, config: &Config) {
+    pub fn export_theme(&mut self, ctx: &mut EventCtx, config: &LapceConfig) {
         let id = self.new_file(ctx, config);
         let doc = self.scratch_docs.get_mut(&id).unwrap();
         let doc = Arc::make_mut(doc);
-        doc.set_language(LapceLanguage::Toml);
+
+        #[cfg(feature = "lang-toml")]
+        doc.set_language(lapce_core::language::LapceLanguage::Toml);
+
         doc.reload(Rope::from(config.export_theme()), true);
     }
 
-    pub fn new_file(&mut self, ctx: &mut EventCtx, config: &Config) -> BufferId {
+    pub fn new_file(
+        &mut self,
+        ctx: &mut EventCtx,
+        config: &LapceConfig,
+    ) -> BufferId {
         let tab_id = *self.tab_id;
         let proxy = self.proxy.clone();
         let buffer_id = BufferId::next();
@@ -2344,9 +3292,9 @@ impl LapceMainSplitData {
             Document::new(content.clone(), tab_id, ctx.get_external_handle(), proxy);
         self.scratch_docs.insert(buffer_id, Arc::new(doc));
 
-        let editor = self.get_editor_or_new(ctx, None, None, true, config);
+        let editor = self.get_editor_or_new(ctx, None, true, None, true, config);
         editor.content = content;
-        editor.cursor = if config.lapce.modal {
+        editor.cursor = if config.core.modal {
             Cursor::new(CursorMode::Normal(0), None, None)
         } else {
             Cursor::new(CursorMode::Insert(Selection::caret(0)), None, None)
@@ -2354,91 +3302,172 @@ impl LapceMainSplitData {
         buffer_id
     }
 
-    pub fn go_to_location(
+    pub fn go_to_location<P: EditorPosition + Send + 'static>(
+        &mut self,
+        ctx: &mut EventCtx,
+        editor_view_id: Option<WidgetId>,
+        same_tab: bool,
+        location: EditorLocation<P>,
+        config: &LapceConfig,
+    ) {
+        // Unfortunately this is the 'nicest' way I know to pass in no callback to an Option<F>
+        self.go_to_location_cb::<P, fn(&mut EventCtx, &mut LapceMainSplitData)>(
+            ctx,
+            editor_view_id,
+            same_tab,
+            location,
+            config,
+            None,
+        );
+    }
+
+    /// Go to the location in the editor
+    /// `cb` is called when the buffer is loaded, or immediately if it is already loaded.
+    pub fn go_to_location_cb<
+        P: EditorPosition + Send + 'static,
+        F: Fn(&mut EventCtx, &mut LapceMainSplitData) + Send + 'static,
+    >(
         &mut self,
         ctx: &mut EventCtx,
         editor_view_id: Option<WidgetId>,
-        location: EditorLocation,
-        config: &Config,
+        same_tab: bool,
+        location: EditorLocation<P>,
+        config: &LapceConfig,
+        cb: Option<F>,
     ) {
         let editor_view_id = self
             .get_editor_or_new(
                 ctx,
                 editor_view_id,
+                same_tab,
                 Some(location.path.clone()),
                 false,
                 config,
             )
             .view_id;
         let doc = self.editor_doc(editor_view_id);
+
+        // Whether we're swapping to a different file/kind-of-buffer
         let new_buffer = match doc.content() {
-            BufferContent::File(path) => path != &location.path,
+            BufferContent::File(path) => {
+                if path != &location.path {
+                    // different path
+                    true
+                } else {
+                    // same path, then check history version and EditorView change
+                    let editor = self.editors.get(&editor_view_id).unwrap();
+                    if let EditorView::Diff(old_version) = editor.view.clone() {
+                        if let Some(new_version) = location.history.clone() {
+                            // old editor is DiffView, and OpenFileDiff with 'history version'
+                            // check history version
+                            new_version != old_version
+                        } else {
+                            // old editor is DiffView, but OpenFile without 'history version'
+                            true
+                        }
+                    } else {
+                        // old editor is NormalView, but OpenFileDiff with 'history version'
+                        location.history.is_some()
+                    }
+                }
+            }
             BufferContent::Local(_) => true,
             BufferContent::SettingsValue(..) => true,
             BufferContent::Scratch(..) => true,
         };
+
         if new_buffer {
+            // Save the position in the document so that when the user reopens it, they'll
+            // return to the same place
             self.db.save_doc_position(&self.workspace, &doc);
         } else if location.position.is_none()
             && location.scroll_offset.is_none()
             && location.history.is_none()
         {
+            // If it is not a new buffer (so it is the same file); and there's no positioning,
+            // scrolling, or history, then we don't need to do anything to the editor at all.
             return;
         }
         let path = location.path.clone();
+        // TODO: Could this just be done via an if let Some()? Would have to reorder the if/else
         let doc_exists = self.open_docs.contains_key(&path);
         if !doc_exists {
+            // There's no existing document for the path, so we need to construct a new one.
             let mut doc = Document::new(
                 BufferContent::File(path.clone()),
                 *self.tab_id,
                 ctx.get_external_handle(),
                 self.proxy.clone(),
             );
+
+            // Acquire information about the buffer when it was last accessed, restoring their
+            // scroll & cursor position.
             if let Ok(info) = self.db.get_buffer_info(&self.workspace, &path) {
                 doc.scroll_offset =
                     Vec2::new(info.scroll_offset.0, info.scroll_offset.1);
                 doc.cursor_offset = info.cursor_offset;
             }
-            doc.retrieve_file(vec![(editor_view_id, location)]);
+
+            let cb: Option<InitBufferContentCb> = cb.map(|cb| Box::new(cb) as _);
+
+            // Since we don't have document loaded, we'll have to retrieve it from the proxy
+            // So, the document is not immediately filled with content!
+            doc.retrieve_file(vec![(editor_view_id, location)], None, cb, config);
             self.open_docs.insert(path.clone(), Arc::new(doc));
         } else {
             let doc = self.open_docs.get_mut(&path).unwrap().clone();
 
             let (offset, scroll_offset) = match &location.position {
-                Some(position) => {
-                    let offset = doc.buffer().offset_of_position(position);
+                Some(offset) => {
                     let doc = self.open_docs.get_mut(&path).unwrap();
                     let doc = Arc::make_mut(doc);
-                    doc.cursor_offset = offset;
+
+                    // Convert the offset into a utf8 form for us to use
+                    let offset = {
+                        let offset = offset.to_utf8_offset(doc.buffer());
+                        doc.cursor_offset = offset;
+                        offset
+                    };
+
                     if let Some(scroll_offset) = location.scroll_offset.as_ref() {
                         doc.scroll_offset = *scroll_offset;
                     }
 
                     (offset, location.scroll_offset.as_ref())
                 }
+                // No custom position, so we'll simply keep them where they were
                 None => (doc.cursor_offset, Some(&doc.scroll_offset)),
             };
+            // Ensure that the offset is within the bounds of the document
+            let offset = offset.min(doc.buffer().len());
 
+            // Update the document's source control history with the given version
             if let Some(version) = location.history.as_ref() {
                 let doc = self.open_docs.get_mut(&path).unwrap();
-                Arc::make_mut(doc).retrieve_history(version);
+                // TODO(minor): Could we avoid this make mut definitely cloning the `Document` by
+                // early-dropping our held doc above?
+                Arc::make_mut(doc)
+                    .retrieve_history(version, config.editor.diff_context_lines);
             }
 
             let editor = self.get_editor_or_new(
                 ctx,
                 Some(editor_view_id),
+                same_tab,
                 Some(location.path.clone()),
                 false,
                 config,
             );
-            if let Some(version) = location.history.as_ref() {
-                editor.view = EditorView::Diff(version.to_string());
+            editor.view = if let Some(version) = location.history.as_ref() {
+                // If they've provided us with a history version, then we're comparing with that
+                // version of the file.
+                EditorView::Diff(version.to_string())
             } else {
-                editor.view = EditorView::Normal;
-            }
+                EditorView::Normal
+            };
             editor.content = BufferContent::File(path.clone());
             editor.compare = location.history.clone();
-            editor.cursor = if config.lapce.modal {
+            editor.cursor = if config.core.modal {
                 Cursor::new(CursorMode::Normal(offset), None, None)
             } else {
                 Cursor::new(CursorMode::Insert(Selection::caret(offset)), None, None)
@@ -2467,6 +3496,11 @@ impl LapceMainSplitData {
                     Target::Widget(editor_view_id),
                 ));
             }
+
+            // Finished setting up the file, so alert the caller
+            if let Some(cb) = cb {
+                (cb)(ctx, self);
+            }
         }
     }
 
@@ -2475,19 +3509,27 @@ impl LapceMainSplitData {
         ctx: &mut EventCtx,
         editor_view_id: Option<WidgetId>,
         line: usize,
-        config: &Config,
+        config: &LapceConfig,
     ) {
-        let editor_view_id = self
-            .get_editor_or_new(ctx, editor_view_id, None, false, config)
-            .view_id;
-        let doc = self.editor_doc(editor_view_id);
-        let offset = doc.buffer().first_non_blank_character_on_line(if line > 0 {
-            line - 1
+        let editor =
+            self.get_editor_or_new(ctx, editor_view_id, true, None, false, config);
+        let path = if let BufferContent::File(path) = &editor.content {
+            Some(path.clone())
         } else {
-            0
-        });
-        let position = doc.buffer().offset_to_position(offset);
-        self.jump_to_position(ctx, Some(editor_view_id), position, config);
+            None
+        };
+
+        let position = Line(line);
+
+        if let Some(path) = path {
+            let location = EditorLocation {
+                path,
+                position: Some(position),
+                scroll_offset: None,
+                history: None,
+            };
+            self.jump_to_location(ctx, editor_view_id, true, location, config);
+        }
     }
 }
 
@@ -2498,10 +3540,11 @@ impl LapceMainSplitData {
         workspace_info: Option<&WorkspaceInfo>,
         palette_preview_editor: WidgetId,
         proxy: Arc<LapceProxy>,
-        config: &Config,
+        config: &LapceConfig,
         event_sink: ExtEventSink,
         workspace: Arc<LapceWorkspace>,
         db: Arc<LapceDb>,
+        unsaved_buffers: im::HashMap<String, String>,
     ) -> Self {
         let split_id = Arc::new(WidgetId::next());
 
@@ -2520,6 +3563,15 @@ impl LapceMainSplitData {
                 proxy.clone(),
             )),
         );
+        local_docs.insert(
+            LocalBufferKind::PathName,
+            Arc::new(Document::new(
+                BufferContent::Local(LocalBufferKind::PathName),
+                tab_id,
+                event_sink.clone(),
+                proxy.clone(),
+            )),
+        );
         let value_docs = im::HashMap::new();
         let scratch_docs = im::HashMap::new();
 
@@ -2553,6 +3605,8 @@ impl LapceMainSplitData {
             warning_count: 0,
             workspace,
             db,
+            locations: Arc::new(Vec::new()),
+            current_location: 0,
         };
 
         if let Some(info) = workspace_info {
@@ -2567,8 +3621,11 @@ impl LapceMainSplitData {
             );
             main_split_data.split_id = Arc::new(split_data.widget_id);
             for (path, locations) in positions.into_iter() {
+                let unsaved_buffer = unsaved_buffers
+                    .get(&path.to_str().unwrap().to_string())
+                    .map(Rope::from);
                 Arc::make_mut(main_split_data.open_docs.get_mut(&path).unwrap())
-                    .retrieve_file(locations.clone());
+                    .retrieve_file(locations.clone(), unsaved_buffer, None, config);
             }
         } else {
             main_split_data.splits.insert(
@@ -2585,7 +3642,11 @@ impl LapceMainSplitData {
         main_split_data
     }
 
-    pub fn insert_editor(&mut self, editor: Arc<LapceEditorData>, config: &Config) {
+    pub fn insert_editor(
+        &mut self,
+        editor: Arc<LapceEditorData>,
+        config: &LapceConfig,
+    ) {
         if let Some((find_view_id, find_editor_id)) = editor.find_view_id {
             let mut find_editor = LapceEditorData::new(
                 Some(find_view_id),
@@ -2606,7 +3667,7 @@ impl LapceMainSplitData {
         view_id: WidgetId,
         split_id: Option<WidgetId>,
         buffer_kind: LocalBufferKind,
-        config: &Config,
+        config: &LapceConfig,
         event_sink: ExtEventSink,
     ) {
         let doc = Document::new(
@@ -2733,18 +3794,22 @@ impl LapceMainSplitData {
                 let rev = doc.rev();
                 let path = path.to_path_buf();
                 let content = content.clone();
-                self.proxy.save_buffer_as(
+                self.proxy.proxy_rpc.save_buffer_as(
                     doc.id(),
                     path.to_path_buf(),
                     doc.rev(),
-                    doc.buffer().text().to_string(),
+                    doc.buffer().to_string(),
                     Box::new(move |result| {
                         if let Ok(_r) = result {
                             let _ = event_sink.submit_command(
                                 LAPCE_UI_COMMAND,
-                                LapceUICommand::SaveAsSuccess(
-                                    content, rev, path, view_id, exit,
-                                ),
+                                LapceUICommand::SaveAsSuccess {
+                                    content,
+                                    rev,
+                                    path,
+                                    view_id,
+                                    exit,
+                                },
                                 Target::Auto,
                             );
                         }
@@ -2756,19 +3821,18 @@ impl LapceMainSplitData {
         }
     }
 
-    pub fn settings_close(
+    pub fn widget_close(
         &mut self,
         ctx: &mut EventCtx,
         widget_id: WidgetId,
         editor_tab_id: WidgetId,
     ) {
         let editor_tab = self.editor_tabs.get(&editor_tab_id).unwrap();
-        let mut index = 0;
-        for (i, child) in editor_tab.children.iter().enumerate() {
-            if child.widget_id() == widget_id {
-                index = i;
-            }
-        }
+        let index = editor_tab
+            .children
+            .iter()
+            .position(|child| child.widget_id() == widget_id)
+            .unwrap_or(0);
         ctx.submit_command(Command::new(
             LAPCE_UI_COMMAND,
             LapceUICommand::EditorTabRemove(index, true, true),
@@ -3018,24 +4082,85 @@ impl LapceMainSplitData {
         }
     }
 
+    fn split_plugin(
+        &mut self,
+        ctx: &mut EventCtx,
+        editor_tab_id: WidgetId,
+        volt_id: VoltID,
+        volt_name: String,
+        direction: SplitDirection,
+        _config: &LapceConfig,
+    ) {
+        let editor_tab = self.editor_tabs.get(&editor_tab_id).unwrap();
+        let split_id = editor_tab.split;
+
+        let new_editor_tab_id = WidgetId::next();
+        let mut new_editor_tab = LapceEditorTabData {
+            widget_id: new_editor_tab_id,
+            split: split_id,
+            active: 0,
+            children: vec![EditorTabChild::Plugin {
+                widget_id: WidgetId::next(),
+                editor_tab_id: new_editor_tab_id,
+                volt_id,
+                volt_name,
+            }]
+            .into(),
+            layout_rect: Rc::new(RefCell::new(Rect::ZERO)),
+            content_is_hot: Rc::new(RefCell::new(false)),
+        };
+
+        let new_split_id = self.split(
+            ctx,
+            split_id,
+            SplitContent::EditorTab(editor_tab_id),
+            SplitContent::EditorTab(new_editor_tab.widget_id),
+            direction,
+            false,
+            false,
+        );
+
+        new_editor_tab.split = new_split_id;
+        if split_id != new_split_id {
+            let editor_tab = self.editor_tabs.get_mut(&editor_tab_id).unwrap();
+            let editor_tab = Arc::make_mut(editor_tab);
+            editor_tab.split = new_split_id;
+        }
+        self.editor_tabs
+            .insert(new_editor_tab.widget_id, Arc::new(new_editor_tab));
+    }
+
     pub fn split_settings(
         &mut self,
         ctx: &mut EventCtx,
         editor_tab_id: WidgetId,
         direction: SplitDirection,
+        config: &LapceConfig,
     ) {
         let editor_tab = self.editor_tabs.get(&editor_tab_id).unwrap();
         let split_id = editor_tab.split;
 
+        let editor = LapceEditorData::new(
+            None,
+            None,
+            None,
+            BufferContent::Local(LocalBufferKind::Keymap),
+            config,
+        );
+        let keymap_input_view_id = editor.view_id;
+        self.editors.insert(editor.view_id, Arc::new(editor));
+
         let new_editor_tab_id = WidgetId::next();
         let mut new_editor_tab = LapceEditorTabData {
             widget_id: new_editor_tab_id,
             split: split_id,
             active: 0,
-            children: vec![EditorTabChild::Settings(
-                WidgetId::next(),
-                new_editor_tab_id,
-            )],
+            children: vec![EditorTabChild::Settings {
+                settings_widget_id: WidgetId::next(),
+                editor_tab_id: new_editor_tab_id,
+                keymap_input_view_id,
+            }]
+            .into(),
             layout_rect: Rc::new(RefCell::new(Rect::ZERO)),
             content_is_hot: Rc::new(RefCell::new(false)),
         };
@@ -3060,13 +4185,49 @@ impl LapceMainSplitData {
             .insert(new_editor_tab.widget_id, Arc::new(new_editor_tab));
     }
 
+    pub fn tab_split(
+        &mut self,
+        ctx: &mut EventCtx,
+        editor_tab_id: WidgetId,
+        direction: SplitDirection,
+        config: &LapceConfig,
+    ) {
+        let editor_tab = self.editor_tabs.get(&editor_tab_id).unwrap();
+        if let Some(active) = editor_tab.children.get(editor_tab.active) {
+            match active {
+                EditorTabChild::Editor(view_id, _, _) => {
+                    self.split_editor(ctx, *view_id, direction, config);
+                }
+                EditorTabChild::Settings { editor_tab_id, .. } => {
+                    self.split_settings(ctx, *editor_tab_id, direction, config);
+                }
+                EditorTabChild::Plugin {
+                    editor_tab_id,
+                    volt_id,
+                    volt_name,
+                    ..
+                } => {
+                    self.split_plugin(
+                        ctx,
+                        *editor_tab_id,
+                        volt_id.clone(),
+                        volt_name.clone(),
+                        direction,
+                        config,
+                    );
+                }
+            }
+        }
+    }
+
     pub fn split_editor(
         &mut self,
         ctx: &mut EventCtx,
-        editor: &mut LapceEditorData,
+        view_id: WidgetId,
         direction: SplitDirection,
-        config: &Config,
+        config: &LapceConfig,
     ) {
+        let editor = self.editors.get(&view_id).unwrap();
         if let Some(editor_tab_id) = editor.tab_id {
             let editor_tab = self.editor_tabs.get(&editor_tab_id).unwrap();
             let split_id = editor_tab.split;
@@ -3079,7 +4240,8 @@ impl LapceMainSplitData {
                     new_editor.view_id,
                     new_editor.editor_id,
                     new_editor.find_view_id,
-                )],
+                )]
+                .into(),
                 layout_rect: Rc::new(RefCell::new(Rect::ZERO)),
                 content_is_hot: Rc::new(RefCell::new(false)),
             };
@@ -3121,17 +4283,30 @@ pub enum InlineFindDirection {
     Right,
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum EditorTabChild {
     Editor(WidgetId, WidgetId, Option<(WidgetId, WidgetId)>),
-    Settings(WidgetId, WidgetId),
+    Settings {
+        settings_widget_id: WidgetId,
+        editor_tab_id: WidgetId,
+        keymap_input_view_id: WidgetId,
+    },
+    Plugin {
+        widget_id: WidgetId,
+        volt_id: VoltID,
+        volt_name: String,
+        editor_tab_id: WidgetId,
+    },
 }
 
 impl EditorTabChild {
     pub fn widget_id(&self) -> WidgetId {
         match &self {
             EditorTabChild::Editor(widget_id, _, _) => *widget_id,
-            EditorTabChild::Settings(widget_id, _) => *widget_id,
+            EditorTabChild::Settings {
+                settings_widget_id, ..
+            } => *settings_widget_id,
+            EditorTabChild::Plugin { widget_id, .. } => *widget_id,
         }
     }
 
@@ -3141,34 +4316,44 @@ impl EditorTabChild {
                 let editor_data = data.main_split.editors.get(view_id).unwrap();
                 EditorTabChildInfo::Editor(editor_data.editor_info(data))
             }
-            EditorTabChild::Settings(_, _) => EditorTabChildInfo::Settings,
+            EditorTabChild::Settings { .. } => EditorTabChildInfo::Settings,
+            EditorTabChild::Plugin {
+                volt_id, volt_name, ..
+            } => EditorTabChildInfo::Plugin {
+                volt_id: volt_id.clone(),
+                volt_name: volt_name.to_string(),
+            },
         }
     }
 
     pub fn set_editor_tab(
         &mut self,
         data: &mut LapceTabData,
-        editor_tab_id: WidgetId,
+        editor_tab_widget_id: WidgetId,
     ) {
         match self {
             EditorTabChild::Editor(view_id, _, _) => {
                 let editor_data = data.main_split.editors.get_mut(view_id).unwrap();
                 let editor_data = Arc::make_mut(editor_data);
-                editor_data.tab_id = Some(editor_tab_id);
+                editor_data.tab_id = Some(editor_tab_widget_id);
             }
-            EditorTabChild::Settings(_, current_editor_tab_id) => {
-                *current_editor_tab_id = editor_tab_id;
+            EditorTabChild::Settings { editor_tab_id, .. } => {
+                *editor_tab_id = editor_tab_widget_id;
+            }
+            EditorTabChild::Plugin { editor_tab_id, .. } => {
+                *editor_tab_id = editor_tab_widget_id;
             }
         }
     }
 }
 
+/// The actual Editor tab structure, holding the windows.
 #[derive(Clone, Debug)]
 pub struct LapceEditorTabData {
     pub widget_id: WidgetId,
     pub split: WidgetId,
     pub active: usize,
-    pub children: Vec<EditorTabChild>,
+    pub children: Vector<EditorTabChild>,
     pub layout_rect: Rc<RefCell<Rect>>,
     pub content_is_hot: Rc<RefCell<bool>>,
 }
@@ -3187,8 +4372,8 @@ impl LapceEditorTabData {
         info
     }
 
-    pub fn active_child(&self) -> &EditorTabChild {
-        &self.children[self.active]
+    pub fn active_child(&self) -> Option<&EditorTabChild> {
+        self.children.get(self.active)
     }
 }
 
@@ -3199,13 +4384,28 @@ pub struct SelectionHistory {
     pub selections: im::Vector<Selection>,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum EditorView {
     Normal,
+    /// Source Control Diffing
     Diff(String),
+    /// Code Lens
     Lens,
 }
 
+impl EditorView {
+    pub fn is_normal(&self) -> bool {
+        matches!(self, EditorView::Normal)
+    }
+}
+
+#[derive(Debug)]
+pub struct StickyHeaderInfo {
+    pub height: f64,
+    pub lines: Vec<usize>,
+    pub last_y_diff: f64,
+}
+
 #[derive(Clone, Debug)]
 pub struct LapceEditorData {
     pub tab_id: Option<WidgetId>,
@@ -3216,15 +4416,13 @@ pub struct LapceEditorData {
     pub content: BufferContent,
     pub view: EditorView,
     pub compare: Option<String>,
-    pub code_lens: bool,
     pub scroll_offset: Vec2,
     pub cursor: Cursor,
     pub last_cursor_instant: Rc<RefCell<Instant>>,
     pub size: Rc<RefCell<Size>>,
+    pub sticky_header: Rc<RefCell<StickyHeaderInfo>>,
     pub window_origin: Rc<RefCell<Point>>,
     pub snippet: Option<Vec<(usize, (usize, usize))>>,
-    pub locations: Vec<EditorLocation>,
-    pub current_location: usize,
     pub last_movement_new: Movement,
     pub last_inline_find: Option<(InlineFindDirection, String)>,
     pub inline_find: Option<InlineFindDirection>,
@@ -3237,7 +4435,7 @@ impl LapceEditorData {
         editor_id: Option<WidgetId>,
         tab_id: Option<WidgetId>,
         content: BufferContent,
-        config: &Config,
+        config: &LapceConfig,
     ) -> Self {
         Self {
             tab_id,
@@ -3253,7 +4451,7 @@ impl LapceEditorData {
             scroll_offset: Vec2::ZERO,
             cursor: if content.is_input() {
                 Cursor::new(CursorMode::Insert(Selection::caret(0)), None, None)
-            } else if config.lapce.modal {
+            } else if config.core.modal {
                 Cursor::new(CursorMode::Normal(0), None, None)
             } else {
                 Cursor::new(CursorMode::Insert(Selection::caret(0)), None, None)
@@ -3261,12 +4459,14 @@ impl LapceEditorData {
             last_cursor_instant: Rc::new(RefCell::new(Instant::now())),
             content,
             size: Rc::new(RefCell::new(Size::ZERO)),
+            sticky_header: Rc::new(RefCell::new(StickyHeaderInfo {
+                height: 0.0,
+                lines: Vec::new(),
+                last_y_diff: 0.0,
+            })),
             compare: None,
-            code_lens: false,
             window_origin: Rc::new(RefCell::new(Point::ZERO)),
             snippet: None,
-            locations: vec![],
-            current_location: 0,
             last_movement_new: Movement::Left,
             inline_find: None,
             last_inline_find: None,
@@ -3286,6 +4486,10 @@ impl LapceEditorData {
         new_editor
     }
 
+    pub fn is_code_lens(&self) -> bool {
+        matches!(self.view, EditorView::Lens)
+    }
+
     pub fn add_snippet_placeholders(
         &mut self,
         new_placeholders: Vec<(usize, (usize, usize))>,
@@ -3313,72 +4517,108 @@ impl LapceEditorData {
         placeholders.extend_from_slice(&v[1..]);
     }
 
-    pub fn save_jump_location(&mut self, doc: &Document) {
-        if let BufferContent::File(path) = doc.content() {
-            let location = EditorLocation {
-                path: path.clone(),
-                position: Some(
-                    doc.buffer().offset_to_position(self.cursor.offset()),
-                ),
-                scroll_offset: Some(self.scroll_offset),
-                history: None,
-            };
-            self.locations.push(location);
-            self.current_location = self.locations.len();
-        }
-    }
-
     pub fn editor_info(&self, data: &LapceTabData) -> EditorInfo {
         let unsaved = if let BufferContent::Scratch(id, _) = &self.content {
             let doc = data.main_split.scratch_docs.get(id).unwrap();
-            Some(doc.buffer().text().to_string())
+            Some(doc.buffer().to_string())
         } else {
             None
         };
-        let info = EditorInfo {
+
+        EditorInfo {
             content: self.content.clone(),
             unsaved,
             scroll_offset: (self.scroll_offset.x, self.scroll_offset.y),
-            position: if let BufferContent::File(path) = &self.content {
-                let doc = data.main_split.open_docs.get(path).unwrap().clone();
-                Some(doc.buffer().offset_to_position(self.cursor.offset()))
+            position: if let BufferContent::File(_) = &self.content {
+                Some(self.cursor.offset())
             } else {
                 None
             },
-        };
-        info
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
+pub struct SshHost {
+    pub user: Option<String>,
+    pub host: String,
+    pub port: Option<usize>,
+}
+
+impl SshHost {
+    pub fn from_string(s: &str) -> Self {
+        let mut whole_splits = s.split(':');
+        let splits = whole_splits
+            .next()
+            .unwrap()
+            .split('@')
+            .collect::<Vec<&str>>();
+        let mut splits = splits.iter().rev();
+        let host = splits.next().unwrap().to_string();
+        let user = splits.next().map(|s| s.to_string());
+        let port = whole_splits.next().and_then(|s| s.parse::<usize>().ok());
+        Self { user, host, port }
+    }
+
+    pub fn user_host(&self) -> String {
+        if let Some(user) = self.user.as_ref() {
+            format!("{user}@{}", self.host)
+        } else {
+            self.host.clone()
+        }
+    }
+}
+
+impl Display for SshHost {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(user) = self.user.as_ref() {
+            write!(f, "{user}@")?;
+        }
+        write!(f, "{}", self.host)?;
+        if let Some(port) = self.port {
+            write!(f, ":{port}")?;
+        }
+        Ok(())
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum LapceWorkspaceType {
     Local,
-    RemoteSSH(String, String),
+    RemoteSSH(SshHost),
+    #[cfg(windows)]
     RemoteWSL,
 }
 
 impl LapceWorkspaceType {
+    #[cfg(windows)]
     pub fn is_remote(&self) -> bool {
         matches!(
             self,
-            LapceWorkspaceType::RemoteSSH(_, _) | LapceWorkspaceType::RemoteWSL
+            LapceWorkspaceType::RemoteSSH(_) | LapceWorkspaceType::RemoteWSL
         )
     }
+
+    #[cfg(not(windows))]
+    pub fn is_remote(&self) -> bool {
+        matches!(self, LapceWorkspaceType::RemoteSSH(_))
+    }
 }
 
 impl std::fmt::Display for LapceWorkspaceType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             LapceWorkspaceType::Local => f.write_str("Local"),
-            LapceWorkspaceType::RemoteSSH(user, host) => {
-                write!(f, "ssh://{}@{}", user, host)
+            LapceWorkspaceType::RemoteSSH(ssh) => {
+                write!(f, "ssh://{ssh}")
             }
+            #[cfg(windows)]
             LapceWorkspaceType::RemoteWSL => f.write_str("WSL"),
         }
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct LapceWorkspace {
     pub kind: LapceWorkspaceType,
     pub path: Option<PathBuf>,
@@ -3401,11 +4641,7 @@ impl std::fmt::Display for LapceWorkspace {
             f,
             "{}:{}",
             self.kind,
-            self.path
-                .as_ref()
-                .and_then(|p| p.to_str())
-                .map(|p| p.to_string())
-                .unwrap_or_else(|| "".to_string())
+            self.path.as_ref().and_then(|p| p.to_str()).unwrap_or("")
         )
     }
 }
diff --git a/lapce-data/src/db.rs b/lapce-data/src/db.rs
index 6863463485..a578f9c462 100644
--- a/lapce-data/src/db.rs
+++ b/lapce-data/src/db.rs
@@ -8,21 +8,22 @@ use std::{
 
 use anyhow::{anyhow, Result};
 use crossbeam_channel::{unbounded, Sender};
-use directories::ProjectDirs;
 use druid::{ExtEventSink, Point, Rect, Size, Vec2, WidgetId};
-use lsp_types::Position;
+use lapce_core::directory::Directory;
+use lapce_rpc::plugin::VoltID;
+use lapce_xi_rope::Rope;
 use serde::{Deserialize, Serialize};
-use xi_rope::Rope;
 
 use crate::{
-    config::Config,
+    config::LapceConfig,
     data::{
         EditorTabChild, LapceData, LapceEditorData, LapceEditorTabData,
         LapceMainSplitData, LapceTabData, LapceWindowData, LapceWorkspace,
         SplitContent, SplitData,
     },
-    document::{BufferContent, Document},
+    document::{BufferContent, Document, LocalBufferKind},
     editor::EditorLocation,
+    panel::{PanelData, PanelOrder},
     split::SplitDirection,
 };
 
@@ -30,6 +31,7 @@ pub enum SaveEvent {
     Workspace(LapceWorkspace, WorkspaceInfo),
     Tabs(TabsInfo),
     Buffer(BufferInfo),
+    RecentWorkspace(LapceWorkspace),
 }
 
 #[derive(Clone)]
@@ -51,7 +53,7 @@ impl SplitContentInfo {
         parent_split: Option<WidgetId>,
         editor_positions: &mut HashMap<PathBuf, Vec<(WidgetId, EditorLocation)>>,
         tab_id: WidgetId,
-        config: &Config,
+        config: &LapceConfig,
         event_sink: ExtEventSink,
     ) -> SplitContent {
         match &self {
@@ -95,7 +97,7 @@ impl EditorTabInfo {
         split: WidgetId,
         editor_positions: &mut HashMap<PathBuf, Vec<(WidgetId, EditorLocation)>>,
         tab_id: WidgetId,
-        config: &Config,
+        config: &LapceConfig,
         event_sink: ExtEventSink,
     ) -> LapceEditorTabData {
         let editor_tab_id = WidgetId::next();
@@ -136,6 +138,7 @@ impl EditorTabInfo {
 pub enum EditorTabChildInfo {
     Editor(EditorInfo),
     Settings,
+    Plugin { volt_id: VoltID, volt_name: String },
 }
 
 impl EditorTabChildInfo {
@@ -145,7 +148,7 @@ impl EditorTabChildInfo {
         editor_tab_id: WidgetId,
         editor_positions: &mut HashMap<PathBuf, Vec<(WidgetId, EditorLocation)>>,
         tab_id: WidgetId,
-        config: &Config,
+        config: &LapceConfig,
         event_sink: ExtEventSink,
     ) -> EditorTabChild {
         match &self {
@@ -165,7 +168,29 @@ impl EditorTabChildInfo {
                 )
             }
             EditorTabChildInfo::Settings => {
-                EditorTabChild::Settings(WidgetId::next(), editor_tab_id)
+                let editor = LapceEditorData::new(
+                    None,
+                    None,
+                    None,
+                    BufferContent::Local(LocalBufferKind::Keymap),
+                    config,
+                );
+                let keymap_input_view_id = editor.view_id;
+                data.editors.insert(editor.view_id, Arc::new(editor));
+
+                EditorTabChild::Settings {
+                    settings_widget_id: WidgetId::next(),
+                    editor_tab_id,
+                    keymap_input_view_id,
+                }
+            }
+            EditorTabChildInfo::Plugin { volt_id, volt_name } => {
+                EditorTabChild::Plugin {
+                    widget_id: WidgetId::next(),
+                    volt_id: volt_id.clone(),
+                    volt_name: volt_name.to_string(),
+                    editor_tab_id,
+                }
             }
         }
     }
@@ -184,7 +209,7 @@ impl SplitInfo {
         parent_split: Option<WidgetId>,
         editor_positions: &mut HashMap<PathBuf, Vec<(WidgetId, EditorLocation)>>,
         tab_id: WidgetId,
-        config: &Config,
+        config: &LapceConfig,
         event_sink: ExtEventSink,
     ) -> SplitData {
         let split_id = WidgetId::next();
@@ -216,6 +241,7 @@ impl SplitInfo {
 #[derive(Clone, Serialize, Deserialize)]
 pub struct WorkspaceInfo {
     pub split: SplitInfo,
+    pub panel: PanelData,
 }
 
 #[derive(Clone, Serialize, Deserialize)]
@@ -245,7 +271,7 @@ pub struct EditorInfo {
     pub content: BufferContent,
     pub unsaved: Option<String>,
     pub scroll_offset: (f64, f64),
-    pub position: Option<Position>,
+    pub position: Option<usize>,
 }
 
 #[derive(Clone, Serialize, Deserialize)]
@@ -260,7 +286,7 @@ impl EditorInfo {
         editor_tab_id: WidgetId,
         editor_positions: &mut HashMap<PathBuf, Vec<(WidgetId, EditorLocation)>>,
         tab_id: WidgetId,
-        config: &Config,
+        config: &LapceConfig,
         event_sink: ExtEventSink,
     ) -> LapceEditorData {
         let editor_data = LapceEditorData::new(
@@ -289,13 +315,15 @@ impl EditorInfo {
             ));
 
             if !data.open_docs.contains_key(path) {
-                let doc = Arc::new(Document::new(
-                    BufferContent::File(path.clone()),
-                    tab_id,
-                    event_sink,
-                    data.proxy.clone(),
-                ));
-                data.open_docs.insert(path.clone(), doc);
+                data.open_docs.insert(
+                    path.clone(),
+                    Arc::new(Document::new(
+                        BufferContent::File(path.clone()),
+                        tab_id,
+                        event_sink,
+                        data.proxy.clone(),
+                    )),
+                );
             }
         } else if let BufferContent::Scratch(id, _) = &self.content {
             if !data.scratch_docs.contains_key(id) {
@@ -318,17 +346,13 @@ impl EditorInfo {
 
 impl LapceDb {
     pub fn new() -> Result<Self> {
-        let proj_dirs = ProjectDirs::from("", "", "Lapce")
-            .ok_or_else(|| anyhow!("can't find project dirs"))?;
-        let path = proj_dirs.config_dir().join(if !cfg!(debug_assertions) {
-            "lapce.db"
-        } else {
-            "debug-lapce.db"
-        });
+        let path = Directory::config_directory()
+            .ok_or_else(|| anyhow!("can't get config directory"))?
+            .join("lapce.db");
         let (save_tx, save_rx) = unbounded();
 
         let sled_db = sled::Config::default()
-            .path(&path)
+            .path(path)
             .flush_every_ms(None)
             .open()
             .ok();
@@ -348,6 +372,9 @@ impl LapceDb {
                     SaveEvent::Buffer(info) => {
                         let _ = local_db.insert_buffer(&info);
                     }
+                    SaveEvent::RecentWorkspace(workspace) => {
+                        let _ = local_db.insert_recent_workspace(workspace);
+                    }
                 }
             }
         });
@@ -405,7 +432,7 @@ impl LapceDb {
         let key = "recent_workspaces";
         let sled_db = self.get_db()?;
         let workspaces = sled_db
-            .get(&key)?
+            .get(key)?
             .ok_or_else(|| anyhow!("can't find recent workspaces"))?;
         let workspaces = std::str::from_utf8(&workspaces)?;
         let workspaces: Vec<LapceWorkspace> = serde_json::from_str(workspaces)?;
@@ -419,13 +446,45 @@ impl LapceDb {
         let workspace = workspace.to_string();
         let sled_db = self.get_db()?;
         let info = sled_db
-            .get(&workspace)?
+            .get(workspace)?
             .ok_or_else(|| anyhow!("can't find workspace info"))?;
         let info = std::str::from_utf8(&info)?;
         let info: WorkspaceInfo = serde_json::from_str(info)?;
         Ok(info)
     }
 
+    /// fetches all the files stored in the database that are tagged as `unsaved_buffer`.<br>
+    /// Returns a hashmap of the form HashMap<path, file_content><br>
+    /// *Note: The file is deleted from the database right after as to prevent "ghost" buffers*
+    pub fn get_unsaved_buffers(&self) -> Result<im::HashMap<String, String>> {
+        let sled_db = self.get_db()?;
+        let mut buffers = im::HashMap::new();
+
+        let res = match sled_db.get("unsaved_buffers") {
+            Ok(val) => match val {
+                Some(buffers) => buffers,
+                None => return Ok(buffers),
+            },
+            Err(err) => return Err(anyhow!(err)),
+        };
+
+        let res = String::from_utf8(res.to_vec())
+            .expect("invalid utf-8 sequence retrieving unsaved buffer");
+
+        let res: Vec<String> = serde_json::from_str(&res)?;
+        if res.len() % 2 != 0 {
+            return Err(anyhow!("Deserialized Unsaved buffer size is not even: this should never happen"));
+        }
+
+        for i in (0..res.len()).step_by(2) {
+            let key = res.get(i).unwrap().clone();
+            let value = res.get(i + 1).unwrap().clone();
+            buffers.insert(key, value);
+        }
+        sled_db.remove("unsaved_buffers")?;
+        Ok(buffers)
+    }
+
     pub fn get_buffer_info(
         &self,
         workspace: &LapceWorkspace,
@@ -458,6 +517,49 @@ impl LapceDb {
         Ok(())
     }
 
+    pub fn save_disabled_volts(&self, volts: Vec<&VoltID>) -> Result<()> {
+        let sled_db = self.get_db()?;
+        let volts = serde_json::to_string(&volts)?;
+        sled_db.insert(b"disabled_volts", volts.as_str())?;
+        sled_db.flush()?;
+        Ok(())
+    }
+
+    pub fn get_disabled_volts(&self) -> Result<Vec<VoltID>> {
+        let sled_db = self.get_db()?;
+        let volts = sled_db
+            .get("disabled_volts")?
+            .ok_or_else(|| anyhow!("can't find disable volts"))?;
+        let volts = std::str::from_utf8(&volts)?;
+        let volts: Vec<VoltID> = serde_json::from_str(volts)?;
+        Ok(volts)
+    }
+
+    pub fn save_workspace_disabled_volts(
+        &self,
+        workspace: &LapceWorkspace,
+        volts: Vec<&VoltID>,
+    ) -> Result<()> {
+        let sled_db = self.get_db()?;
+        let volts = serde_json::to_string(&volts)?;
+        sled_db.insert(format!("disabled_volts:{workspace}"), volts.as_str())?;
+        sled_db.flush()?;
+        Ok(())
+    }
+
+    pub fn get_workspace_disabled_volts(
+        &self,
+        workspace: &LapceWorkspace,
+    ) -> Result<Vec<VoltID>> {
+        let sled_db = self.get_db()?;
+        let volts = sled_db
+            .get(format!("disabled_volts:{workspace}"))?
+            .ok_or_else(|| anyhow!("can't find disable volts"))?;
+        let volts = std::str::from_utf8(&volts)?;
+        let volts: Vec<VoltID> = serde_json::from_str(volts)?;
+        Ok(volts)
+    }
+
     pub fn save_last_window(&self, window: &LapceWindowData) {
         let info = window.info();
         let _ = self.insert_last_window_info(info);
@@ -481,6 +583,24 @@ impl LapceDb {
         Ok(info)
     }
 
+    pub fn get_panel_orders(&self) -> Result<PanelOrder> {
+        let sled_db = self.get_db()?;
+        let panel_orders = sled_db
+            .get("panel_orders")?
+            .ok_or_else(|| anyhow!("can't find panel orders"))?;
+        let panel_orders = std::str::from_utf8(&panel_orders)?;
+        let panel_orders: PanelOrder = serde_json::from_str(panel_orders)?;
+        Ok(panel_orders)
+    }
+
+    pub fn save_panel_orders(&self, order: &PanelOrder) -> Result<()> {
+        let info = serde_json::to_string(order)?;
+        let sled_db = self.get_db()?;
+        sled_db.insert("panel_orders", info.as_str())?;
+        sled_db.flush()?;
+        Ok(())
+    }
+
     fn insert_workspace(
         &self,
         workspace: &LapceWorkspace,
@@ -498,7 +618,34 @@ impl LapceDb {
         let workspace = (*data.workspace).clone();
         let workspace_info = data.workspace_info();
 
+        // Buffer for auto save on quit
+        let main_split = &data.main_split;
+
         self.insert_workspace(&workspace, &workspace_info)?;
+        self.insert_unsaved_buffer(main_split)?;
+
+        Ok(())
+    }
+
+    fn insert_unsaved_buffer(&self, main_split: &LapceMainSplitData) -> Result<()> {
+        let sled_db = self.get_db()?;
+        // Vec of all unsaved buffers of format path_buff, file_content
+        let mut unsaved_buffers = Vec::new();
+
+        for (path, doc) in &main_split.open_docs {
+            if !doc.buffer().is_pristine() && doc.content().is_file() {
+                let path_str = path.to_str().unwrap();
+                let buf_text = doc.buffer().to_string();
+                unsaved_buffers.push(path_str.to_string());
+                unsaved_buffers.push(buf_text);
+            }
+        }
+        if !unsaved_buffers.is_empty() {
+            let tmp = serde_json::to_string(&unsaved_buffers).unwrap();
+            sled_db.insert("unsaved_buffers", tmp.as_str())?;
+            sled_db.flush()?;
+        }
+
         Ok(())
     }
 
@@ -541,7 +688,7 @@ impl LapceDb {
             .enumerate()
             .map(|(i, w)| {
                 let tab = data.tabs.get(w).unwrap();
-                if tab.id == data.active_id {
+                if tab.id == *data.active_id {
                     active_tab = i;
                 }
                 (*tab.workspace).clone()
@@ -554,4 +701,55 @@ impl LapceDb {
         self.save_tx.send(SaveEvent::Tabs(info))?;
         Ok(())
     }
+
+    pub fn recent_workspaces(&self) -> Result<Vec<LapceWorkspace>> {
+        let sled_db = self.get_db()?;
+        let workspaces = sled_db
+            .get("recent_workspaces")?
+            .ok_or_else(|| anyhow!("can't find disable volts"))?;
+        let workspaces = std::str::from_utf8(&workspaces)?;
+        let workspaces: Vec<LapceWorkspace> = serde_json::from_str(workspaces)?;
+        Ok(workspaces)
+    }
+
+    pub fn update_recent_workspace(&self, workspace: LapceWorkspace) -> Result<()> {
+        if workspace.path.is_none() {
+            return Ok(());
+        }
+        self.save_tx.send(SaveEvent::RecentWorkspace(workspace))?;
+        Ok(())
+    }
+
+    fn insert_recent_workspace(&self, workspace: LapceWorkspace) -> Result<()> {
+        let sled_db = self.get_db()?;
+
+        let mut workspaces = self.recent_workspaces().unwrap_or_default();
+
+        let mut exits = false;
+        for w in workspaces.iter_mut() {
+            if w.path == workspace.path && w.kind == workspace.kind {
+                w.last_open = std::time::SystemTime::now()
+                    .duration_since(std::time::UNIX_EPOCH)
+                    .unwrap()
+                    .as_secs();
+                exits = true;
+                break;
+            }
+        }
+        if !exits {
+            let mut workspace = workspace;
+            workspace.last_open = std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_secs();
+            workspaces.push(workspace);
+        }
+        workspaces.sort_by_key(|w| -(w.last_open as i64));
+        let workspaces = serde_json::to_string(&workspaces)?;
+
+        sled_db.insert("recent_workspaces", workspaces.as_str())?;
+        sled_db.flush()?;
+
+        Ok(())
+    }
 }
diff --git a/lapce-data/src/document.rs b/lapce-data/src/document.rs
index d2a73ad42c..a5d591c224 100644
--- a/lapce-data/src/document.rs
+++ b/lapce-data/src/document.rs
@@ -1,22 +1,21 @@
 use std::{
     cell::RefCell,
     collections::{HashMap, HashSet},
-    path::PathBuf,
+    path::{Path, PathBuf},
     rc::Rc,
-    sync::{
-        atomic::{self},
-        Arc,
-    },
+    sync::Arc,
 };
 
 use druid::{
     piet::{
         PietText, PietTextLayout, Text, TextAttribute, TextLayout, TextLayoutBuilder,
     },
-    ExtEventSink, Point, SingleUse, Size, Target, Vec2, WidgetId,
+    Color, ExtEventSink, FontFamily, Point, Size, Target, Vec2, WidgetId,
 };
+use itertools::Itertools;
 use lapce_core::{
     buffer::{Buffer, DiffLines, InvalLines},
+    char_buffer::CharBuffer,
     command::{EditCommand, MultiSelectionCommand},
     cursor::{ColPosition, Cursor, CursorMode},
     editor::{EditType, Editor},
@@ -26,43 +25,86 @@ use lapce_core::{
     register::{Clipboard, Register, RegisterData},
     selection::{SelRegion, Selection},
     style::line_styles,
-    syntax::Syntax,
+    syntax::{
+        edit::SyntaxEdit, highlight::HighlightIssue, util::matching_pair_direction,
+        Syntax,
+    },
     word::WordCursor,
 };
 use lapce_rpc::{
-    buffer::{BufferId, NewBufferResponse},
+    buffer::BufferId,
+    plugin::PluginId,
+    proxy::ProxyResponse,
     style::{LineStyle, LineStyles, Style},
 };
-use lsp_types::{CodeActionOrCommand, CodeActionResponse};
+use lapce_xi_rope::{
+    spans::{Spans, SpansBuilder},
+    Interval, Rope, RopeDelta, Transformer,
+};
+use lsp_types::{
+    CodeActionOrCommand, CodeActionResponse, DiagnosticSeverity, InlayHint,
+    InlayHintLabel, MessageType, ShowMessageParams,
+};
 use serde::{Deserialize, Serialize};
-use xi_rope::{spans::Spans, Rope, RopeDelta};
+use smallvec::SmallVec;
 
 use crate::{
-    command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::{Config, LapceTheme},
-    editor::EditorLocation,
+    atomic_soft_tabs::{snap_to_soft_tab, snap_to_soft_tab_line_col, SnapDirection},
+    command::{InitBufferContentCb, LapceUICommand, LAPCE_UI_COMMAND},
+    config::{LapceConfig, LapceTheme},
+    data::{EditorDiagnostic, EditorView},
+    editor::{EditorLocation, EditorPosition},
     find::{Find, FindProgress},
     history::DocumentHistory,
     proxy::LapceProxy,
-    settings::SettingsValueKind,
+    selection_range::{SelectionRangeDirection, SyntaxSelectionRanges},
 };
 
 pub struct SystemClipboard {}
 
+impl SystemClipboard {
+    fn clipboard() -> druid::Clipboard {
+        druid::Application::global().clipboard()
+    }
+}
+
 impl Clipboard for SystemClipboard {
     fn get_string(&self) -> Option<String> {
-        druid::Application::global().clipboard().get_string()
+        Self::clipboard().get_string()
     }
 
     fn put_string(&mut self, s: impl AsRef<str>) {
-        druid::Application::global().clipboard().put_string(s)
+        Self::clipboard().put_string(s)
     }
 }
 
+#[derive(Clone)]
+pub struct LineExtraStyle {
+    pub bg_color: Option<Color>,
+    pub under_line: Option<Color>,
+}
+
+#[derive(Clone)]
+pub struct TextLayoutLine {
+    /// Extra styling that should be applied to the text
+    /// (x0, x1 or line display end, style)
+    pub extra_style: Vec<(f64, Option<f64>, LineExtraStyle)>,
+    pub text: PietTextLayout,
+    pub whitespaces: Option<Vec<(char, (f64, f64))>>,
+    pub indent: f64,
+}
+
+/// Keeps track of the text layouts so that we can efficiently reuse them.
 #[derive(Clone, Default)]
 pub struct TextLayoutCache {
+    /// The id of the last config, which lets us know when the config changes so we can update
+    /// the cache.
     config_id: u64,
-    pub layouts: HashMap<usize, Arc<PietTextLayout>>,
+    /// (Font Size -> (Line Number -> Text Layout))  
+    /// Different font-sizes are cached separately, which is useful for features like code lens
+    /// where the text becomes small but you may wish to revert quickly.
+    pub layouts: HashMap<usize, HashMap<usize, Arc<TextLayoutLine>>>,
+    pub max_width: f64,
 }
 
 impl TextLayoutCache {
@@ -70,6 +112,7 @@ impl TextLayoutCache {
         Self {
             config_id: 0,
             layouts: HashMap::new(),
+            max_width: 0.0,
         }
     }
 
@@ -85,40 +128,72 @@ impl TextLayoutCache {
     }
 }
 
+/// Local buffers are certain special buffers that aren't files or scratch buffers
 #[derive(Clone, PartialEq, Eq, Hash, Serialize, Deserialize, Debug)]
 pub enum LocalBufferKind {
+    /// No buffer at all. Sometimes used as a temporary value.
     Empty,
+    /// The buffer for typing in the palette
     Palette,
+    /// The search buffer
     Search,
+    /// Commit message buffer
     SourceControl,
     FilePicker,
+    /// Keymap filter buffer
     Keymap,
+    /// Settings filter buffer
     Settings,
+    /// File explorer {re,}naming buffer
+    PathName,
+    /// Symbol renaming buffer
+    Rename,
+    /// Search buffer in plugin panel
+    PluginSearch,
+    /// Source Control branch filter in the branch list
+    BranchesFilter,
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum BufferContent {
+    /// A file at some location. This can be a remote path.
     File(PathBuf),
+    /// A special local buffer, like the palette or search.
     Local(LocalBufferKind),
-    SettingsValue(String, SettingsValueKind, String, String),
+    /// A setting input; with its name.
+    SettingsValue(String),
+    /// A scratch buffer that doesn't have a location.
+    /// The `BufferId` identifies the underlying buffer, and the `String` is the scratch file's
+    /// name
     Scratch(BufferId, String),
 }
-
 impl BufferContent {
+    pub fn path(&self) -> Option<&Path> {
+        if let BufferContent::File(p) = self {
+            Some(p)
+        } else {
+            None
+        }
+    }
+
     pub fn is_file(&self) -> bool {
         matches!(self, BufferContent::File(_))
     }
 
     pub fn is_special(&self) -> bool {
-        match &self {
+        match self {
             BufferContent::File(_) => false,
             BufferContent::Local(local) => match local {
                 LocalBufferKind::Search
                 | LocalBufferKind::Palette
                 | LocalBufferKind::SourceControl
+                | LocalBufferKind::BranchesFilter
                 | LocalBufferKind::FilePicker
                 | LocalBufferKind::Settings
-                | LocalBufferKind::Keymap => true,
+                | LocalBufferKind::Keymap
+                | LocalBufferKind::PathName
+                | LocalBufferKind::PluginSearch
+                | LocalBufferKind::Rename => true,
                 LocalBufferKind::Empty => false,
             },
             BufferContent::SettingsValue(..) => true,
@@ -126,15 +201,21 @@ impl BufferContent {
         }
     }
 
+    /// Is the `BufferContent` an input-box style editor, (ex: uses ui font; and input box drawing
+    /// style)
     pub fn is_input(&self) -> bool {
-        match &self {
+        match self {
             BufferContent::File(_) => false,
             BufferContent::Local(local) => match local {
                 LocalBufferKind::Search
                 | LocalBufferKind::Palette
                 | LocalBufferKind::FilePicker
                 | LocalBufferKind::Settings
-                | LocalBufferKind::Keymap => true,
+                | LocalBufferKind::Keymap
+                | LocalBufferKind::PathName
+                | LocalBufferKind::PluginSearch
+                | LocalBufferKind::BranchesFilter
+                | LocalBufferKind::Rename => true,
                 LocalBufferKind::Empty | LocalBufferKind::SourceControl => false,
             },
             BufferContent::SettingsValue(..) => true,
@@ -142,17 +223,16 @@ impl BufferContent {
         }
     }
 
+    pub fn is_palette(&self) -> bool {
+        matches!(self, BufferContent::Local(LocalBufferKind::Palette))
+    }
+
     pub fn is_search(&self) -> bool {
-        match &self {
-            BufferContent::File(_) => false,
-            BufferContent::SettingsValue(..) => false,
-            BufferContent::Scratch(..) => false,
-            BufferContent::Local(local) => matches!(local, LocalBufferKind::Search),
-        }
+        matches!(self, BufferContent::Local(LocalBufferKind::Search))
     }
 
     pub fn is_settings(&self) -> bool {
-        match &self {
+        match self {
             BufferContent::File(_) => false,
             BufferContent::SettingsValue(..) => true,
             BufferContent::Local(_) => false,
@@ -171,24 +251,188 @@ impl BufferContent {
     }
 }
 
+/// `PhantomText` is for text that is not in the actual document, but should be rendered with it.  
+/// Ex: Inlay hints, IME text, error lens' diagnostics, etc
+pub struct PhantomText {
+    /// The kind is currently used for sorting the phantom text on a line
+    kind: PhantomTextKind,
+    /// Column on the line that the phantom text should be displayed at
+    col: usize,
+    text: String,
+    font_size: Option<usize>,
+    font_family: Option<FontFamily>,
+    fg: Option<Color>,
+    bg: Option<Color>,
+    under_line: Option<Color>,
+}
+
+#[derive(Ord, Eq, PartialEq, PartialOrd)]
+pub enum PhantomTextKind {
+    /// Input methods
+    Ime,
+    /// Completion lens
+    Completion,
+    /// Inlay hints supplied by an LSP/PSP (like type annotations)
+    InlayHint,
+    /// Error lens
+    Diagnostic,
+}
+
+/// Information about the phantom text on a specific line.  
+/// This has various utility functions for transforming a coordinate (typically a column) into the
+/// resulting coordinate after the phantom text is combined with the line's real content.
+#[derive(Default)]
+pub struct PhantomTextLine {
+    /// This uses a smallvec because most lines rarely have more than a couple phantom texts
+    text: SmallVec<[PhantomText; 6]>,
+    /// Maximum diagnostic severity, so that we can color the background as an error if there is a
+    /// warning and error on the line. (For error lens)
+    max_severity: Option<DiagnosticSeverity>,
+}
+
+impl PhantomTextLine {
+    /// Translate a column position into the text into what it would be after combining
+    pub fn col_at(&self, pre_col: usize) -> usize {
+        let mut last = pre_col;
+        for (col_shift, size, col, _) in self.offset_size_iter() {
+            if pre_col >= col {
+                last = pre_col + col_shift + size;
+            }
+        }
+
+        last
+    }
+
+    /// Translate a column position into the text into what it would be after combining
+    /// If before_cursor is false and the cursor is right at the start then it will stay there
+    pub fn col_after(&self, pre_col: usize, before_cursor: bool) -> usize {
+        let mut last = pre_col;
+        for (col_shift, size, col, _) in self.offset_size_iter() {
+            if pre_col > col || (pre_col == col && before_cursor) {
+                last = pre_col + col_shift + size;
+            }
+        }
+
+        last
+    }
+
+    /// Translate a column position into the position it would be before combining
+    pub fn before_col(&self, col: usize) -> usize {
+        let mut last = col;
+        for (col_shift, size, hint_col, _) in self.offset_size_iter() {
+            let shifted_start = hint_col + col_shift;
+            let shifted_end = shifted_start + size;
+            if col >= shifted_start {
+                if col >= shifted_end {
+                    last = col - col_shift - size;
+                } else {
+                    last = hint_col;
+                }
+            }
+        }
+        last
+    }
+
+    /// Insert the hints at their positions in the text
+    pub fn combine_with_text(&self, text: String) -> String {
+        let mut text = text;
+        let mut col_shift = 0;
+
+        for phantom in self.text.iter() {
+            let location = phantom.col + col_shift;
+
+            // Stop iterating if the location is bad
+            if text.get(location..).is_none() {
+                return text;
+            }
+
+            text.insert_str(location, &phantom.text);
+            col_shift += phantom.text.len();
+        }
+
+        text
+    }
+
+    /// Iterator over (col_shift, size, hint, pre_column)
+    /// Note that this only iterates over the ordered text, since those depend on the text for where
+    /// they'll be positioned
+    pub fn offset_size_iter(
+        &self,
+    ) -> impl Iterator<Item = (usize, usize, usize, &PhantomText)> + '_ {
+        let mut col_shift = 0;
+
+        self.text.iter().map(move |phantom| {
+            let pre_col_shift = col_shift;
+            col_shift += phantom.text.len();
+            (
+                pre_col_shift,
+                col_shift - pre_col_shift,
+                phantom.col,
+                phantom,
+            )
+        })
+    }
+}
+
+/// A [`Document`] is a core structure for files in the editor. All editors are merely views into a
+/// specific document, which is what allows views to be synchronized without any effort.  
+/// This builds on top of the held [`Buffer`], providing syntax/semantic highlighting, phantom
+/// text, and more.
 #[derive(Clone)]
 pub struct Document {
+    /// The id of the held buffer.  
+    /// If `content` is `BufferContent::Scratch` then their ids should be equivalent.
     id: BufferId,
+    /// The window-tab that this document is a part of.
     pub tab_id: WidgetId,
+    /// The underlying content held by the document.
     buffer: Buffer,
+    /// Information about what kind of buffer this is; like a file, a scratch buffer, or
+    /// the palette's input buffer.
     content: BufferContent,
+    /// Tree-sitter syntax highlighting information.
     syntax: Option<Syntax>,
     line_styles: Rc<RefCell<LineStyles>>,
+    /// Semantic highlighting information (which is provided by the LSP)
     semantic_styles: Option<Arc<Spans<Style>>>,
-    text_layouts: Rc<RefCell<TextLayoutCache>>,
+    /// The ready-to-render text layouts for the document.  
+    /// This is an `Rc<RefCell<_>>` due to needing to access it even when the document is borrowed,
+    /// since we may need to fill it with constructed text layouts.
+    pub text_layouts: Rc<RefCell<TextLayoutCache>>,
+    /// A cache for the sticky headers which maps a line to the lines it should show in the header.
+    pub sticky_headers: Rc<RefCell<HashMap<usize, Option<Vec<usize>>>>>,
+    /// Whether we've started loading the buffer's content, used for file loading since that
+    /// has to be done through a request to the proxy.
     load_started: Rc<RefCell<bool>>,
+    /// Whether the buffer's content has been loaded/initialized into the buffer.
     loaded: bool,
+    /// Stores information about different versions of the document from source control.
     histories: im::HashMap<String, DocumentHistory>,
+    /// The cursor's offset into the document, which is synced to the [`LapceEditorData::cursor`]
+    /// (You may be wanting [`LapceEditorData::cursor`] instead)
     pub cursor_offset: usize,
+    /// The scroll offset into the document, which is synced to the widget's scroll offset
     pub scroll_offset: Vec2,
-    pub code_actions: im::HashMap<usize, CodeActionResponse>,
+    /// (Offset -> (Plugin the code actions are from, Code Actions))
+    pub code_actions: im::HashMap<usize, (PluginId, CodeActionResponse)>,
+    /// Inlay hints for the document
+    pub inlay_hints: Option<Spans<InlayHint>>,
+    /// The diagnostics for the document
+    pub diagnostics: Option<Arc<Vec<EditorDiagnostic>>>,
+    /// Current completion text which should be rendered at the `completion_pos`, as phantom text
+    completion: Option<Arc<String>>,
+    /// (line, col) position that the completion text should be displayed at.
+    completion_pos: (usize, usize),
+    /// Current IME text which should be rendered at the `ime_pos`, as phantom text
+    ime_text: Option<Arc<str>>,
+    /// (line, col, shift) position that the IME text should be displayed at.
+    ime_pos: (usize, usize, usize),
+    /// Information about specific ranges that are used to do smarter selections, supplied by an LSP
+    pub syntax_selection_range: Option<SyntaxSelectionRanges>,
+    /// Information about the file-specific find box
     pub find: Rc<RefCell<Find>>,
     find_progress: Rc<RefCell<FindProgress>>,
+    /// Event sink so that we can submit commands to the event loop
     pub event_sink: ExtEventSink,
     pub proxy: Arc<LapceProxy>,
 }
@@ -200,12 +444,17 @@ impl Document {
         event_sink: ExtEventSink,
         proxy: Arc<LapceProxy>,
     ) -> Self {
+        // Only files have syntax highlighing automatically,
+        // though scratch buffer can have it be set manually by the user.
         let syntax = match &content {
-            BufferContent::File(path) => Syntax::init(path),
+            BufferContent::File(path) => {
+                Self::syntax_to_option(&proxy, Syntax::init(path))
+            }
             BufferContent::Local(_) => None,
             BufferContent::SettingsValue(..) => None,
             BufferContent::Scratch(..) => None,
         };
+        // Since scratch specifies its own id, we have to use that as our buffer id.
         let id = match &content {
             BufferContent::Scratch(id, _) => *id,
             _ => BufferId::next(),
@@ -219,6 +468,7 @@ impl Document {
             syntax,
             line_styles: Rc::new(RefCell::new(HashMap::new())),
             text_layouts: Rc::new(RefCell::new(TextLayoutCache::new())),
+            sticky_headers: Rc::new(RefCell::new(HashMap::new())),
             semantic_styles: None,
             load_started: Rc::new(RefCell::new(false)),
             histories: im::HashMap::new(),
@@ -226,17 +476,48 @@ impl Document {
             cursor_offset: 0,
             scroll_offset: Vec2::ZERO,
             code_actions: im::HashMap::new(),
+            inlay_hints: None,
+            diagnostics: None,
+            completion: None,
+            completion_pos: (0, 0),
+            ime_text: None,
+            ime_pos: (0, 0, 0),
             find: Rc::new(RefCell::new(Find::new(0))),
             find_progress: Rc::new(RefCell::new(FindProgress::Ready)),
             event_sink,
             proxy,
+            syntax_selection_range: None,
+        }
+    }
+
+    /// Converts a syntax highlighting result into an option, showing an error message if it is
+    /// anything unexpected.
+    fn syntax_to_option(
+        proxy: &Arc<LapceProxy>,
+        syntax: Result<Syntax, HighlightIssue>,
+    ) -> Option<Syntax> {
+        match syntax {
+            Ok(x) => Some(x),
+            Err(HighlightIssue::NotAvailable) => None,
+            Err(HighlightIssue::Error(x)) => {
+                proxy.core_rpc.show_message(
+                    "Syntax Highlighting failed".to_owned(),
+                    ShowMessageParams {
+                        typ: MessageType::ERROR,
+                        message: format!("An error occurred trying to load syntax highlighting info: {x}."),
+                    },
+                );
+                None
+            }
         }
     }
 
+    /// The id of the document's buffer
     pub fn id(&self) -> BufferId {
         self.id
     }
 
+    /// Whether or not the underlying buffer is loaded
     pub fn loaded(&self) -> bool {
         self.loaded
     }
@@ -244,7 +525,9 @@ impl Document {
     pub fn set_content(&mut self, content: BufferContent) {
         self.content = content;
         self.syntax = match &self.content {
-            BufferContent::File(path) => Syntax::init(path),
+            BufferContent::File(path) => {
+                Self::syntax_to_option(&self.proxy, Syntax::init(path))
+            }
             BufferContent::Local(_) => None,
             BufferContent::SettingsValue(..) => None,
             BufferContent::Scratch(..) => None,
@@ -256,10 +539,12 @@ impl Document {
         &self.content
     }
 
+    /// Get the buffer's current revision. This is used to track whether the buffer has changed.
     pub fn rev(&self) -> u64 {
         self.buffer.rev()
     }
 
+    //// Initialize the content with some text, this marks the document as loaded.
     pub fn init_content(&mut self, content: Rope) {
         self.buffer.init_content(content);
         self.buffer.detect_indent(self.syntax.as_ref());
@@ -267,12 +552,116 @@ impl Document {
         self.on_update(None);
     }
 
+    /// Set the syntax highlighting this document should use.
     pub fn set_language(&mut self, language: LapceLanguage) {
-        self.syntax = Some(Syntax::from_language(language));
+        self.syntax =
+            Self::syntax_to_option(&self.proxy, Syntax::from_language(language));
+    }
+
+    pub fn set_diagnostics(&mut self, diagnostics: &[EditorDiagnostic]) {
+        self.clear_text_layout_cache();
+        self.clear_code_actions();
+        self.diagnostics = Some(Arc::new(
+            diagnostics
+                .iter()
+                // We discard diagnostics that have bad positions
+                .map(|d| EditorDiagnostic {
+                    range: (
+                        self.buffer.offset_of_position(&d.diagnostic.range.start),
+                        self.buffer.offset_of_position(&d.diagnostic.range.end),
+                    ),
+                    lines: d.lines,
+                    diagnostic: d.diagnostic.clone(),
+                })
+                .collect(),
+        ));
+    }
+
+    /// Update the diagnostics' positions after an edit so that they appear in the correct place.
+    fn update_diagnostics(&mut self, delta: &RopeDelta) {
+        let Some(mut diagnostics) = self.diagnostics.clone() else { return };
+
+        for diagnostic in Arc::make_mut(&mut diagnostics).iter_mut() {
+            let mut transformer = Transformer::new(delta);
+            let (start, end) = diagnostic.range;
+            let (new_start, new_end) = (
+                transformer.transform(start, false),
+                transformer.transform(end, true),
+            );
+
+            let new_start_pos = self.buffer().offset_to_position(new_start);
+
+            let new_end_pos = self.buffer().offset_to_position(new_end);
+
+            diagnostic.range = (new_start, new_end);
+
+            diagnostic.diagnostic.range.start = new_start_pos;
+            diagnostic.diagnostic.range.end = new_end_pos;
+        }
+
+        self.diagnostics = Some(diagnostics);
     }
 
+    /// Get the current completion phantomtext
+    pub fn completion(&self) -> Option<&str> {
+        self.completion.as_deref().map(String::as_str)
+    }
+
+    pub fn set_completion(&mut self, completion: String, line: usize, col: usize) {
+        self.clear_text_layout_cache();
+        self.completion = Some(Arc::new(completion));
+        self.completion_pos = (line, col);
+    }
+
+    pub fn clear_completion(&mut self) {
+        if self.completion.is_some() {
+            self.clear_text_layout_cache();
+        }
+        self.completion = None;
+    }
+
+    /// Update the completion lens position after an edit so that it appears in the correct place.
+    fn update_completion(&mut self, delta: &RopeDelta) {
+        let Some(completion) = self.completion.clone() else { return };
+
+        let (line, col) = self.completion_pos;
+        let offset = self.buffer().offset_of_line_col(line, col);
+
+        // If the edit is easily checkable & updateable from, then we change
+        // the completion's text. Because, in normal typing (if we didn't do this)
+        // then the text would jitter forward and then backwards as the completion widget
+        // updates it.
+        // TODO: this could also handle simple deletion, but we don't currently keep track of
+        // the past completion string content.
+        if delta.as_simple_insert().is_some() {
+            let (iv, new_len) = delta.summary();
+            if iv.start() == iv.end()
+                && iv.start() == offset
+                && new_len <= completion.len()
+            {
+                // Remove the # of newly inserted characters
+                // These aren't necessarily the same as the characters literally in the
+                // text, but the completion will be updated when the completion widget
+                // receives the update event, and it will fix this if needed.
+                // TODO: this could be smarter and use the insert's content
+                self.completion = Some(Arc::new(completion[new_len..].to_string()))
+            }
+        }
+
+        // Shift the position by the rope delta
+        let mut transformer = Transformer::new(delta);
+
+        let new_offset = transformer.transform(offset, true);
+        let new_pos = self.buffer().offset_to_line_col(new_offset);
+
+        self.completion_pos = new_pos;
+    }
+
+    /// Reload the document's content, and is what you should typically use when you want to *set*
+    /// an existing document's content.
     pub fn reload(&mut self, content: Rope, set_pristine: bool) {
         self.code_actions.clear();
+        self.inlay_hints = None;
         let delta = self.buffer.reload(content, set_pristine);
         self.apply_deltas(&[delta]);
     }
@@ -283,7 +672,15 @@ impl Document {
         }
     }
 
-    pub fn retrieve_file(&mut self, locations: Vec<(WidgetId, EditorLocation)>) {
+    /// Retrieve a file from the poxy, initialized to a specific starting location.  
+    /// Has no effect if the file is already loaded.
+    pub fn retrieve_file<P: EditorPosition + Send + 'static>(
+        &mut self,
+        locations: Vec<(WidgetId, EditorLocation<P>)>,
+        unsaved_buffer: Option<Rope>,
+        cb: Option<InitBufferContentCb>,
+        config: &LapceConfig,
+    ) {
         if self.loaded || *self.load_started.borrow() {
             return;
         }
@@ -296,39 +693,34 @@ impl Document {
             let event_sink = self.event_sink.clone();
             let proxy = self.proxy.clone();
             std::thread::spawn(move || {
-                proxy.new_buffer(
-                    id,
-                    path.clone(),
-                    Box::new(move |result| {
-                        if let Ok(res) = result {
-                            if let Ok(resp) =
-                                serde_json::from_value::<NewBufferResponse>(res)
-                            {
-                                let _ = event_sink.submit_command(
-                                    LAPCE_UI_COMMAND,
-                                    LapceUICommand::InitBufferContent {
-                                        path,
-                                        content: Rope::from(resp.content),
-                                        locations,
-                                    },
-                                    Target::Widget(tab_id),
-                                );
-                            }
-                        };
-                    }),
-                )
+                proxy.proxy_rpc.new_buffer(id, path.clone(), move |result| {
+                    if let Ok(ProxyResponse::NewBufferResponse { content }) = result
+                    {
+                        let _ = event_sink.submit_command(
+                            LAPCE_UI_COMMAND,
+                            P::init_buffer_content_cmd(
+                                path,
+                                Rope::from(content),
+                                locations,
+                                unsaved_buffer,
+                                cb,
+                            ),
+                            Target::Widget(tab_id),
+                        );
+                    };
+                })
             });
         }
 
-        self.retrieve_history("head");
+        self.retrieve_history("head", config.editor.diff_context_lines);
     }
 
-    pub fn retrieve_history(&mut self, version: &str) {
+    pub fn retrieve_history(&mut self, version: &str, diff_context_lines: i32) {
         if self.histories.contains_key(version) {
             return;
         }
 
-        let history = DocumentHistory::new(version.to_string());
+        let history = DocumentHistory::new(version.to_string(), diff_context_lines);
         history.retrieve(self);
         self.histories.insert(version.to_string(), history);
     }
@@ -339,8 +731,14 @@ impl Document {
         }
     }
 
-    pub fn load_history(&mut self, version: &str, content: Rope) {
-        let mut history = DocumentHistory::new(version.to_string());
+    pub fn load_history(
+        &mut self,
+        version: &str,
+        content: Rope,
+        diff_context_lines: i32,
+    ) {
+        let mut history =
+            DocumentHistory::new(version.to_string(), diff_context_lines);
         history.load_content(content, self);
         self.histories.insert(version.to_string(), history);
     }
@@ -443,17 +841,24 @@ impl Document {
         }
     }
 
+    pub fn trigger_history_change(&self, version: &str) {
+        if let Some(history) = self.histories.get(version) {
+            history.trigger_update_change(self);
+        }
+    }
+
     pub fn update_history_changes(
         &mut self,
         rev: u64,
         version: &str,
         changes: Arc<Vec<DiffLines>>,
+        diff_context_lines: i32,
     ) {
         if rev != self.rev() {
             return;
         }
         if let Some(history) = self.histories.get_mut(version) {
-            history.update_changes(changes);
+            history.update_changes(changes, diff_context_lines);
         }
     }
 
@@ -467,31 +872,151 @@ impl Document {
         }
     }
 
-    fn on_update(&mut self, delta: Option<&RopeDelta>) {
+    /// Request semantic styles for the buffer from the LSP through the proxy.
+    fn get_semantic_styles(&self) {
+        if !self.loaded() {
+            return;
+        }
+
+        if !self.content().is_file() {
+            return;
+        }
+        if let BufferContent::File(path) = self.content() {
+            let tab_id = self.tab_id;
+            let path = path.clone();
+            let buffer_id = self.id();
+            let buffer = self.buffer();
+            let rev = buffer.rev();
+            let len = buffer.len();
+            let event_sink = self.event_sink.clone();
+            let syntactic_styles =
+                self.syntax().and_then(|s| s.styles.as_ref()).cloned();
+
+            self.proxy
+                .proxy_rpc
+                .get_semantic_tokens(path.clone(), move |result| {
+                    if let Ok(ProxyResponse::GetSemanticTokens { styles }) = result {
+                        rayon::spawn(move || {
+                            let mut styles_span = SpansBuilder::new(len);
+                            for style in styles.styles {
+                                styles_span.add_span(
+                                    Interval::new(style.start, style.end),
+                                    style.style,
+                                );
+                            }
+
+                            let styles = styles_span.build();
+
+                            let styles =
+                                if let Some(syntactic_styles) = syntactic_styles {
+                                    syntactic_styles.merge(&styles, |a, b| {
+                                        if let Some(b) = b {
+                                            return b.clone();
+                                        }
+                                        a.clone()
+                                    })
+                                } else {
+                                    styles
+                                };
+                            let styles = Arc::new(styles);
+
+                            let _ = event_sink.submit_command(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::UpdateSemanticStyles {
+                                    id: buffer_id,
+                                    path,
+                                    rev,
+                                    styles,
+                                },
+                                Target::Widget(tab_id),
+                            );
+                        });
+                    }
+                });
+        }
+    }
+
+    /// Request inlay hints for the buffer from the LSP through the proxy.
+    pub fn get_inlay_hints(&self) {
+        if !self.loaded() {
+            return;
+        }
+
+        if !self.content().is_file() {
+            return;
+        }
+
+        if let BufferContent::File(path) = self.content() {
+            let tab_id = self.tab_id;
+            let path = path.clone();
+            let buffer = self.buffer().clone();
+            let rev = buffer.rev();
+            let len = buffer.len();
+            let event_sink = self.event_sink.clone();
+            self.proxy
+                .proxy_rpc
+                .get_inlay_hints(path.clone(), move |result| {
+                    if let Ok(ProxyResponse::GetInlayHints { mut hints }) = result {
+                        // Sort the inlay hints by their position, as the LSP does not guarantee that it will
+                        // provide them in the order that they are in within the file
+                        // as well, Spans does not iterate in the order that they appear
+                        hints.sort_by(|left, right| {
+                            left.position.cmp(&right.position)
+                        });
+
+                        let mut hints_span = SpansBuilder::new(len);
+                        for hint in hints {
+                            let offset =
+                                buffer.offset_of_position(&hint.position).min(len);
+                            hints_span.add_span(
+                                Interval::new(offset, (offset + 1).min(len)),
+                                hint,
+                            );
+                        }
+                        let hints = hints_span.build();
+                        let _ = event_sink.submit_command(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::UpdateInlayHints { path, rev, hints },
+                            Target::Widget(tab_id),
+                        );
+                    }
+                });
+        }
+    }
+
+    fn on_update(&mut self, edits: Option<SmallVec<[SyntaxEdit; 3]>>) {
+        self.clear_code_actions();
         self.find.borrow_mut().unset();
         *self.find_progress.borrow_mut() = FindProgress::Started;
+        self.get_inlay_hints();
         self.clear_style_cache();
-        self.trigger_syntax_change(delta);
+        self.trigger_syntax_change(edits);
+        self.get_semantic_styles();
+        self.clear_sticky_headers_cache();
         self.trigger_head_change();
         self.notify_special();
     }
 
+    /// Notify special buffer content's about their content potentially changing.
     fn notify_special(&self) {
         match &self.content {
             BufferContent::File(_) => {}
             BufferContent::Scratch(..) => {}
             BufferContent::Local(local) => {
-                let s = self.buffer.text().to_string();
+                let s = self.buffer.to_string();
                 match local {
                     LocalBufferKind::Search => {
                         let _ = self.event_sink.submit_command(
                             LAPCE_UI_COMMAND,
-                            LapceUICommand::UpdateSearch(s),
+                            LapceUICommand::UpdateSearch(s, None),
                             Target::Widget(self.tab_id),
                         );
                     }
+                    LocalBufferKind::PluginSearch => {}
                     LocalBufferKind::SourceControl => {}
+                    LocalBufferKind::BranchesFilter => {}
                     LocalBufferKind::Empty => {}
+                    LocalBufferKind::Rename => {}
                     LocalBufferKind::Palette => {
                         let _ = self.event_sink.submit_command(
                             LAPCE_UI_COMMAND,
@@ -521,6 +1046,9 @@ impl Document {
                             Target::Widget(self.tab_id),
                         );
                     }
+                    LocalBufferKind::PathName => {
+                        // TODO: anything to update with this?
+                    }
                 }
             }
             BufferContent::SettingsValue(..) => {}
@@ -532,6 +1060,11 @@ impl Document {
         if self.semantic_styles.is_none() {
             self.clear_style_cache();
         }
+        self.clear_sticky_headers_cache();
+    }
+
+    fn clear_sticky_headers_cache(&self) {
+        self.sticky_headers.borrow_mut().clear();
     }
 
     pub fn set_semantic_styles(&mut self, styles: Option<Arc<Spans<Style>>>) {
@@ -548,34 +1081,27 @@ impl Document {
         self.text_layouts.borrow_mut().clear();
     }
 
-    fn trigger_syntax_change(&self, delta: Option<&RopeDelta>) {
-        if let Some(syntax) = self.syntax.clone() {
-            let content = self.content.clone();
-            let rev = self.buffer.rev();
-            let text = self.buffer.text().clone();
-            let delta = delta.cloned();
-            let atomic_rev = self.buffer.atomic_rev();
-            let event_sink = self.event_sink.clone();
-            let tab_id = self.tab_id;
-            rayon::spawn(move || {
-                if atomic_rev.load(atomic::Ordering::Acquire) != rev {
-                    return;
-                }
-                let new_syntax = syntax.parse(rev, text, delta);
-                if atomic_rev.load(atomic::Ordering::Acquire) != rev {
-                    return;
-                }
-                let _ = event_sink.submit_command(
-                    LAPCE_UI_COMMAND,
-                    LapceUICommand::UpdateSyntax {
-                        content,
-                        rev,
-                        syntax: SingleUse::new(new_syntax),
-                    },
-                    Target::Widget(tab_id),
-                );
-            });
-        }
+    fn clear_code_actions(&mut self) {
+        self.code_actions.clear();
+    }
+
+    pub fn trigger_syntax_change(
+        &mut self,
+        edits: Option<SmallVec<[SyntaxEdit; 3]>>,
+    ) {
+        let Some(syntax)  = self.syntax.as_mut() else { return };
+
+        let rev = self.buffer.rev();
+        let text = self.buffer.text().clone();
+
+        syntax.parse(rev, text, edits.as_deref());
+    }
+
+    /// Update the inlay hints with new ones
+    /// Clears any caches that need to be updated after change
+    pub fn set_inlay_hints(&mut self, hints: Spans<InlayHint>) {
+        self.inlay_hints = Some(hints);
+        self.clear_text_layout_cache();
     }
 
     pub fn buffer(&self) -> &Buffer {
@@ -590,10 +1116,13 @@ impl Document {
         self.syntax.as_ref()
     }
 
+    /// Update the styles after an edit, so the highlights are at the correct positions.  
+    /// This does not do a reparse of the document itself.
     fn update_styles(&mut self, delta: &RopeDelta) {
         if let Some(styles) = self.semantic_styles.as_mut() {
             Arc::make_mut(styles).apply_shape(delta);
-        } else if let Some(syntax) = self.syntax.as_mut() {
+        }
+        if let Some(syntax) = self.syntax.as_mut() {
             if let Some(styles) = syntax.styles.as_mut() {
                 Arc::make_mut(styles).apply_shape(delta);
             }
@@ -604,31 +1133,260 @@ impl Document {
         }
     }
 
-    fn apply_deltas(&mut self, deltas: &[(RopeDelta, InvalLines)]) {
+    /// Update the inlay hints so their positions are correct after an edit.
+    fn update_inlay_hints(&mut self, delta: &RopeDelta) {
+        if let Some(hints) = self.inlay_hints.as_mut() {
+            hints.apply_shape(delta);
+        }
+    }
+
+    pub fn set_ime_pos(&mut self, line: usize, col: usize, shift: usize) {
+        self.ime_pos = (line, col, shift);
+    }
+
+    pub fn ime_text(&self) -> Option<&Arc<str>> {
+        self.ime_text.as_ref()
+    }
+
+    pub fn ime_pos(&self) -> (usize, usize, usize) {
+        self.ime_pos
+    }
+
+    pub fn set_ime_text(&mut self, text: &str) {
+        self.ime_text = Some(Arc::from(text));
+        self.clear_text_layout_cache();
+    }
+
+    pub fn clear_ime_text(&mut self) {
+        if self.ime_text.is_some() {
+            self.ime_text = None;
+            self.clear_text_layout_cache();
+        }
+    }
+
+    /// Get the phantom text for a given line
+    pub fn line_phantom_text(
+        &self,
+        config: &LapceConfig,
+        line: usize,
+    ) -> PhantomTextLine {
+        let start_offset = self.buffer.offset_of_line(line);
+        let end_offset = self.buffer.offset_of_line(line + 1);
+
+        // If hints are enabled, and the hints field is filled, then get the hints for this line
+        // and convert them into PhantomText instances
+        let hints = config
+            .editor
+            .enable_inlay_hints
+            .then_some(())
+            .and(self.inlay_hints.as_ref())
+            .map(|hints| hints.iter_chunks(start_offset..end_offset))
+            .into_iter()
+            .flatten()
+            .filter(|(interval, _)| {
+                interval.start >= start_offset && interval.start < end_offset
+            })
+            .map(|(interval, inlay_hint)| {
+                let (_, col) = self.buffer.offset_to_line_col(interval.start);
+                let text = match &inlay_hint.label {
+                    InlayHintLabel::String(label) => label.to_string(),
+                    InlayHintLabel::LabelParts(parts) => {
+                        parts.iter().map(|p| &p.value).join("")
+                    }
+                };
+                PhantomText {
+                    kind: PhantomTextKind::InlayHint,
+                    col,
+                    text,
+                    fg: Some(
+                        config
+                            .get_color_unchecked(LapceTheme::INLAY_HINT_FOREGROUND)
+                            .clone(),
+                    ),
+                    font_family: Some(config.editor.inlay_hint_font_family()),
+                    font_size: Some(config.editor.inlay_hint_font_size()),
+                    bg: Some(
+                        config
+                            .get_color_unchecked(LapceTheme::INLAY_HINT_BACKGROUND)
+                            .clone(),
+                    ),
+                    under_line: None,
+                }
+            });
+        // You're quite unlikely to have more than six hints on a single line
+        // this later has the diagnostics added onto it, but that's still likely to be below six
+        // overall.
+        let mut text: SmallVec<[PhantomText; 6]> = hints.collect();
+
+        // The max severity is used to determine the color given to the background of the line
+        let mut max_severity = None;
+        // If error lens is enabled, and the diagnostics field is filled, then get the diagnostics
+        // that end on this line which have a severity worse than HINT and convert them into
+        // PhantomText instances
+        let diag_text = config
+            .editor
+            .enable_error_lens
+            .then_some(())
+            .and(self.diagnostics.as_ref())
+            .map(|x| x.iter())
+            .into_iter()
+            .flatten()
+            .filter(|diag| {
+                diag.diagnostic.range.end.line as usize == line
+                    && diag.diagnostic.severity < Some(DiagnosticSeverity::HINT)
+            })
+            .map(|diag| {
+                match (diag.diagnostic.severity, max_severity) {
+                    (Some(severity), Some(max)) => {
+                        if severity < max {
+                            max_severity = Some(severity);
+                        }
+                    }
+                    (Some(severity), None) => {
+                        max_severity = Some(severity);
+                    }
+                    _ => {}
+                }
+
+                let rope_text = self.buffer.rope_text();
+                let col = rope_text.offset_of_line(line + 1)
+                    - rope_text.offset_of_line(line);
+                let fg = {
+                    let severity = diag
+                        .diagnostic
+                        .severity
+                        .unwrap_or(DiagnosticSeverity::WARNING);
+                    let theme_prop = if severity == DiagnosticSeverity::ERROR {
+                        LapceTheme::ERROR_LENS_ERROR_FOREGROUND
+                    } else if severity == DiagnosticSeverity::WARNING {
+                        LapceTheme::ERROR_LENS_WARNING_FOREGROUND
+                    } else {
+                        // information + hint (if we keep that) + things without a severity
+                        LapceTheme::ERROR_LENS_OTHER_FOREGROUND
+                    };
+
+                    config.get_color_unchecked(theme_prop).clone()
+                };
+                let text =
+                    format!("    {}", diag.diagnostic.message.lines().join(" "));
+                PhantomText {
+                    kind: PhantomTextKind::Diagnostic,
+                    col,
+                    text,
+                    fg: Some(fg),
+                    font_size: Some(config.editor.error_lens_font_size()),
+                    font_family: Some(config.editor.error_lens_font_family()),
+                    bg: None,
+                    under_line: None,
+                }
+            });
+        let mut diag_text: SmallVec<[PhantomText; 6]> = diag_text.collect();
+
+        text.append(&mut diag_text);
+
+        let (completion_line, completion_col) = self.completion_pos;
+        let completion_text = config
+            .editor
+            .enable_completion_lens
+            .then_some(())
+            .and(self.completion.as_ref())
+            // TODO: We're probably missing on various useful completion things to include here!
+            .filter(|_| line == completion_line)
+            .map(|completion| PhantomText {
+                kind: PhantomTextKind::Completion,
+                col: completion_col,
+                text: completion.to_string(),
+                fg: Some(
+                    config
+                        .get_color_unchecked(LapceTheme::COMPLETION_LENS_FOREGROUND)
+                        .clone(),
+                ),
+                font_size: Some(config.editor.completion_lens_font_size()),
+                font_family: Some(config.editor.completion_lens_font_family()),
+                bg: None,
+                under_line: None,
+                // TODO: italics?
+            });
+        if let Some(completion_text) = completion_text {
+            text.push(completion_text);
+        }
+
+        if let Some(ime_text) = self.ime_text.as_ref() {
+            let (ime_line, col, _) = self.ime_pos;
+            if line == ime_line {
+                text.push(PhantomText {
+                    kind: PhantomTextKind::Ime,
+                    text: ime_text.to_string(),
+                    col,
+                    font_size: None,
+                    font_family: None,
+                    fg: None,
+                    bg: None,
+                    under_line: Some(
+                        config
+                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                            .clone(),
+                    ),
+                });
+            }
+        }
+
+        text.sort_by(|a, b| {
+            if a.col == b.col {
+                a.kind.cmp(&b.kind)
+            } else {
+                a.col.cmp(&b.col)
+            }
+        });
+
+        PhantomTextLine { text, max_severity }
+    }
+
+    fn apply_deltas(&mut self, deltas: &[(RopeDelta, InvalLines, SyntaxEdit)]) {
         let rev = self.rev() - deltas.len() as u64;
-        for (i, (delta, _)) in deltas.iter().enumerate() {
+        for (i, (delta, _, _)) in deltas.iter().enumerate() {
             self.update_styles(delta);
-            if self.content.is_file() {
-                self.proxy.update(self.id, delta, rev + i as u64 + 1);
+            self.update_inlay_hints(delta);
+            self.update_diagnostics(delta);
+            self.update_completion(delta);
+            if let BufferContent::File(path) = &self.content {
+                self.proxy.proxy_rpc.update(
+                    path.clone(),
+                    delta.clone(),
+                    rev + i as u64 + 1,
+                );
             }
         }
 
-        let delta = if deltas.len() == 1 {
-            Some(&deltas[0].0)
-        } else {
-            None
-        };
-        self.on_update(delta);
+        // TODO(minor): We could avoid this potential allocation since most apply_delta callers are actually using a Vec
+        // which we could reuse.
+        // We use a smallvec because there is unlikely to be more than a couple of deltas
+        let edits = deltas.iter().map(|(_, _, edits)| edits.clone()).collect();
+        self.on_update(Some(edits));
     }
 
     pub fn do_insert(
         &mut self,
         cursor: &mut Cursor,
         s: &str,
-    ) -> Vec<(RopeDelta, InvalLines)> {
+        config: &LapceConfig,
+    ) -> Vec<(RopeDelta, InvalLines, SyntaxEdit)> {
         let old_cursor = cursor.mode.clone();
-        let deltas =
-            Editor::insert(cursor, &mut self.buffer, s, self.syntax.as_ref());
+        let auto_closing = config.editor.auto_closing_matching_pairs
+            && match self.content {
+                BufferContent::File(_) => true,
+                BufferContent::Local(_) => false,
+                BufferContent::SettingsValue(_) => false,
+                BufferContent::Scratch(_, _) => true,
+            };
+        let deltas = Editor::insert(
+            cursor,
+            &mut self.buffer,
+            s,
+            self.syntax.as_ref(),
+            auto_closing,
+        );
+        // Keep track of the change in the cursor mode for undo/redo
         self.buffer_mut().set_cursor_before(old_cursor);
         self.buffer_mut().set_cursor_after(cursor.mode.clone());
         self.apply_deltas(&deltas);
@@ -639,10 +1397,10 @@ impl Document {
         &mut self,
         edits: &[(impl AsRef<Selection>, &str)],
         edit_type: EditType,
-    ) -> (RopeDelta, InvalLines) {
-        let (delta, inval_lines) = self.buffer.edit(edits, edit_type);
-        self.apply_deltas(&[(delta.clone(), inval_lines.clone())]);
-        (delta, inval_lines)
+    ) -> (RopeDelta, InvalLines, SyntaxEdit) {
+        let (delta, inval_lines, edits) = self.buffer.edit(edits, edit_type);
+        self.apply_deltas(&[(delta.clone(), inval_lines.clone(), edits.clone())]);
+        (delta, inval_lines, edits)
     }
 
     pub fn do_edit(
@@ -651,7 +1409,7 @@ impl Document {
         cmd: &EditCommand,
         modal: bool,
         register: &mut Register,
-    ) -> Vec<(RopeDelta, InvalLines)> {
+    ) -> Vec<(RopeDelta, InvalLines, SyntaxEdit)> {
         let mut clipboard = SystemClipboard {};
         let old_cursor = cursor.mode.clone();
         let deltas = Editor::do_edit(
@@ -663,8 +1421,12 @@ impl Document {
             modal,
             register,
         );
-        self.buffer_mut().set_cursor_before(old_cursor);
-        self.buffer_mut().set_cursor_after(cursor.mode.clone());
+
+        if !deltas.is_empty() {
+            self.buffer_mut().set_cursor_before(old_cursor);
+            self.buffer_mut().set_cursor_after(cursor.mode.clone());
+        }
+
         self.apply_deltas(&deltas);
         deltas
     }
@@ -674,7 +1436,8 @@ impl Document {
         text: &mut PietText,
         cursor: &mut Cursor,
         cmd: &MultiSelectionCommand,
-        config: &Config,
+        view: &EditorView,
+        config: &LapceConfig,
     ) {
         use MultiSelectionCommand::*;
         match cmd {
@@ -690,7 +1453,7 @@ impl Document {
             }
             InsertCursorAbove => {
                 if let CursorMode::Insert(mut selection) = cursor.mode.clone() {
-                    let offset = selection.first().map(|s| s.end()).unwrap_or(0);
+                    let offset = selection.first().map(|s| s.end).unwrap_or(0);
                     let (new_offset, _) = self.move_offset(
                         text,
                         offset,
@@ -698,7 +1461,7 @@ impl Document {
                         1,
                         &Movement::Up,
                         Mode::Insert,
-                        config.editor.font_size,
+                        view,
                         config,
                     );
                     if new_offset != offset {
@@ -711,7 +1474,7 @@ impl Document {
             }
             InsertCursorBelow => {
                 if let CursorMode::Insert(mut selection) = cursor.mode.clone() {
-                    let offset = selection.last().map(|s| s.end()).unwrap_or(0);
+                    let offset = selection.last().map(|s| s.end).unwrap_or(0);
                     let (new_offset, _) = self.move_offset(
                         text,
                         offset,
@@ -719,7 +1482,7 @@ impl Document {
                         1,
                         &Movement::Down,
                         Mode::Insert,
-                        config.editor.font_size,
+                        view,
                         config,
                     );
                     if new_offset != offset {
@@ -761,29 +1524,35 @@ impl Document {
                         let end = self.buffer.offset_of_line(end_line + 1);
                         new_selection.add_region(SelRegion::new(start, end, None));
                     }
-                    cursor.set_insert(selection);
+                    cursor.set_insert(new_selection);
                 }
             }
             SelectAllCurrent => {
-                if let CursorMode::Insert(selection) = cursor.mode.clone() {
-                    let mut new_selection = Selection::new();
+                if let CursorMode::Insert(mut selection) = cursor.mode.clone() {
                     if !selection.is_empty() {
                         let first = selection.first().unwrap();
                         let (start, end) = if first.is_caret() {
-                            self.buffer.select_word(first.start())
+                            self.buffer.select_word(first.start)
                         } else {
                             (first.min(), first.max())
                         };
                         let search_str = self.buffer.slice_to_cow(start..end);
+                        let case_sensitive = self.find.borrow().case_sensitive();
+                        let multicursor_case_sensitive =
+                            config.editor.multicursor_case_sensitive;
+                        let case_sensitive =
+                            multicursor_case_sensitive || case_sensitive;
+                        let search_whole_word =
+                            config.editor.multicursor_whole_words;
                         let mut find = Find::new(0);
-                        find.set_find(&search_str, false, false, false);
+                        find.set_case_sensitive(case_sensitive);
+                        find.set_find(&search_str, false, search_whole_word);
                         let mut offset = 0;
                         while let Some((start, end)) =
                             find.next(self.buffer.text(), offset, false, false)
                         {
                             offset = end;
-                            new_selection
-                                .add_region(SelRegion::new(start, end, None));
+                            selection.add_region(SelRegion::new(start, end, None));
                         }
                     }
                     cursor.set_insert(selection);
@@ -797,7 +1566,7 @@ impl Document {
                             if region.is_caret() {
                                 had_caret = true;
                                 let (start, end) =
-                                    self.buffer.select_word(region.start());
+                                    self.buffer.select_word(region.start);
                                 region.start = start;
                                 region.end = end;
                             }
@@ -806,8 +1575,15 @@ impl Document {
                             let r = selection.last_inserted().unwrap();
                             let search_str =
                                 self.buffer.slice_to_cow(r.min()..r.max());
+                            let case_sensitive = self.find.borrow().case_sensitive();
+                            let case_sensitive =
+                                config.editor.multicursor_case_sensitive
+                                    || case_sensitive;
+                            let search_whole_word =
+                                config.editor.multicursor_whole_words;
                             let mut find = Find::new(0);
-                            find.set_find(&search_str, false, false, false);
+                            find.set_case_sensitive(case_sensitive);
+                            find.set_find(&search_str, false, search_whole_word);
                             let mut offset = r.max();
                             let mut seen = HashSet::new();
                             while let Some((start, end)) =
@@ -839,15 +1615,17 @@ impl Document {
                     if !selection.is_empty() {
                         let r = selection.last_inserted().unwrap();
                         if r.is_caret() {
-                            let (start, end) = self.buffer.select_word(r.start());
+                            let (start, end) = self.buffer.select_word(r.start);
                             selection.replace_last_inserted_region(SelRegion::new(
                                 start, end, None,
                             ));
                         } else {
                             let search_str =
                                 self.buffer.slice_to_cow(r.min()..r.max());
+                            let case_sensitive = self.find.borrow().case_sensitive();
                             let mut find = Find::new(0);
-                            find.set_find(&search_str, false, false, false);
+                            find.set_case_sensitive(case_sensitive);
+                            find.set_find(&search_str, false, false);
                             let mut offset = r.max();
                             let mut seen = HashSet::new();
                             while let Some((start, end)) =
@@ -912,14 +1690,18 @@ impl Document {
         self.apply_deltas(&deltas)
     }
 
+    /// Get the active style information, either the semantic styles or the
+    /// tree-sitter syntax styles.
     pub fn styles(&self) -> Option<&Arc<Spans<Style>>> {
-        let styles = self
-            .semantic_styles
-            .as_ref()
-            .or_else(|| self.syntax().and_then(|s| s.styles.as_ref()));
-        styles
+        if let Some(semantic_styles) = self.semantic_styles.as_ref() {
+            Some(semantic_styles)
+        } else {
+            self.syntax().and_then(|s| s.styles.as_ref())
+        }
     }
 
+    /// Get the style information for the particular line from semantic/syntax highlighting.  
+    /// This caches the result if possible.
     fn line_style(&self, line: usize) -> Arc<Vec<LineStyle>> {
         if self.line_styles.borrow().get(&line).is_none() {
             let styles = self.styles();
@@ -934,84 +1716,460 @@ impl Document {
         self.line_styles.borrow().get(&line).cloned().unwrap()
     }
 
-    pub fn point_of_line_col(
-        &self,
-        text: &mut PietText,
-        line: usize,
-        col: usize,
-        font_size: usize,
-        config: &Config,
-    ) -> Point {
-        let text_layout = self.get_text_layout(text, line, font_size, config);
-        text_layout.hit_test_text_position(col).point
-    }
-
-    pub fn offset_of_point(
+    /// Get the (line, col) of a particular point within the editor.
+    /// The boolean indicates whether the point is within the text bounds.  
+    /// Points outside of vertical bounds will return the last line.
+    /// Points outside of horizontal bounds will return the last column on the line.
+    pub fn line_col_of_point(
         &self,
         text: &mut PietText,
         mode: Mode,
         point: Point,
-        font_size: usize,
-        config: &Config,
-    ) -> (usize, bool) {
-        let last_line = self.buffer.last_line();
-        let line = ((point.y / config.editor.line_height as f64).floor() as usize)
-            .min(last_line);
-        let text_layout = self.get_text_layout(text, line, font_size, config);
-        let hit_point = text_layout.hit_test_point(Point::new(point.x, 0.0));
-        let col = hit_point.idx;
+        view: &EditorView,
+        config: &LapceConfig,
+    ) -> ((usize, usize), bool) {
+        let (line, font_size) = match view {
+            EditorView::Diff(version) => {
+                let changes = self
+                    .get_history(version)
+                    .map(|h| h.changes())
+                    .unwrap_or_default();
+                let line_height = config.editor.line_height();
+                // Tracks the actual line in the file.
+                let mut line = 0;
+                // Tracks the lines that are displayed in the editor.
+                let mut lines = 0;
+                for change in changes {
+                    match change {
+                        DiffLines::Left(l) => {
+                            lines += l.len();
+                            if (lines * line_height) as f64 > point.y {
+                                break;
+                            }
+                        }
+                        DiffLines::Skip(_l, r) => {
+                            // Skip only has one line rendered, so we only update this by 1
+                            lines += 1;
+                            if (lines * line_height) as f64 > point.y {
+                                break;
+                            }
+                            // However, skip moves forward multiple lines in the underlying
+                            // file so we need to update this.
+                            line += r.len();
+                        }
+                        DiffLines::Both(_, r) | DiffLines::Right(r) => {
+                            lines += r.len();
+                            if (lines * line_height) as f64 > point.y {
+                                line += ((point.y
+                                    - ((lines - r.len()) * line_height) as f64)
+                                    / line_height as f64)
+                                    .floor()
+                                    as usize;
+                                break;
+                            }
+                            line += r.len();
+                        }
+                    }
+                }
+                (line, config.editor.font_size)
+            }
+            EditorView::Lens => {
+                if let Some(syntax) = self.syntax() {
+                    // If we have a syntax, then we need to do logic which handles that some text
+                    // will be the smaller lens font size, and some text will be larger (like
+                    // function names). We can just use the utility functions on the lens for this.
+                    let lens = &syntax.lens;
+                    let line = lens.line_of_height(point.y.round() as usize);
+                    let line_height =
+                        lens.height_of_line(line + 1) - lens.height_of_line(line);
+                    let font_size = if line_height < config.editor.line_height() {
+                        config.editor.code_lens_font_size
+                    } else {
+                        config.editor.font_size
+                    };
+                    (line, font_size)
+                } else {
+                    // The entire file is small, so we can just do a division.
+                    (
+                        (point.y / config.editor.line_height() as f64).floor()
+                            as usize,
+                        config.editor.font_size,
+                    )
+                }
+            }
+            EditorView::Normal => (
+                (point.y / config.editor.line_height() as f64).floor() as usize,
+                config.editor.font_size,
+            ),
+        };
+
+        let line = line.min(self.buffer.last_line());
+
+        let mut x_shift = 0.0;
+        if font_size < config.editor.font_size {
+            let line_content = self.buffer.line_content(line);
+            let mut col = 0usize;
+            for ch in line_content.chars() {
+                if ch == ' ' || ch == '\t' {
+                    col += 1;
+                } else {
+                    break;
+                }
+            }
+
+            // If there's indentation, then we look at the difference between the normal text
+            // and the shrunk text to shift the point over.
+            if col > 0 {
+                let normal_text_layout = self.get_text_layout(
+                    text,
+                    line,
+                    config.editor.font_size,
+                    config,
+                );
+                let small_text_layout =
+                    self.get_text_layout(text, line, font_size, config);
+                x_shift =
+                    normal_text_layout.text.hit_test_text_position(col).point.x
+                        - small_text_layout.text.hit_test_text_position(col).point.x;
+            }
+        }
+
+        // Since we have the line, we can do a hit test after shifting the point to be within the
+        // line itself
+        let text_layout = self.get_text_layout(text, line, font_size, config);
+        let hit_point = text_layout
+            .text
+            .hit_test_point(Point::new(point.x - x_shift, 0.0));
+        // We have to unapply the phantom text shifting in order to get back to the column in
+        // the actual buffer
+        let phantom_text = self.line_phantom_text(config, line);
+        let col = phantom_text.before_col(hit_point.idx);
+        // Ensure that the column doesn't end up out of bounds, so things like clicking on the far
+        // right end will just go to the end of the line.
         let max_col = self.buffer.line_end_col(line, mode != Mode::Normal);
+        let mut col = col.min(max_col);
+
+        if config.editor.atomic_soft_tabs && config.editor.tab_width > 1 {
+            col = snap_to_soft_tab_line_col(
+                &self.buffer,
+                line,
+                col,
+                SnapDirection::Nearest,
+                config.editor.tab_width,
+            );
+        }
+
+        ((line, col), hit_point.is_inside)
+    }
+
+    /// Get the offset of a particular point within the editor.  
+    /// The boolean indicates whether the point is inside the text or not
+    /// Points outside of vertical bounds will return the last line.
+    /// Points outside of horizontal bounds will return the last column on the line.
+    pub fn offset_of_point(
+        &self,
+        text: &mut PietText,
+        mode: Mode,
+        point: Point,
+        view: &EditorView,
+        config: &LapceConfig,
+    ) -> (usize, bool) {
+        let ((line, col), is_inside) =
+            self.line_col_of_point(text, mode, point, view, config);
+        (self.buffer.offset_of_line_col(line, col), is_inside)
+    }
+
+    /// Get the (point above, point below) of a particular offset within the editor.
+    pub fn points_of_offset(
+        &self,
+        text: &mut PietText,
+        offset: usize,
+        view: &EditorView,
+        config: &LapceConfig,
+    ) -> (Point, Point) {
+        let (line, col) = self.buffer.offset_to_line_col(offset);
+        self.points_of_line_col(text, line, col, view, config)
+    }
+
+    /// Get the (point above, point below) of a particular (line, col) within the editor.
+    pub fn points_of_line_col(
+        &self,
+        text: &mut PietText,
+        line: usize,
+        col: usize,
+        view: &EditorView,
+        config: &LapceConfig,
+    ) -> (Point, Point) {
+        let (y, line_height, font_size) = match view {
+            EditorView::Diff(version) => {
+                let changes = self
+                    .get_history(version)
+                    .map(|h| h.changes())
+                    .unwrap_or_default();
+                let line_height = config.editor.line_height();
+                let mut current_line = 0;
+                let mut y = 0;
+                for change in changes {
+                    match change {
+                        DiffLines::Left(l) => {
+                            y += l.len() * line_height;
+                        }
+                        DiffLines::Skip(_l, r) => {
+                            if current_line + r.len() > line {
+                                break;
+                            }
+                            y += line_height;
+                            current_line += r.len();
+                        }
+                        DiffLines::Both(_, r) | DiffLines::Right(r) => {
+                            if current_line + r.len() > line {
+                                y += line_height * (line - current_line);
+                                break;
+                            }
+                            y += r.len() * line_height;
+                            current_line += r.len();
+                        }
+                    }
+                }
+                (y, config.editor.line_height(), config.editor.font_size)
+            }
+            EditorView::Lens => {
+                if let Some(syntax) = self.syntax() {
+                    let lens = &syntax.lens;
+                    let height = lens.height_of_line(line);
+                    let line_height =
+                        lens.height_of_line(line + 1) - lens.height_of_line(line);
+                    let font_size = if line_height < config.editor.line_height() {
+                        config.editor.code_lens_font_size
+                    } else {
+                        config.editor.font_size
+                    };
+                    (height, line_height, font_size)
+                } else {
+                    (
+                        config.editor.line_height() * line,
+                        config.editor.line_height(),
+                        config.editor.font_size,
+                    )
+                }
+            }
+            EditorView::Normal => (
+                config.editor.line_height() * line,
+                config.editor.line_height(),
+                config.editor.font_size,
+            ),
+        };
+
+        let line = line.min(self.buffer.last_line());
+
+        let phantom_text = self.line_phantom_text(config, line);
+        let col = phantom_text.col_after(col, false);
+
+        let mut x_shift = 0.0;
+        if font_size < config.editor.font_size {
+            let line_content = self.buffer.line_content(line);
+            let mut col = 0usize;
+            for ch in line_content.chars() {
+                if ch == ' ' || ch == '\t' {
+                    col += 1;
+                } else {
+                    break;
+                }
+            }
+
+            if col > 0 {
+                let normal_text_layout = self.get_text_layout(
+                    text,
+                    line,
+                    config.editor.font_size,
+                    config,
+                );
+                let small_text_layout =
+                    self.get_text_layout(text, line, font_size, config);
+                x_shift =
+                    normal_text_layout.text.hit_test_text_position(col).point.x
+                        - small_text_layout.text.hit_test_text_position(col).point.x;
+            }
+        }
+
+        let x = self
+            .line_point_of_line_col(text, line, col, font_size, config)
+            .x
+            + x_shift;
         (
-            self.buffer.offset_of_line_col(line, col.min(max_col)),
-            hit_point.is_inside,
+            Point::new(x, y as f64),
+            Point::new(x, (y + line_height) as f64),
         )
     }
 
-    pub fn point_of_offset(
+    fn diff_cursor_line(&self, version: &str, line: usize) -> usize {
+        let mut cursor_line = 0;
+        if let Some(history) = self.get_history(version) {
+            for (_i, change) in history.changes().iter().enumerate() {
+                match change {
+                    DiffLines::Left(_range) => {}
+                    DiffLines::Both(_, r) | DiffLines::Right(r) => {
+                        if r.contains(&line) {
+                            cursor_line += line - r.start;
+                            break;
+                        }
+                        cursor_line += r.len();
+                    }
+                    DiffLines::Skip(_, r) => {
+                        if r.contains(&line) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        cursor_line
+    }
+
+    fn diff_actual_line(&self, version: &str, cursor_line: usize) -> usize {
+        let mut current_cursor_line = 0;
+        let mut line = 0;
+        if let Some(history) = self.get_history(version) {
+            for (_i, change) in history.changes().iter().enumerate() {
+                match change {
+                    DiffLines::Left(_range) => {}
+                    DiffLines::Skip(_, _r) => {}
+                    DiffLines::Both(_, r) | DiffLines::Right(r) => {
+                        current_cursor_line += r.len();
+                        if current_cursor_line > cursor_line {
+                            line = r.end - (current_cursor_line - cursor_line);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if current_cursor_line <= cursor_line {
+            self.buffer.last_line()
+        } else {
+            line
+        }
+    }
+
+    /// Returns the point into the text layout of the line at the given offset.
+    /// `x` being the leading edge of the character, and `y` being the baseline.
+    pub fn line_point_of_offset(
         &self,
         text: &mut PietText,
         offset: usize,
         font_size: usize,
-        config: &Config,
+        config: &LapceConfig,
     ) -> Point {
         let (line, col) = self.buffer.offset_to_line_col(offset);
+        self.line_point_of_line_col(text, line, col, font_size, config)
+    }
+
+    /// Returns the point into the text layout of the line at the given line and column.
+    /// `x` being the leading edge of the character, and `y` being the baseline.
+    pub fn line_point_of_line_col(
+        &self,
+        text: &mut PietText,
+        line: usize,
+        col: usize,
+        font_size: usize,
+        config: &LapceConfig,
+    ) -> Point {
         let text_layout = self.get_text_layout(text, line, font_size, config);
-        text_layout.hit_test_text_position(col).point
+        text_layout.text.hit_test_text_position(col).point
     }
 
+    /// Get the text layout for the given line.  
+    /// If the text layout is not cached, it will be created and cached.
     pub fn get_text_layout(
         &self,
         text: &mut PietText,
         line: usize,
         font_size: usize,
-        config: &Config,
-    ) -> Arc<PietTextLayout> {
+        config: &LapceConfig,
+    ) -> Arc<TextLayoutLine> {
+        // Check if the text layout needs to update due to the config being changed
         self.text_layouts.borrow_mut().check_attributes(config.id);
-        if self.text_layouts.borrow().layouts.get(&line).is_none() {
-            self.text_layouts.borrow_mut().layouts.insert(
-                line,
-                Arc::new(self.new_text_layout(text, line, font_size, config)),
-            );
+        // If we don't have a second layer of the hashmap initialized for this specific font size,
+        // do it now
+        if self.text_layouts.borrow().layouts.get(&font_size).is_none() {
+            let mut cache = self.text_layouts.borrow_mut();
+            cache.layouts.insert(font_size, HashMap::new());
+        }
+
+        // Get whether there's an entry for this specific font size and line
+        let cache_exists = self
+            .text_layouts
+            .borrow()
+            .layouts
+            .get(&font_size)
+            .unwrap()
+            .get(&line)
+            .is_some();
+        // If there isn't an entry then we actually have to create it
+        if !cache_exists {
+            let text_layout =
+                Arc::new(self.new_text_layout(text, line, font_size, config));
+            let mut cache = self.text_layouts.borrow_mut();
+            let width = text_layout.text.size().width;
+            if width > cache.max_width {
+                cache.max_width = width;
+            }
+            cache
+                .layouts
+                .get_mut(&font_size)
+                .unwrap()
+                .insert(line, text_layout);
         }
+
+        // Just get the entry, assuming it has been created because we initialize it above.
         self.text_layouts
             .borrow()
             .layouts
+            .get(&font_size)
+            .unwrap()
             .get(&line)
             .cloned()
             .unwrap()
     }
 
+    /// Create a new text layout for the given line.  
+    /// Typically you should use [`Document::get_text_layout`] instead.
     fn new_text_layout(
         &self,
         text: &mut PietText,
         line: usize,
         font_size: usize,
-        config: &Config,
-    ) -> PietTextLayout {
-        let line_content = self.buffer.line_content(line);
+        config: &LapceConfig,
+    ) -> TextLayoutLine {
+        let line_content_original = self.buffer.line_content(line);
+
+        // Get the line content with newline characters replaced with spaces
+        // and the content without the newline characters
+        let (line_content, line_content_original) =
+            if let Some(s) = line_content_original.strip_suffix("\r\n") {
+                (
+                    format!("{s}  "),
+                    &line_content_original[..line_content_original.len() - 2],
+                )
+            } else if let Some(s) = line_content_original.strip_suffix('\n') {
+                (
+                    format!("{s} ",),
+                    &line_content_original[..line_content_original.len() - 1],
+                )
+            } else {
+                (
+                    line_content_original.to_string(),
+                    &line_content_original[..],
+                )
+            };
+        // Combine the phantom text with the line content
+        let phantom_text = self.line_phantom_text(config, line);
+        let line_content = phantom_text.combine_with_text(line_content);
+
         let tab_width =
             config.tab_width(text, config.editor.font_family(), font_size);
 
+        // Inputs use the UI font instead of the editor font
         let font_family = if self.content.is_input() {
             config.ui.font_family()
         } else {
@@ -1032,19 +2190,202 @@ impl Document {
             )
             .set_tab_width(tab_width);
 
+        // Apply various styles to the line's text based on our semantic/syntax highlighting
         let styles = self.line_style(line);
         for line_style in styles.iter() {
             if let Some(fg_color) = line_style.style.fg_color.as_ref() {
                 if let Some(fg_color) = config.get_style_color(fg_color) {
+                    let start = phantom_text.col_at(line_style.start);
+                    let end = phantom_text.col_at(line_style.end);
                     layout_builder = layout_builder.range_attribute(
-                        line_style.start..line_style.end,
+                        start..end,
                         TextAttribute::TextColor(fg_color.clone()),
                     );
                 }
             }
         }
 
-        layout_builder.build().unwrap()
+        // Apply phantom text specific styling
+        for (offset, size, col, phantom) in phantom_text.offset_size_iter() {
+            let start = col + offset;
+            let end = start + size;
+
+            if let Some(fg) = phantom.fg.clone() {
+                layout_builder = layout_builder
+                    .range_attribute(start..end, TextAttribute::TextColor(fg));
+            }
+            if let Some(phantom_font_size) = phantom.font_size {
+                layout_builder = layout_builder.range_attribute(
+                    start..end,
+                    TextAttribute::FontSize(phantom_font_size.min(font_size) as f64),
+                );
+            }
+            if let Some(font_family) = phantom.font_family.clone() {
+                layout_builder = layout_builder.range_attribute(
+                    start..end,
+                    TextAttribute::FontFamily(font_family),
+                );
+            }
+        }
+
+        let text_layout = layout_builder.build().unwrap();
+
+        let mut extra_style = Vec::new();
+
+        // Keep track of background styling from phantom text, which is done separately
+        // from the text layout attributes
+        for (offset, size, col, phantom) in phantom_text.offset_size_iter() {
+            if phantom.bg.is_some() || phantom.under_line.is_some() {
+                let start = col + offset;
+                let end = start + size;
+                let x0 = text_layout.hit_test_text_position(start).point.x;
+                let x1 = text_layout.hit_test_text_position(end).point.x;
+                extra_style.push((
+                    x0,
+                    Some(x1),
+                    LineExtraStyle {
+                        bg_color: phantom.bg.clone(),
+                        under_line: phantom.under_line.clone(),
+                    },
+                ));
+            }
+        }
+
+        // Add the styling for the diagnostic severity, if applicable
+        if let Some(max_severity) = phantom_text.max_severity {
+            let theme_prop = if max_severity == DiagnosticSeverity::ERROR {
+                LapceTheme::ERROR_LENS_ERROR_BACKGROUND
+            } else if max_severity == DiagnosticSeverity::WARNING {
+                LapceTheme::ERROR_LENS_WARNING_BACKGROUND
+            } else {
+                LapceTheme::ERROR_LENS_OTHER_BACKGROUND
+            };
+
+            let x1 = (!config.editor.error_lens_end_of_line).then(|| {
+                text_layout
+                    .hit_test_text_position(line_content.len())
+                    .point
+                    .x
+            });
+
+            extra_style.push((
+                0.0,
+                x1,
+                LineExtraStyle {
+                    bg_color: Some(config.get_color_unchecked(theme_prop).clone()),
+                    under_line: None,
+                },
+            ));
+        }
+
+        let new_whitespaces = Self::new_whitespace_layout(
+            line_content_original,
+            &text_layout,
+            &phantom_text,
+            config,
+        );
+
+        let indent_line = if line_content_original.trim().is_empty() {
+            let offset = self.buffer.offset_of_line(line);
+            if let Some(offset) = self
+                .syntax
+                .as_ref()
+                .and_then(|syntax| syntax.parent_offset(offset))
+            {
+                self.buffer.line_of_offset(offset)
+            } else {
+                line
+            }
+        } else {
+            line
+        };
+
+        let indent = if indent_line != line {
+            self.get_text_layout(text, indent_line, font_size, config)
+                .indent
+                + 1.0
+        } else {
+            let offset = self.buffer.first_non_blank_character_on_line(indent_line);
+            let (_, col) = self.buffer.offset_to_line_col(offset);
+            text_layout.hit_test_text_position(col).point.x
+        };
+
+        TextLayoutLine {
+            text: text_layout,
+            extra_style,
+            whitespaces: new_whitespaces,
+            indent,
+        }
+    }
+
+    /// Create rendable whitespace layout by creating a new text layout
+    /// with invisible spaces and special utf8 characters that display
+    /// the different white space characters.
+    fn new_whitespace_layout(
+        line_content: &str,
+        text_layout: &PietTextLayout,
+        phantom: &PhantomTextLine,
+        config: &LapceConfig,
+    ) -> Option<Vec<(char, (f64, f64))>> {
+        let mut render_leading = false;
+        let mut render_boundary = false;
+        let mut render_between = false;
+
+        // TODO: render whitespaces only on highlighted text
+        match config.editor.render_whitespace.as_str() {
+            "all" => {
+                render_leading = true;
+                render_boundary = true;
+                render_between = true;
+            }
+            "boundary" => {
+                render_leading = true;
+                render_boundary = true;
+            }
+            "trailing" => {} // All configs include rendering trailing whitespace
+            _ => return None,
+        }
+
+        let mut whitespace_buffer = Vec::new();
+        let mut rendered_whitespaces: Vec<(char, (f64, f64))> = Vec::new();
+        let mut char_found = false;
+        let mut col = 0;
+        for c in line_content.chars() {
+            match c {
+                '\t' => {
+                    let col_left = phantom.col_after(col, true);
+                    let col_right = phantom.col_after(col + 1, false);
+                    let x0 = text_layout.hit_test_text_position(col_left).point.x;
+                    let x1 = text_layout.hit_test_text_position(col_right).point.x;
+                    whitespace_buffer.push(('\t', (x0, x1)));
+                }
+                ' ' => {
+                    let col_left = phantom.col_after(col, true);
+                    let col_right = phantom.col_after(col + 1, false);
+                    let x0 = text_layout.hit_test_text_position(col_left).point.x;
+                    let x1 = text_layout.hit_test_text_position(col_right).point.x;
+                    whitespace_buffer.push((' ', (x0, x1)));
+                }
+                _ => {
+                    if (char_found && render_between)
+                        || (char_found
+                            && render_boundary
+                            && whitespace_buffer.len() > 1)
+                        || (!char_found && render_leading)
+                    {
+                        rendered_whitespaces.extend(whitespace_buffer.iter());
+                    } else {
+                    }
+
+                    char_found = true;
+                    whitespace_buffer.clear();
+                }
+            }
+            col += c.len_utf8();
+        }
+        rendered_whitespaces.extend(whitespace_buffer.iter());
+
+        Some(rendered_whitespaces)
     }
 
     pub fn line_horiz_col(
@@ -1054,13 +2395,13 @@ impl Document {
         font_size: usize,
         horiz: &ColPosition,
         caret: bool,
-        config: &Config,
+        config: &LapceConfig,
     ) -> usize {
         match *horiz {
             ColPosition::Col(x) => {
                 let text_layout =
                     self.get_text_layout(text, line, font_size, config);
-                let n = text_layout.hit_test_point(Point::new(x, 0.0)).idx;
+                let n = text_layout.text.hit_test_point(Point::new(x, 0.0)).idx;
                 n.min(self.buffer.line_end_col(line, caret))
             }
             ColPosition::End => self.buffer.line_end_col(line, caret),
@@ -1071,6 +2412,9 @@ impl Document {
         }
     }
 
+    /// Move a selection region by a given movement.  
+    /// Much of the time, this will just be a matter of moving the cursor, but
+    /// some movements may depend on the current selection.
     #[allow(clippy::too_many_arguments)]
     fn move_region(
         &self,
@@ -1080,9 +2424,33 @@ impl Document {
         modify: bool,
         movement: &Movement,
         mode: Mode,
-        font_size: usize,
-        config: &Config,
+        view: &EditorView,
+        config: &LapceConfig,
     ) -> SelRegion {
+        let (count, region) = if count >= 1 && !modify && !region.is_caret() {
+            // If we're not a caret, and we are moving left/up or right/down, we want to move
+            // the cursor to the left or right side of the selection.
+            // Ex: `|abc|` -> left/up arrow key -> `|abc`
+            // Ex: `|abc|` -> right/down arrow key -> `abc|`
+            // and it doesn't matter which direction the selection os going, so we use min/max
+            match movement {
+                Movement::Left | Movement::Up => {
+                    let leftmost = region.min();
+                    (count - 1, SelRegion::new(leftmost, leftmost, region.horiz))
+                }
+                Movement::Right | Movement::Down => {
+                    let rightmost = region.max();
+                    (
+                        count - 1,
+                        SelRegion::new(rightmost, rightmost, region.horiz),
+                    )
+                }
+                _ => (count, *region),
+            }
+        } else {
+            (count, *region)
+        };
+
         let (end, horiz) = self.move_offset(
             text,
             region.end,
@@ -1090,11 +2458,11 @@ impl Document {
             count,
             movement,
             mode,
-            font_size,
+            view,
             config,
         );
         let start = match modify {
-            true => region.start(),
+            true => region.start,
             false => end,
         };
         SelRegion::new(start, end, horiz)
@@ -1108,9 +2476,9 @@ impl Document {
         movement: &Movement,
         count: usize,
         modify: bool,
-        font_size: usize,
+        view: &EditorView,
         register: &mut Register,
-        config: &Config,
+        config: &LapceConfig,
     ) {
         match cursor.mode {
             CursorMode::Normal(offset) => {
@@ -1121,7 +2489,7 @@ impl Document {
                     count,
                     movement,
                     Mode::Normal,
-                    font_size,
+                    view,
                     config,
                 );
                 if let Some(motion_mode) = cursor.motion_mode.clone() {
@@ -1132,7 +2500,7 @@ impl Document {
                         1,
                         &Movement::Right,
                         Mode::Insert,
-                        font_size,
+                        view,
                         config,
                     );
                     let (start, end) = match movement {
@@ -1172,7 +2540,7 @@ impl Document {
                     count,
                     movement,
                     Mode::Visual,
-                    font_size,
+                    view,
                     config,
                 );
                 cursor.mode = CursorMode::Visual {
@@ -1191,7 +2559,7 @@ impl Document {
                     modify,
                     movement,
                     Mode::Insert,
-                    font_size,
+                    view,
                     config,
                 );
                 cursor.set_insert(selection);
@@ -1209,13 +2577,13 @@ impl Document {
         modify: bool,
         movement: &Movement,
         mode: Mode,
-        font_size: usize,
-        config: &Config,
+        view: &EditorView,
+        config: &LapceConfig,
     ) -> Selection {
         let mut new_selection = Selection::new();
         for region in selection.regions() {
             new_selection.add_region(self.move_region(
-                text, region, count, modify, movement, mode, font_size, config,
+                text, region, count, modify, movement, mode, view, config,
             ));
         }
         new_selection
@@ -1230,50 +2598,102 @@ impl Document {
         count: usize,
         movement: &Movement,
         mode: Mode,
-        font_size: usize,
-        config: &Config,
+        view: &EditorView,
+        config: &LapceConfig,
     ) -> (usize, Option<ColPosition>) {
         match movement {
             Movement::Left => {
-                let line = self.buffer.line_of_offset(offset);
-                let line_start_offset = self.buffer.offset_of_line(line);
+                let mut new_offset = self.buffer.move_left(offset, mode, count);
 
-                let min_offset = if mode == Mode::Insert {
-                    0
-                } else {
-                    line_start_offset
-                };
+                if config.editor.atomic_soft_tabs && config.editor.tab_width > 1 {
+                    new_offset = snap_to_soft_tab(
+                        &self.buffer,
+                        new_offset,
+                        SnapDirection::Left,
+                        config.editor.tab_width,
+                    );
+                }
 
-                let new_offset =
-                    self.buffer.prev_grapheme_offset(offset, count, min_offset);
                 (new_offset, None)
             }
             Movement::Right => {
-                let line_end =
-                    self.buffer.offset_line_end(offset, mode != Mode::Normal);
-
-                let max_offset = if mode == Mode::Insert {
-                    self.buffer.len()
-                } else {
-                    line_end
-                };
+                let mut new_offset = self.buffer.move_right(offset, mode, count);
 
-                let new_offset =
-                    self.buffer.next_grapheme_offset(offset, count, max_offset);
+                if config.editor.atomic_soft_tabs && config.editor.tab_width > 1 {
+                    new_offset = snap_to_soft_tab(
+                        &self.buffer,
+                        new_offset,
+                        SnapDirection::Right,
+                        config.editor.tab_width,
+                    );
+                }
 
                 (new_offset, None)
             }
             Movement::Up => {
                 let line = self.buffer.line_of_offset(offset);
-                let line = if line == 0 {
-                    0
-                } else {
-                    line.saturating_sub(count)
+                if line == 0 {
+                    let line = self.buffer.line_of_offset(offset);
+                    let new_offset = self.buffer.offset_of_line(line);
+                    return (new_offset, Some(ColPosition::Start));
+                }
+
+                let (line, font_size) = match view {
+                    EditorView::Lens => {
+                        if let Some(syntax) = self.syntax() {
+                            let lens = &syntax.lens;
+                            let line = if count == 1 {
+                                let mut line = line - 1;
+                                loop {
+                                    if line == 0 {
+                                        break;
+                                    }
+
+                                    let line_height = lens.height_of_line(line + 1)
+                                        - lens.height_of_line(line);
+                                    if line_height == config.editor.line_height() {
+                                        break;
+                                    }
+                                    line -= 1;
+                                }
+                                line
+                            } else {
+                                line.saturating_sub(count)
+                            };
+                            let line_height = lens.height_of_line(line + 1)
+                                - lens.height_of_line(line);
+                            let font_size =
+                                if line_height == config.editor.line_height() {
+                                    config.editor.font_size
+                                } else {
+                                    config.editor.code_lens_font_size
+                                };
+
+                            (line, font_size)
+                        } else {
+                            (line.saturating_sub(count), config.editor.font_size)
+                        }
+                    }
+                    EditorView::Diff(version) => {
+                        let cursor_line = self.diff_cursor_line(version, line);
+                        let cursor_line = if cursor_line > count {
+                            cursor_line - count
+                        } else {
+                            0
+                        };
+                        (
+                            self.diff_actual_line(version, cursor_line),
+                            config.editor.font_size,
+                        )
+                    }
+                    EditorView::Normal => {
+                        (line.saturating_sub(count), config.editor.font_size)
+                    }
                 };
 
                 let horiz = horiz.cloned().unwrap_or_else(|| {
                     ColPosition::Col(
-                        self.point_of_offset(text, offset, font_size, config).x,
+                        self.line_point_of_offset(text, offset, font_size, config).x,
                     )
                 });
                 let col = self.line_horiz_col(
@@ -1290,12 +2710,64 @@ impl Document {
             Movement::Down => {
                 let last_line = self.buffer.last_line();
                 let line = self.buffer.line_of_offset(offset);
+                if line == last_line {
+                    let new_offset =
+                        self.buffer.offset_line_end(offset, mode != Mode::Normal);
+                    return (new_offset, Some(ColPosition::End));
+                }
+
+                let (line, font_size) = match view {
+                    EditorView::Lens => {
+                        if let Some(syntax) = self.syntax() {
+                            let lens = &syntax.lens;
+                            let line = if count == 1 {
+                                let mut line = (line + 1).min(last_line);
+                                loop {
+                                    if line == last_line {
+                                        break;
+                                    }
+
+                                    let line_height = lens.height_of_line(line + 1)
+                                        - lens.height_of_line(line);
+                                    if line_height == config.editor.line_height() {
+                                        break;
+                                    }
+                                    line += 1;
+                                }
+                                line
+                            } else {
+                                line + count
+                            };
+                            let line_height = lens.height_of_line(line + 1)
+                                - lens.height_of_line(line);
+                            let font_size =
+                                if line_height == config.editor.line_height() {
+                                    config.editor.font_size
+                                } else {
+                                    config.editor.code_lens_font_size
+                                };
+
+                            (line, font_size)
+                        } else {
+                            (line + count, config.editor.font_size)
+                        }
+                    }
+                    EditorView::Diff(version) => {
+                        let cursor_line = self.diff_cursor_line(version, line);
+                        let cursor_line = cursor_line + count;
+                        (
+                            self.diff_actual_line(version, cursor_line),
+                            config.editor.font_size,
+                        )
+                    }
+                    EditorView::Normal => (line + count, config.editor.font_size),
+                };
 
-                let line = (line + count).min(last_line);
+                let line = line.min(last_line);
 
                 let horiz = horiz.cloned().unwrap_or_else(|| {
                     ColPosition::Col(
-                        self.point_of_offset(text, offset, font_size, config).x,
+                        self.line_point_of_offset(text, offset, font_size, config).x,
                     )
                 });
                 let col = self.line_horiz_col(
@@ -1352,9 +2824,26 @@ impl Document {
                     LinePosition::First => 0,
                     LinePosition::Last => self.buffer.last_line(),
                 };
+                let font_size = if let EditorView::Lens = view {
+                    if let Some(syntax) = self.syntax() {
+                        let lens = &syntax.lens;
+                        let line_height = lens.height_of_line(line + 1)
+                            - lens.height_of_line(line);
+
+                        if line_height == config.editor.line_height() {
+                            config.editor.font_size
+                        } else {
+                            config.editor.code_lens_font_size
+                        }
+                    } else {
+                        config.editor.font_size
+                    }
+                } else {
+                    config.editor.font_size
+                };
                 let horiz = horiz.cloned().unwrap_or_else(|| {
                     ColPosition::Col(
-                        self.point_of_offset(text, offset, font_size, config).x,
+                        self.line_point_of_offset(text, offset, font_size, config).x,
                     )
                 });
                 let col = self.line_horiz_col(
@@ -1390,31 +2879,32 @@ impl Document {
                 (new_offset, None)
             }
             Movement::WordBackward => {
-                let new_offset = self.buffer.move_n_words_backward(offset, count);
+                let new_offset =
+                    self.buffer.move_n_words_backward(offset, count, mode);
                 (new_offset, None)
             }
-            Movement::NextUnmatched(c) => {
+            Movement::NextUnmatched(char) => {
                 if let Some(syntax) = self.syntax.as_ref() {
                     let new_offset = syntax
-                        .find_tag(offset, false, &c.to_string())
+                        .find_tag(offset, false, &CharBuffer::from(char))
                         .unwrap_or(offset);
                     (new_offset, None)
                 } else {
                     let new_offset = WordCursor::new(self.buffer.text(), offset)
-                        .next_unmatched(*c)
+                        .next_unmatched(*char)
                         .map_or(offset, |new| new - 1);
                     (new_offset, None)
                 }
             }
-            Movement::PreviousUnmatched(c) => {
+            Movement::PreviousUnmatched(char) => {
                 if let Some(syntax) = self.syntax.as_ref() {
                     let new_offset = syntax
-                        .find_tag(offset, true, &c.to_string())
+                        .find_tag(offset, true, &CharBuffer::from(char))
                         .unwrap_or(offset);
                     (new_offset, None)
                 } else {
                     let new_offset = WordCursor::new(self.buffer.text(), offset)
-                        .previous_unmatched(*c)
+                        .previous_unmatched(*char)
                         .unwrap_or(offset);
                     (new_offset, None)
                 }
@@ -1431,6 +2921,16 @@ impl Document {
                     (new_offset, None)
                 }
             }
+            Movement::ParagraphForward => {
+                let new_offset =
+                    self.buffer.move_n_paragraphs_forward(offset, count);
+                (new_offset, None)
+            }
+            Movement::ParagraphBackward => {
+                let new_offset =
+                    self.buffer.move_n_paragraphs_backward(offset, count);
+                (new_offset, None)
+            }
         }
     }
 
@@ -1438,11 +2938,15 @@ impl Document {
         &self,
         text: &mut PietText,
         offset: usize,
-        config: &Config,
+        config: &LapceConfig,
     ) -> Size {
         let prev_offset = self.buffer.prev_code_boundary(offset);
         let empty_vec = Vec::new();
-        let code_actions = self.code_actions.get(&prev_offset).unwrap_or(&empty_vec);
+        let code_actions = self
+            .code_actions
+            .get(&prev_offset)
+            .map(|(_plugin_id, code_actions)| code_actions)
+            .unwrap_or(&empty_vec);
 
         let action_text_layouts: Vec<PietTextLayout> = code_actions
             .iter()
@@ -1468,7 +2972,7 @@ impl Document {
                 width = line_width;
             }
         }
-        let line_height = config.editor.line_height as f64;
+        let line_height = config.editor.line_height() as f64;
         Size::new(width, code_actions.len() as f64 * line_height)
     }
 
@@ -1565,4 +3069,77 @@ impl Document {
             }
         }
     }
+
+    /// Get the sticky headers for a particular line, creating them if necessary.
+    pub fn sticky_headers(&self, line: usize) -> Option<Vec<usize>> {
+        if let Some(lines) = self.sticky_headers.borrow().get(&line) {
+            return lines.clone();
+        }
+        let offset = self.buffer.offset_of_line(line + 1);
+        let lines = self.syntax.as_ref()?.sticky_headers(offset).map(|offsets| {
+            offsets
+                .iter()
+                .filter_map(|offset| {
+                    let l = self.buffer.line_of_offset(*offset);
+                    if l <= line {
+                        Some(l)
+                    } else {
+                        None
+                    }
+                })
+                .dedup()
+                .sorted()
+                .collect()
+        });
+        self.sticky_headers.borrow_mut().insert(line, lines.clone());
+        lines
+    }
+
+    pub fn change_syntax_selection(
+        &mut self,
+        direction: SelectionRangeDirection,
+    ) -> Option<Selection> {
+        if let Some(selections) = self.syntax_selection_range.as_mut() {
+            match direction {
+                SelectionRangeDirection::Next => selections.next_range(),
+                SelectionRangeDirection::Previous => selections.previous_range(),
+            }
+            .map(|range| {
+                let start = self.buffer.offset_of_position(&range.start);
+                let end = self.buffer.offset_of_position(&range.end);
+                selections.last_known_selection = Some((start, end));
+                Selection::region(start, end)
+            })
+        } else {
+            None
+        }
+    }
+
+    pub fn find_enclosing_brackets(&self, offset: usize) -> Option<(usize, usize)> {
+        let char_at_cursor = match self.buffer().char_at_offset(offset) {
+            Some(c) => c,
+            None => return None,
+        };
+
+        if let Some(syntax) = self.syntax() {
+            if matching_pair_direction(char_at_cursor).is_some() {
+                if let Some(new_offset) = syntax.find_matching_pair(offset) {
+                    if offset > new_offset {
+                        return Some((new_offset, offset));
+                    }
+                    return Some((offset, new_offset));
+                }
+            } else {
+                return syntax.find_enclosing_pair(offset);
+            }
+        }
+
+        let mut cursor = WordCursor::new(self.buffer.text(), offset);
+        if matching_pair_direction(char_at_cursor).is_some() {
+            let new_offset = cursor.match_pairs().unwrap_or(offset);
+            Some((offset, new_offset))
+        } else {
+            cursor.find_enclosing_pair()
+        }
+    }
 }
diff --git a/lapce-data/src/dropdown.rs b/lapce-data/src/dropdown.rs
new file mode 100644
index 0000000000..724bc2e495
--- /dev/null
+++ b/lapce-data/src/dropdown.rs
@@ -0,0 +1,77 @@
+use std::sync::Arc;
+
+use druid::{Data, WidgetId};
+
+use crate::{
+    config::{DropdownInfo, LapceConfig},
+    list::ListData,
+};
+
+/// Data for a dropdown menu.  
+/// **Note**: You should call `data.clone_with(config)` before passing it to the widget functions
+/// because we need access to a recent version of the config.
+#[derive(Clone)]
+pub struct DropdownData<T: Clone, D: Data> {
+    /// The index of the active item in the list, not necessarily the
+    /// same as the index of the selected item, because you have to
+    /// 'apply' the select item to change this
+    pub active_item_index: usize,
+    /// Whether the list is currently active for selection.
+    pub list_active: bool,
+    pub list: ListData<T, D>,
+}
+impl<T: Clone, D: Data> DropdownData<T, D> {
+    pub fn new(config: Arc<LapceConfig>, parent: WidgetId, data: D) -> Self {
+        let list = ListData::new(config, parent, data);
+        DropdownData {
+            active_item_index: 0,
+            list_active: false,
+            list,
+        }
+    }
+
+    pub fn clone_with(&self, config: Arc<LapceConfig>) -> Self {
+        let mut data = self.clone();
+        data.update_data(config);
+
+        data
+    }
+
+    pub fn update_data(&mut self, config: Arc<LapceConfig>) {
+        self.list.update_data(config);
+    }
+
+    pub fn update_active_item(&mut self) {
+        if self.list.current_selected_item().is_some() {
+            self.active_item_index = self.list.selected_index;
+        }
+    }
+
+    /// Show the dropdown-list. You'll need to request a layout.
+    pub fn show(&mut self) {
+        self.list_active = true;
+    }
+
+    /// Hide the dropdown-list from view. You'll need to request a layout.
+    pub fn hide(&mut self) {
+        self.list_active = false;
+    }
+
+    pub fn get_active_item(&self) -> Option<&T> {
+        self.list.items.get(self.active_item_index)
+    }
+}
+impl<D: Data> DropdownData<String, D> {
+    pub fn update_from_info(&mut self, info: DropdownInfo) {
+        self.active_item_index = info.active_index;
+        self.list.items = info.items;
+        self.list.selected_index = info.active_index;
+    }
+}
+impl<T: Clone + PartialEq + 'static, D: Data> Data for DropdownData<T, D> {
+    fn same(&self, other: &Self) -> bool {
+        self.active_item_index == other.active_item_index
+            && self.list_active == other.list_active
+            && self.list.same(&other.list)
+    }
+}
diff --git a/lapce-data/src/editor.rs b/lapce-data/src/editor.rs
index 9c17290071..7872973aed 100644
--- a/lapce-data/src/editor.rs
+++ b/lapce-data/src/editor.rs
@@ -1,65 +1,64 @@
-use crate::command::LapceCommand;
-use crate::command::LAPCE_COMMAND;
-use crate::command::LAPCE_SAVE_FILE_AS;
-use crate::command::{CommandExecuted, CommandKind};
-use crate::completion::{CompletionData, CompletionStatus, Snippet};
-use crate::config::Config;
-use crate::data::{
-    EditorDiagnostic, InlineFindDirection, LapceEditorData, LapceMainSplitData,
-    SplitContent,
+use std::{
+    cmp::Ordering,
+    collections::HashMap,
+    iter::Iterator,
+    path::{Path, PathBuf},
+    str::FromStr,
+    sync::Arc,
+    thread,
+    time::Duration,
 };
-use crate::document::BufferContent;
-use crate::document::Document;
-use crate::document::LocalBufferKind;
-use crate::hover::HoverData;
-use crate::hover::HoverStatus;
-use crate::keypress::KeyMap;
-use crate::keypress::KeyPressFocus;
-use crate::palette::PaletteData;
-use crate::proxy::path_from_url;
-use crate::{
-    command::{EnsureVisiblePosition, LapceUICommand, LAPCE_UI_COMMAND},
-    split::SplitMoveDirection,
-};
-use crate::{find::Find, split::SplitDirection};
-use crate::{proxy::LapceProxy, source_control::SourceControlData};
+
 use anyhow::{anyhow, Result};
 use crossbeam_channel::{self, bounded};
-use druid::piet::PietTextLayout;
-use druid::piet::Svg;
-use druid::FileDialogOptions;
-use druid::Modifiers;
 use druid::{
-    piet::PietText, Command, Env, EventCtx, Point, Rect, Target, Vec2, WidgetId,
+    piet::{PietText, PietTextLayout, Svg},
+    Color, Command, Env, EventCtx, ExtEventSink, FileDialogOptions, Modifiers,
+    MouseEvent, Point, Rect, Target, Vec2, WidgetId,
 };
-use druid::{ExtEventSink, MouseEvent};
 use indexmap::IndexMap;
-use lapce_core::buffer::{DiffLines, InvalLines};
-use lapce_core::command::{
-    EditCommand, FocusCommand, MotionModeCommand, MultiSelectionCommand,
-};
-use lapce_core::mode::{Mode, MotionMode};
 pub use lapce_core::syntax::Syntax;
-use lsp_types::CodeActionOrCommand;
-use lsp_types::CompletionTextEdit;
-use lsp_types::DocumentChangeOperation;
-use lsp_types::DocumentChanges;
-use lsp_types::OneOf;
-use lsp_types::TextEdit;
-use lsp_types::Url;
-use lsp_types::WorkspaceEdit;
+use lapce_core::{
+    buffer::{Buffer, DiffLines, InvalLines},
+    command::{EditCommand, FocusCommand, MotionModeCommand, MultiSelectionCommand},
+    editor::EditType,
+    mode::{Mode, MotionMode},
+    selection::{InsertDrift, Selection},
+    syntax::edit::SyntaxEdit,
+};
+use lapce_rpc::{plugin::PluginId, proxy::ProxyResponse};
+use lapce_xi_rope::{Rope, RopeDelta, Transformer};
 use lsp_types::{
-    CodeActionResponse, CompletionItem, DiagnosticSeverity, GotoDefinitionResponse,
-    Location, Position,
+    request::GotoTypeDefinitionResponse, CodeAction, CodeActionOrCommand,
+    CodeActionResponse, CompletionItem, CompletionTextEdit, DiagnosticSeverity,
+    DocumentChangeOperation, DocumentChanges, GotoDefinitionResponse, Location,
+    OneOf, Position, ResourceOp, TextEdit, Url, WorkspaceEdit,
+};
+
+use crate::{
+    command::{
+        CommandExecuted, CommandKind, EnsureVisiblePosition, InitBufferContent,
+        InitBufferContentCb, LapceCommand, LapceUICommand, LAPCE_COMMAND,
+        LAPCE_SAVE_FILE_AS, LAPCE_UI_COMMAND,
+    },
+    completion::{CompletionData, CompletionStatus, Snippet},
+    config::LapceConfig,
+    data::{
+        EditorDiagnostic, EditorView, FocusArea, InlineFindDirection,
+        LapceEditorData, LapceMainSplitData, SplitContent,
+    },
+    document::{BufferContent, Document, LocalBufferKind},
+    find::Find,
+    hover::{HoverData, HoverStatus},
+    keypress::{KeyMap, KeyPressFocus},
+    palette::PaletteData,
+    proxy::{path_from_url, LapceProxy},
+    rename::RenameData,
+    selection_range::SelectionRangeDirection,
+    signature::{SignatureData, SignatureStatus},
+    source_control::SourceControlData,
+    split::{SplitDirection, SplitMoveDirection},
 };
-use serde_json::Value;
-use std::cmp::Ordering;
-use std::path::Path;
-use std::thread;
-use std::{collections::HashMap, sync::Arc};
-use std::{iter::Iterator, path::PathBuf};
-use std::{str::FromStr, time::Duration};
-use xi_rope::{RopeDelta, Transformer};
 
 pub struct LapceUI {}
 
@@ -72,27 +71,164 @@ pub enum EditorOperator {
     Yank(EditorCount),
 }
 
-#[derive(Clone, Debug)]
-pub struct EditorLocation {
+pub trait EditorPosition: Sized {
+    /// Convert the position to a utf8 offset
+    fn to_utf8_offset(&self, buffer: &Buffer) -> usize;
+
+    fn init_buffer_content_cmd(
+        path: PathBuf,
+        content: Rope,
+        locations: Vec<(WidgetId, EditorLocation<Self>)>,
+        edits: Option<Rope>,
+        cb: Option<InitBufferContentCb>,
+    ) -> LapceUICommand;
+}
+
+// Usize is always a utf8 offset
+impl EditorPosition for usize {
+    fn to_utf8_offset(&self, _buffer: &Buffer) -> usize {
+        *self
+    }
+
+    fn init_buffer_content_cmd(
+        path: PathBuf,
+        content: Rope,
+        locations: Vec<(WidgetId, EditorLocation<Self>)>,
+        unsaved_buffers: Option<Rope>,
+        cb: Option<InitBufferContentCb>,
+    ) -> LapceUICommand {
+        LapceUICommand::InitBufferContent(InitBufferContent {
+            path,
+            content,
+            locations,
+            edits: unsaved_buffers,
+            cb,
+        })
+    }
+}
+
+/// Jump to first non blank character on a line
+/// (If you want to jump to the very first character then use [`LineCol`] with column set to 0)
+#[derive(Debug, Clone, Copy)]
+pub struct Line(pub usize);
+
+impl EditorPosition for Line {
+    fn to_utf8_offset(&self, buffer: &Buffer) -> usize {
+        buffer.first_non_blank_character_on_line(self.0.saturating_sub(1))
+    }
+
+    fn init_buffer_content_cmd(
+        path: PathBuf,
+        content: Rope,
+        locations: Vec<(WidgetId, EditorLocation<Self>)>,
+        edits: Option<Rope>,
+        cb: Option<InitBufferContentCb>,
+    ) -> LapceUICommand {
+        LapceUICommand::InitBufferContentLine(InitBufferContent {
+            path,
+            content,
+            locations,
+            edits,
+            cb,
+        })
+    }
+}
+
+/// UTF8 line and column-offset
+#[derive(Debug, Clone, Copy)]
+pub struct LineCol {
+    pub line: usize,
+    pub column: usize,
+}
+
+impl EditorPosition for LineCol {
+    fn to_utf8_offset(&self, buffer: &Buffer) -> usize {
+        buffer.offset_of_line_col(self.line, self.column)
+    }
+
+    fn init_buffer_content_cmd(
+        path: PathBuf,
+        content: Rope,
+        locations: Vec<(WidgetId, EditorLocation<Self>)>,
+        edits: Option<Rope>,
+        cb: Option<InitBufferContentCb>,
+    ) -> LapceUICommand {
+        LapceUICommand::InitBufferContentLineCol(InitBufferContent {
+            path,
+            content,
+            locations,
+            edits,
+            cb,
+        })
+    }
+}
+
+impl EditorPosition for Position {
+    fn to_utf8_offset(&self, buffer: &Buffer) -> usize {
+        buffer.offset_of_position(self)
+    }
+
+    fn init_buffer_content_cmd(
+        path: PathBuf,
+        content: Rope,
+        locations: Vec<(WidgetId, EditorLocation<Self>)>,
+        edits: Option<Rope>,
+        cb: Option<InitBufferContentCb>,
+    ) -> LapceUICommand {
+        LapceUICommand::InitBufferContentLsp(InitBufferContent {
+            path,
+            content,
+            locations,
+            edits,
+            cb,
+        })
+    }
+}
+
+/// Used to specify a location with some path, and potentially position information.  
+/// This is generic so that you can jump to utf8 offsets, line+column offsets, just the line,
+/// or even utf16 offsets (such as those given by the LSP)
+#[derive(Clone, Debug, PartialEq)]
+pub struct EditorLocation<P: EditorPosition = usize> {
     pub path: PathBuf,
-    pub position: Option<Position>,
+    pub position: Option<P>,
     pub scroll_offset: Option<Vec2>,
+    /// Source control history name, ex: "head"
     pub history: Option<String>,
 }
 
+impl<P: EditorPosition> EditorLocation<P> {
+    pub fn into_utf8_location(self, buffer: &Buffer) -> EditorLocation<usize> {
+        EditorLocation {
+            path: self.path,
+            position: self.position.map(|p| p.to_utf8_offset(buffer)),
+            scroll_offset: self.scroll_offset,
+            history: self.history,
+        }
+    }
+}
+
+/// Temporary structure used to manipulate editors/buffers, before returning the data back to
+/// [`LapceTabData`]. See [`LapceTabData::editor_view_content`] for more information on acquiring
+/// the data and on returning it back.
 pub struct LapceEditorBufferData {
     pub view_id: WidgetId,
     pub editor: Arc<LapceEditorData>,
     pub doc: Arc<Document>,
+    // There are a variety of indirectly related data due to it being needed for the various utility
+    // functions on the editor itself.
     pub completion: Arc<CompletionData>,
+    pub signature: Arc<SignatureData>,
     pub hover: Arc<HoverData>,
+    pub rename: Arc<RenameData>,
     pub main_split: LapceMainSplitData,
+    pub focus_area: FocusArea,
     pub source_control: Arc<SourceControlData>,
     pub palette: Arc<PaletteData>,
     pub find: Arc<Find>,
     pub proxy: Arc<LapceProxy>,
     pub command_keymaps: Arc<IndexMap<String, Vec<KeyMap>>>,
-    pub config: Arc<Config>,
+    pub config: Arc<LapceConfig>,
 }
 
 impl LapceEditorBufferData {
@@ -111,6 +247,7 @@ impl LapceEditorBufferData {
         }
     }
 
+    /// Jump to the next/previous column on the line which matches the given text
     fn inline_find(
         &mut self,
         ctx: &mut EventCtx,
@@ -150,48 +287,87 @@ impl LapceEditorBufferData {
         }
     }
 
-    pub fn get_code_actions(&self, ctx: &mut EventCtx) {
+    pub fn get_code_actions(&mut self, ctx: &mut EventCtx) {
         if !self.doc.loaded() {
             return;
         }
-        if !self.doc.content().is_file() {
-            return;
-        }
+
         if let BufferContent::File(path) = self.doc.content() {
             let path = path.clone();
             let offset = self.editor.cursor.offset();
-            let prev_offset = self.doc.buffer().prev_code_boundary(offset);
-            if self.doc.code_actions.get(&prev_offset).is_none() {
-                let buffer_id = self.doc.id();
-                let position = self.doc.buffer().offset_to_position(prev_offset);
+
+            let exists = if self.doc.code_actions.contains_key(&offset) {
+                true
+            } else {
+                Arc::make_mut(&mut self.doc)
+                    .code_actions
+                    .insert(offset, (PluginId(0), Vec::new()));
+                false
+            };
+            if !exists {
+                let position = self.doc.buffer().offset_to_position(offset);
                 let rev = self.doc.rev();
                 let event_sink = ctx.get_external_handle();
-                self.proxy.get_code_actions(
-                    buffer_id,
+
+                // Get the diagnostics for the current line, which the LSP might use to inform
+                // what code actions are available (such as fixes for the diagnostics).
+                let diagnostics: &[EditorDiagnostic] = self
+                    .doc
+                    .diagnostics
+                    .as_deref()
+                    .map(Vec::as_slice)
+                    .unwrap_or(&[]);
+                let diagnostics = diagnostics
+                    .iter()
+                    .map(|x| &x.diagnostic)
+                    .filter(|x| {
+                        x.range.start.line <= position.line
+                            && x.range.end.line >= position.line
+                    })
+                    .cloned()
+                    .collect();
+
+                self.proxy.proxy_rpc.get_code_actions(
+                    path.clone(),
                     position,
-                    Box::new(move |result| {
-                        if let Ok(res) = result {
-                            if let Ok(resp) =
-                                serde_json::from_value::<CodeActionResponse>(res)
-                            {
-                                let _ = event_sink.submit_command(
-                                    LAPCE_UI_COMMAND,
-                                    LapceUICommand::UpdateCodeActions(
-                                        path,
-                                        rev,
-                                        prev_offset,
-                                        resp,
-                                    ),
-                                    Target::Auto,
-                                );
-                            }
+                    diagnostics,
+                    move |result| {
+                        if let Ok(ProxyResponse::GetCodeActionsResponse {
+                            plugin_id,
+                            resp,
+                        }) = result
+                        {
+                            let _ = event_sink.submit_command(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::UpdateCodeActions {
+                                    path,
+                                    plugin_id,
+                                    rev,
+                                    offset,
+                                    resp,
+                                },
+                                Target::Auto,
+                            );
+                        } else {
+                            let _ = event_sink.submit_command(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::CodeActionsError {
+                                    path,
+                                    rev,
+                                    offset,
+                                },
+                                Target::Auto,
+                            );
                         }
-                    }),
+                    },
                 );
             }
         }
     }
 
+    /// Update the positions of cursors in other editors which are editing the same document  
+    /// Ex: You type at the start of the document, the cursor in the other editor (like a split)
+    /// should be moved forward.
     fn inactive_apply_delta(&mut self, delta: &RopeDelta) {
         for (view_id, editor) in self.main_split.editors.iter_mut() {
             if view_id != &self.editor.view_id
@@ -206,97 +382,188 @@ impl LapceEditorBufferData {
         self.editor.content == BufferContent::Local(LocalBufferKind::Palette)
     }
 
+    fn is_rename(&self) -> bool {
+        self.editor.content == BufferContent::Local(LocalBufferKind::Rename)
+    }
+
     /// Check if there are completions that are being rendered
     fn has_completions(&self) -> bool {
         self.completion.status != CompletionStatus::Inactive
             && self.completion.len() > 0
     }
 
+    /// Check if there are signatures that are being rendered
+    fn has_signature(&self) -> bool {
+        self.signature.status != SignatureStatus::Inactive
+            && !self.signature.is_empty()
+    }
+
     fn has_hover(&self) -> bool {
         self.hover.status != HoverStatus::Inactive && !self.hover.is_empty()
     }
 
-    pub fn run_code_action(&mut self, action: &CodeActionOrCommand) {
+    fn has_rename(&self) -> bool {
+        self.rename.active
+    }
+
+    /// Perform a workspace edit, which are from the LSP (such as code actions, or symbol renaming)
+    pub fn apply_workspace_edit(
+        &mut self,
+        ctx: &mut EventCtx,
+        edit: &WorkspaceEdit,
+    ) {
+        // TODO: I think this probably has some issues if an operation created a file, and then the
+        // workspace-edits after this are told to edit the created file. I think it would behave
+        // correctly for a *new* file, but not if the created file overwrote an existing file we had
+        // open.
+
+        // If there's any operations, (such as creating files, renaming them, or deleting them),
+        // then apply those.
+        if let Some(DocumentChanges::Operations(op)) = edit.document_changes.as_ref()
+        {
+            op.iter()
+                .flat_map(|op| match op {
+                    DocumentChangeOperation::Op(op) => Some(op),
+                    _ => None,
+                })
+                .flat_map(workspace_operation)
+                .map(|cmd| Command::new(LAPCE_UI_COMMAND, cmd, Target::Auto))
+                .for_each(|cmd| ctx.submit_command(cmd));
+        }
+
         if let BufferContent::File(path) = &self.editor.content {
-            match action {
-                CodeActionOrCommand::Command(_cmd) => {}
-                CodeActionOrCommand::CodeAction(action) => {
-                    if let Some(edit) = action.edit.as_ref() {
-                        if let Some(edits) = workspace_edits(edit) {
-                            for (url, edits) in edits {
-                                // TODO: Neither of these methods work for paths
-                                // on different filesystems (i.e. windows and linux),
-                                // as pathbuf is meant to represent a path on the host
-                                let mut matches = false;
-                                // This handles windows drive letters, which rust-url doesn't do.
-                                if let Ok(url_path) = url.to_file_path() {
-                                    matches |= &url_path == path;
-                                }
-                                // This is the previous check, to ensure this isn't a regression
-                                if let Ok(path_url) = Url::from_file_path(path) {
-                                    matches |= path_url == url;
-                                }
-                                if matches {
-                                    let path = path.clone();
-                                    let doc = self
-                                        .main_split
-                                        .open_docs
-                                        .get_mut(&path)
-                                        .unwrap();
-                                    let edits: Vec<(
-                                        lapce_core::selection::Selection,
-                                        &str,
-                                    )> = edits
-                                        .iter()
-                                        .map(|edit| {
-                                            let selection =
-                                            lapce_core::selection::Selection::region(
-                                                doc.buffer().offset_of_position(
-                                                    &edit.range.start,
-                                                ),
-                                                doc.buffer().offset_of_position(
-                                                    &edit.range.end,
-                                                ),
-                                            );
-                                            (selection, edit.new_text.as_str())
-                                        })
-                                        .collect();
-                                    self.main_split.edit(
-                                        &path,
-                                        &edits,
-                                        lapce_core::editor::EditType::Other,
-                                    );
-                                }
-                            }
-                        }
+            if let Some(edits) = workspace_edits(edit) {
+                for (url, edits) in edits {
+                    if url_matches_path(path, &url) {
+                        apply_edit(&mut self.main_split, path, &edits);
+                    } else if let Ok(url_path) = url.to_file_path() {
+                        // If it is not for the file we have open then we assume that
+                        // we may have to load it
+                        // So we jump to the location that the edits were at.
+                        // TODO: url_matches_path checks if the url path 'goes back' to the original url
+                        // Should we do that here?
+
+                        // We choose to just jump to the start of the first edit. The edit function will jump
+                        // appropriately when we actually apply the edits.
+                        let position = edits.get(0).map(|edit| edit.range.start);
+                        let location = EditorLocation {
+                            path: url_path.clone(),
+                            position,
+                            scroll_offset: None,
+                            history: None,
+                        };
+
+                        // Note: For some reason Rust is unsure about what type the arguments are if we don't specify them
+                        // Perhaps this could be fixed by being very explicit about the lifetimes in the jump_to_location_cb fn?
+                        let callback = move |_: &mut EventCtx, main_split: &mut LapceMainSplitData| {
+                            // The file has been loaded, so we want to apply the edits now.
+                            apply_edit(main_split, &url_path, &edits);
+                        };
+                        self.main_split.jump_to_location_cb(
+                            ctx,
+                            None,
+                            false,
+                            location,
+                            &self.config,
+                            Some(callback),
+                        );
+                    } else {
+                        log::warn!("Text edits failed to apply to URL {url:?} because it was not found");
                     }
                 }
             }
         }
     }
 
-    pub fn apply_completion_item(&mut self, item: &CompletionItem) -> Result<()> {
-        let additional_edit: Option<Vec<_>> =
-            item.additional_text_edits.as_ref().map(|edits| {
-                edits
-                    .iter()
-                    .map(|edit| {
-                        let selection = lapce_core::selection::Selection::region(
-                            self.doc.buffer().offset_of_position(&edit.range.start),
-                            self.doc.buffer().offset_of_position(&edit.range.end),
+    pub fn run_code_action(
+        &mut self,
+        ctx: &mut EventCtx,
+        action: &CodeActionOrCommand,
+        plugin_id: &PluginId,
+    ) {
+        match action {
+            CodeActionOrCommand::Command(_cmd) => {}
+            CodeActionOrCommand::CodeAction(action) => {
+                // If the action contains a workspace edit we can apply it right away
+                // otherwise we need to use 'codeAction/resolve'
+                // (see: https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_codeAction)
+                if let Some(edit) = action.edit.as_ref() {
+                    self.apply_workspace_edit(ctx, edit);
+                } else {
+                    self.resolve_code_action(ctx, action, plugin_id)
+                }
+            }
+        }
+    }
+
+    /// Resolve a code action and apply its held workspace edit
+    fn resolve_code_action(
+        &mut self,
+        ctx: &mut EventCtx,
+        action: &CodeAction,
+        plugin_id: &PluginId,
+    ) {
+        let event_sink = ctx.get_external_handle();
+        let view_id = self.view_id;
+        self.proxy.proxy_rpc.code_action_resolve(
+            action.clone(),
+            *plugin_id,
+            move |result| {
+                if let Ok(ProxyResponse::CodeActionResolveResponse { item }) = result
+                {
+                    if let Some(edit) = item.edit {
+                        let _ = event_sink.submit_command(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::ApplyWorkspaceEdit(edit),
+                            Target::Widget(view_id),
                         );
-                        (selection, edit.new_text.as_str())
-                    })
-                    .collect::<Vec<(lapce_core::selection::Selection, &str)>>()
-            });
-        let additional_edit: Option<Vec<_>> =
-            additional_edit.as_ref().map(|edits| {
-                edits.iter().map(|(selection, c)| (selection, *c)).collect()
-            });
+                    }
+                }
+            },
+        )
+    }
+
+    fn completion_do_edit(
+        &mut self,
+        selection: &Selection,
+        edits: &[(impl AsRef<Selection>, &str)],
+    ) {
+        let old_cursor = self.editor.cursor.mode.clone();
+        let doc = Arc::make_mut(&mut self.doc);
+        let (delta, inval_lines, edits) =
+            doc.do_raw_edit(edits, EditType::Completion);
+        let selection = selection.apply_delta(&delta, true, InsertDrift::Default);
+        Arc::make_mut(&mut self.editor)
+            .cursor
+            .update_selection(self.doc.buffer(), selection);
+
+        let doc = Arc::make_mut(&mut self.doc);
+        doc.buffer_mut().set_cursor_before(old_cursor);
+        doc.buffer_mut()
+            .set_cursor_after(self.editor.cursor.mode.clone());
+
+        self.apply_deltas(&[(delta, inval_lines, edits)]);
+    }
+
+    pub fn apply_completion_item(&mut self, item: &CompletionItem) -> Result<()> {
+        // Get all the edits which would be applied in places other than right where the cursor is
+        let additional_edit: Vec<_> = item
+            .additional_text_edits
+            .as_ref()
+            .into_iter()
+            .flatten()
+            .map(|edit| {
+                let selection = lapce_core::selection::Selection::region(
+                    self.doc.buffer().offset_of_position(&edit.range.start),
+                    self.doc.buffer().offset_of_position(&edit.range.end),
+                );
+                (selection, edit.new_text.as_str())
+            })
+            .collect::<Vec<(lapce_core::selection::Selection, &str)>>();
 
         let text_format = item
             .insert_text_format
-            .unwrap_or(lsp_types::InsertTextFormat::PlainText);
+            .unwrap_or(lsp_types::InsertTextFormat::PLAIN_TEXT);
         if let Some(edit) = &item.text_edit {
             match edit {
                 CompletionTextEdit::Edit(edit) => {
@@ -307,60 +574,68 @@ impl LapceEditorBufferData {
                         self.doc.buffer().offset_of_position(&edit.range.start);
                     let edit_end =
                         self.doc.buffer().offset_of_position(&edit.range.end);
+
                     let selection = lapce_core::selection::Selection::region(
                         start_offset.min(edit_start),
                         end_offset.max(edit_end),
                     );
                     match text_format {
-                        lsp_types::InsertTextFormat::PlainText => {
-                            let (delta, inval_lines) = Arc::make_mut(&mut self.doc)
-                                .do_raw_edit(
-                                    &[
-                                        &[(&selection, edit.new_text.as_str())][..],
-                                        &additional_edit.unwrap_or_default()[..],
-                                    ]
-                                    .concat(),
-                                    lapce_core::editor::EditType::InsertChars,
-                                );
-                            let selection = selection.apply_delta(
-                                &delta,
-                                true,
-                                lapce_core::selection::InsertDrift::Default,
+                        lsp_types::InsertTextFormat::PLAIN_TEXT => {
+                            self.completion_do_edit(
+                                &selection,
+                                &[
+                                    &[(selection.clone(), edit.new_text.as_str())][..],
+                                    &additional_edit[..],
+                                ]
+                                .concat(),
                             );
-                            Arc::make_mut(&mut self.editor)
-                                .cursor
-                                .update_selection(self.doc.buffer(), selection);
-                            self.apply_deltas(&[(delta, inval_lines)]);
                             return Ok(());
                         }
-                        lsp_types::InsertTextFormat::Snippet => {
+                        lsp_types::InsertTextFormat::SNIPPET => {
                             let snippet = Snippet::from_str(&edit.new_text)?;
                             let text = snippet.text();
-                            let (delta, inval_lines) = Arc::make_mut(&mut self.doc)
-                                .do_raw_edit(
+                            let old_cursor = self.editor.cursor.mode.clone();
+                            let (delta, inval_lines, edits) =
+                                Arc::make_mut(&mut self.doc).do_raw_edit(
                                     &[
-                                        &[(&selection, text.as_str())][..],
-                                        &additional_edit.unwrap_or_default()[..],
+                                        &[(selection.clone(), text.as_str())][..],
+                                        &additional_edit[..],
                                     ]
                                     .concat(),
-                                    lapce_core::editor::EditType::InsertChars,
+                                    EditType::Completion,
                                 );
+
                             let selection = selection.apply_delta(
                                 &delta,
                                 true,
-                                lapce_core::selection::InsertDrift::Default,
+                                InsertDrift::Default,
                             );
 
+                            let start_offset = additional_edit
+                                .iter()
+                                .map(|(selection, _)| selection.min_offset())
+                                .min()
+                                .map(|offset| {
+                                    offset.min(start_offset).min(edit_start)
+                                })
+                                .unwrap_or(start_offset);
+
                             let mut transformer = Transformer::new(&delta);
-                            let offset = transformer
-                                .transform(start_offset.min(edit_start), false);
+                            let offset = transformer.transform(start_offset, false);
                             let snippet_tabs = snippet.tabs(offset);
 
                             if snippet_tabs.is_empty() {
                                 Arc::make_mut(&mut self.editor)
                                     .cursor
                                     .update_selection(self.doc.buffer(), selection);
-                                self.apply_deltas(&[(delta, inval_lines)]);
+
+                                let doc = Arc::make_mut(&mut self.doc);
+                                doc.buffer_mut().set_cursor_before(old_cursor);
+                                doc.buffer_mut().set_cursor_after(
+                                    self.editor.cursor.mode.clone(),
+                                );
+
+                                self.apply_deltas(&[(delta, inval_lines, edits)]);
                                 return Ok(());
                             }
 
@@ -374,11 +649,18 @@ impl LapceEditorBufferData {
                             Arc::make_mut(&mut self.editor)
                                 .cursor
                                 .set_insert(selection);
-                            self.apply_deltas(&[(delta, inval_lines)]);
+
+                            let doc = Arc::make_mut(&mut self.doc);
+                            doc.buffer_mut().set_cursor_before(old_cursor);
+                            doc.buffer_mut()
+                                .set_cursor_after(self.editor.cursor.mode.clone());
+
+                            self.apply_deltas(&[(delta, inval_lines, edits)]);
                             Arc::make_mut(&mut self.editor)
                                 .add_snippet_placeholders(snippet_tabs);
                             return Ok(());
                         }
+                        _ => {}
                     }
                 }
                 CompletionTextEdit::InsertAndReplace(_) => (),
@@ -388,47 +670,115 @@ impl LapceEditorBufferData {
         let offset = self.editor.cursor.offset();
         let start_offset = self.doc.buffer().prev_code_boundary(offset);
         let end_offset = self.doc.buffer().next_code_boundary(offset);
-        let selection =
-            lapce_core::selection::Selection::region(start_offset, end_offset);
+        let selection = Selection::region(start_offset, end_offset);
 
-        let (delta, inval_lines) = Arc::make_mut(&mut self.doc).do_raw_edit(
+        self.completion_do_edit(
+            &selection,
             &[
                 &[(
-                    &selection,
+                    selection.clone(),
                     item.insert_text.as_deref().unwrap_or(item.label.as_str()),
                 )][..],
-                &additional_edit.unwrap_or_default()[..],
+                &additional_edit[..],
             ]
             .concat(),
-            lapce_core::editor::EditType::InsertChars,
-        );
-        let selection = selection.apply_delta(
-            &delta,
-            true,
-            lapce_core::selection::InsertDrift::Default,
         );
-        Arc::make_mut(&mut self.editor)
-            .cursor
-            .update_selection(self.doc.buffer(), selection);
-        self.apply_deltas(&[(delta, inval_lines)]);
         Ok(())
     }
 
     pub fn cancel_completion(&mut self) {
+        if self.completion.status == CompletionStatus::Inactive {
+            return;
+        }
         let completion = Arc::make_mut(&mut self.completion);
         completion.cancel();
     }
 
+    pub fn cancel_signature(&mut self) {
+        if self.signature.status == SignatureStatus::Inactive {
+            return;
+        }
+        let signature = Arc::make_mut(&mut self.signature);
+        signature.cancel();
+    }
+
     pub fn cancel_hover(&mut self) {
         let hover = Arc::make_mut(&mut self.hover);
         hover.cancel();
     }
 
+    pub fn cancel_rename(&mut self, ctx: &mut EventCtx) {
+        let rename = Arc::make_mut(&mut self.rename);
+        rename.cancel();
+        if self.focus_area == FocusArea::Rename {
+            if let Some(active) = *self.main_split.active_tab {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::Focus,
+                    Target::Widget(active),
+                ));
+            } else {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::Focus,
+                    Target::Widget(*self.main_split.split_id),
+                ));
+            }
+        }
+    }
+
+    /// Select the current completion item, getting the data (potentially needing an LSP request)
+    /// and then apply it.
+    pub fn completion_item_select(&mut self, ctx: &mut EventCtx) {
+        let item = if let Some(item) = self.completion.current_item() {
+            item.to_owned()
+        } else {
+            // There was no selected item, this may be due to a bug in failing to ensure that the index was valid.
+            return;
+        };
+
+        self.cancel_completion();
+        if item.item.data.is_some() {
+            let view_id = self.editor.view_id;
+            let buffer_id = self.doc.id();
+            let rev = self.doc.rev();
+            let offset = self.editor.cursor.offset();
+            let event_sink = ctx.get_external_handle();
+            self.proxy.proxy_rpc.completion_resolve(
+                item.plugin_id,
+                item.item.clone(),
+                move |result| {
+                    let item =
+                        if let Ok(ProxyResponse::CompletionResolveResponse {
+                            item,
+                        }) = result
+                        {
+                            *item
+                        } else {
+                            item.item.clone()
+                        };
+                    let _ = event_sink.submit_command(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::ResolveCompletion {
+                            id: buffer_id,
+                            rev,
+                            offset,
+                            item: Box::new(item),
+                        },
+                        Target::Widget(view_id),
+                    );
+                },
+            );
+        } else {
+            let _ = self.apply_completion_item(&item.item);
+        }
+    }
+
     /// Update the displayed autocompletion box
     /// Sends a request to the LSP for completion information
     fn update_completion(
         &mut self,
-        ctx: &mut EventCtx,
+        _ctx: &mut EventCtx,
         display_if_empty_input: bool,
     ) {
         if self.get_mode() != Mode::Insert {
@@ -471,28 +821,22 @@ impl LapceEditorBufferData {
             completion.update_input(input.clone());
 
             if !completion.input_items.contains_key("") {
-                let event_sink = ctx.get_external_handle();
+                let start_pos = self.doc.buffer().offset_to_position(start_offset);
                 completion.request(
                     self.proxy.clone(),
-                    completion.request_id,
-                    self.doc.id(),
+                    self.doc.content().path().unwrap().into(),
                     "".to_string(),
-                    self.doc.buffer().offset_to_position(start_offset),
-                    completion.id,
-                    event_sink,
+                    start_pos,
                 );
             }
 
             if !completion.input_items.contains_key(&input) {
-                let event_sink = ctx.get_external_handle();
+                let position = self.doc.buffer().offset_to_position(offset);
                 completion.request(
                     self.proxy.clone(),
-                    completion.request_id,
-                    self.doc.id(),
+                    self.doc.content().path().unwrap().into(),
                     input,
-                    self.doc.buffer().offset_to_position(offset),
-                    completion.id,
-                    event_sink,
+                    position,
                 );
             }
 
@@ -505,29 +849,64 @@ impl LapceEditorBufferData {
         completion.status = CompletionStatus::Started;
         completion.input_items.clear();
         completion.request_id += 1;
-        let event_sink = ctx.get_external_handle();
+        let start_pos = self.doc.buffer().offset_to_position(start_offset);
         completion.request(
             self.proxy.clone(),
-            completion.request_id,
-            self.doc.id(),
+            self.doc.content().path().unwrap().into(),
             "".to_string(),
-            self.doc.buffer().offset_to_position(start_offset),
-            completion.id,
-            event_sink.clone(),
+            start_pos,
         );
+
         if !input.is_empty() {
+            let position = self.doc.buffer().offset_to_position(offset);
             completion.request(
                 self.proxy.clone(),
-                completion.request_id,
-                self.doc.id(),
+                self.doc.content().path().unwrap().into(),
                 input,
-                self.doc.buffer().offset_to_position(offset),
-                completion.id,
-                event_sink,
+                position,
             );
         }
     }
 
+    fn update_signature(&mut self) {
+        if self.get_mode() != Mode::Insert {
+            self.cancel_signature();
+            return;
+        }
+        if !self.doc.loaded() || !self.doc.content().is_file() {
+            return;
+        }
+
+        let offset = self.editor.cursor.offset();
+
+        let start_offset = match self
+            .doc
+            .syntax()
+            .and_then(|syntax| syntax.find_enclosing_parentheses(offset))
+        {
+            Some((start, _)) => start,
+            None => {
+                self.cancel_signature();
+                return;
+            }
+        };
+
+        let signature = Arc::make_mut(&mut self.signature);
+
+        signature.buffer_id = self.doc.id();
+        signature.offset = start_offset;
+        signature.status = SignatureStatus::Started;
+        signature.request_id += 1;
+
+        let pos = self.doc.buffer().offset_to_position(offset);
+        signature.request(
+            self.proxy.clone(),
+            signature.request_id,
+            self.doc.content().path().unwrap().into(),
+            pos,
+        );
+    }
+
     /// return true if there's existing hover and it's not changed
     pub fn check_hover(
         &mut self,
@@ -536,19 +915,21 @@ impl LapceEditorBufferData {
         is_inside: bool,
         within_scroll: bool,
     ) -> bool {
-        let hover = Arc::make_mut(&mut self.hover);
-
-        if hover.status != HoverStatus::Inactive {
+        if self.hover.status != HoverStatus::Inactive {
             if !is_inside || !within_scroll {
+                let hover = Arc::make_mut(&mut self.hover);
                 hover.cancel();
                 return false;
             }
 
             let start_offset = self.doc.buffer().prev_code_boundary(offset);
-            if self.doc.id() == hover.buffer_id && start_offset == hover.offset {
+            if self.doc.id() == self.hover.buffer_id
+                && start_offset == self.hover.offset
+            {
                 return true;
             }
 
+            let hover = Arc::make_mut(&mut self.hover);
             hover.cancel();
             return false;
         }
@@ -593,34 +974,19 @@ impl LapceEditorBufferData {
         hover.request_id += 1;
 
         let event_sink = ctx.get_external_handle();
+        let start_pos = self.doc.buffer().offset_to_position(start_offset);
         hover.request(
             self.proxy.clone(),
             hover.request_id,
             self.doc.clone(),
             diagnostics,
-            self.doc.buffer().offset_to_position(start_offset),
+            start_pos,
             hover.id,
             event_sink,
             self.config.clone(),
         );
     }
 
-    fn initiate_diagnostics_offset(&mut self) {
-        let doc = self.doc.clone();
-        if let Some(diagnostics) = self.diagnostics_mut() {
-            for diagnostic in diagnostics.iter_mut() {
-                if diagnostic.range.is_none() {
-                    diagnostic.range = Some((
-                        doc.buffer()
-                            .offset_of_position(&diagnostic.diagnostic.range.start),
-                        doc.buffer()
-                            .offset_of_position(&diagnostic.diagnostic.range.end),
-                    ));
-                }
-            }
-        }
-    }
-
     fn update_snippet_offset(&mut self, delta: &RopeDelta) {
         if let Some(snippet) = &self.editor.snippet {
             let mut transformer = Transformer::new(delta);
@@ -640,27 +1006,79 @@ impl LapceEditorBufferData {
             );
         }
     }
-
-    fn update_diagnostics_offset(&mut self, delta: &RopeDelta) {
-        let doc = self.doc.clone();
-        if let Some(diagnostics) = self.diagnostics_mut() {
-            for diagnostic in diagnostics.iter_mut() {
-                let mut transformer = Transformer::new(delta);
-                let (start, end) = diagnostic.range.unwrap();
-                let (new_start, new_end) = (
-                    transformer.transform(start, false),
-                    transformer.transform(end, true),
-                );
-                diagnostic.range = Some((new_start, new_end));
-                if start != new_start {
-                    diagnostic.diagnostic.range.start =
-                        doc.buffer().offset_to_position(new_start);
+    fn diff_file_positions(&self) -> Vec<(PathBuf, Vec<usize>)> {
+        let buffer = self.doc.buffer();
+        let mut diff_files: Vec<(PathBuf, Vec<usize>)> = self
+            .source_control
+            .file_diffs
+            .iter()
+            .map(|(path, _)| {
+                let mut positions = Vec::new();
+                if let Some(doc) = self.main_split.open_docs.get(path) {
+                    if let Some(history) = doc.get_history("head") {
+                        for (i, change) in history.changes().iter().enumerate() {
+                            match change {
+                                DiffLines::Left(_) => {
+                                    if let Some(next) = history.changes().get(i + 1)
+                                    {
+                                        match next {
+                                            DiffLines::Right(_) => {}
+                                            DiffLines::Left(_) => {}
+                                            DiffLines::Both(_, r) => {
+                                                let start =
+                                                    buffer.offset_of_line(r.start);
+                                                positions.push(start);
+                                            }
+                                            DiffLines::Skip(_, r) => {
+                                                let start =
+                                                    buffer.offset_of_line(r.start);
+                                                positions.push(start);
+                                            }
+                                        }
+                                    }
+                                }
+                                DiffLines::Both(_, _) => {}
+                                DiffLines::Skip(_, _) => {}
+                                DiffLines::Right(r) => {
+                                    let start = buffer.offset_of_line(r.start);
+                                    positions.push(start);
+                                }
+                            }
+                        }
+                    }
                 }
-                if end != new_end {
-                    diagnostic.diagnostic.range.end =
-                        doc.buffer().offset_to_position(new_end);
+                if positions.is_empty() {
+                    positions.push(0);
                 }
+                (path.clone(), positions)
+            })
+            .collect();
+        diff_files.sort();
+        diff_files
+    }
+
+    fn prev_diff(&mut self, ctx: &mut EventCtx) {
+        if let BufferContent::File(buffer_path) = self.doc.content() {
+            if self.source_control.file_diffs.is_empty() {
+                return;
             }
+
+            let diff_files: Vec<(PathBuf, Vec<usize>)> = self.diff_file_positions();
+
+            let offset = self.editor.cursor.offset();
+            let (path, offset) =
+                prev_in_file_diff_offset(offset, buffer_path, &diff_files);
+            let location = EditorLocation {
+                path: path.to_path_buf(),
+                position: Some(offset),
+                scroll_offset: None,
+                history: Some("head".to_string()),
+            };
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::JumpToLocation(None, location, true),
+                Target::Widget(*self.main_split.tab_id),
+            ));
         }
     }
 
@@ -669,75 +1087,21 @@ impl LapceEditorBufferData {
             if self.source_control.file_diffs.is_empty() {
                 return;
             }
-            let mut diff_files: Vec<(PathBuf, Vec<Position>)> = self
-                .source_control
-                .file_diffs
-                .iter()
-                .map(|(diff, _)| {
-                    let path = diff.path();
-                    let mut positions = Vec::new();
-                    if let Some(doc) = self.main_split.open_docs.get(path) {
-                        if let Some(history) = doc.get_history("head") {
-                            for (i, change) in history.changes().iter().enumerate() {
-                                match change {
-                                    DiffLines::Left(_) => {
-                                        if let Some(next) =
-                                            history.changes().get(i + 1)
-                                        {
-                                            match next {
-                                                DiffLines::Right(_) => {}
-                                                DiffLines::Left(_) => {}
-                                                DiffLines::Both(_, r) => {
-                                                    positions.push(Position {
-                                                        line: r.start as u32,
-                                                        character: 0,
-                                                    });
-                                                }
-                                                DiffLines::Skip(_, r) => {
-                                                    positions.push(Position {
-                                                        line: r.start as u32,
-                                                        character: 0,
-                                                    });
-                                                }
-                                            }
-                                        }
-                                    }
-                                    DiffLines::Both(_, _) => {}
-                                    DiffLines::Skip(_, _) => {}
-                                    DiffLines::Right(r) => {
-                                        positions.push(Position {
-                                            line: r.start as u32,
-                                            character: 0,
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    if positions.is_empty() {
-                        positions.push(Position {
-                            line: 0,
-                            character: 0,
-                        });
-                    }
-                    (path.clone(), positions)
-                })
-                .collect();
-            diff_files.sort();
+
+            let diff_files: Vec<(PathBuf, Vec<usize>)> = self.diff_file_positions();
 
             let offset = self.editor.cursor.offset();
-            let position = self.doc.buffer().offset_to_position(offset);
-            let (path, position) =
-                next_in_file_diff_offset(position, buffer_path, &diff_files);
+            let (path, offset) =
+                next_in_file_diff_offset(offset, buffer_path, &diff_files);
             let location = EditorLocation {
-                path,
-                position: Some(position),
+                path: path.to_path_buf(),
+                position: Some(offset),
                 scroll_offset: None,
                 history: Some("head".to_string()),
             };
             ctx.submit_command(Command::new(
                 LAPCE_UI_COMMAND,
-                LapceUICommand::JumpToLocation(None, location),
+                LapceUICommand::JumpToLocation(None, location, true),
                 Target::Widget(*self.main_split.tab_id),
             ));
         }
@@ -745,33 +1109,14 @@ impl LapceEditorBufferData {
 
     fn next_error(&mut self, ctx: &mut EventCtx) {
         if let BufferContent::File(buffer_path) = self.doc.content() {
-            let mut file_diagnostics = self
+            let mut file_diagnostics: Vec<(&PathBuf, Vec<Position>)> = self
                 .main_split
-                .diagnostics
-                .iter()
-                .filter_map(|(path, diagnostics)| {
-                    //let buffer = self.get_buffer_from_path(ctx, ui_state, path);
-                    let mut errors: Vec<Position> = diagnostics
-                        .iter()
-                        .filter_map(|d| {
-                            let severity = d
-                                .diagnostic
-                                .severity
-                                .unwrap_or(DiagnosticSeverity::Hint);
-                            if severity != DiagnosticSeverity::Error {
-                                return None;
-                            }
-                            Some(d.diagnostic.range.start)
-                        })
-                        .collect();
-                    if errors.is_empty() {
-                        None
-                    } else {
-                        errors.sort();
-                        Some((path, errors))
-                    }
+                .diagnostics_items(DiagnosticSeverity::ERROR)
+                .into_iter()
+                .map(|(p, d)| {
+                    (p, d.iter().map(|d| d.diagnostic.range.start).collect())
                 })
-                .collect::<Vec<(&PathBuf, Vec<Position>)>>();
+                .collect();
             if file_diagnostics.is_empty() {
                 return;
             }
@@ -789,52 +1134,65 @@ impl LapceEditorBufferData {
             };
             ctx.submit_command(Command::new(
                 LAPCE_UI_COMMAND,
-                LapceUICommand::JumpToLocation(None, location),
+                LapceUICommand::JumpToLspLocation(None, location, true),
                 Target::Auto,
             ));
         }
     }
 
     fn jump_location_forward(&mut self, ctx: &mut EventCtx) -> Option<()> {
-        if self.editor.locations.is_empty() {
+        if self.main_split.locations.is_empty() {
             return None;
         }
-        if self.editor.current_location >= self.editor.locations.len() - 1 {
+        if self.main_split.current_location >= self.main_split.locations.len() - 1 {
             return None;
         }
-        let editor = Arc::make_mut(&mut self.editor);
-        editor.current_location += 1;
-        let location = editor.locations[editor.current_location].clone();
+        self.main_split.current_location += 1;
+        let location =
+            self.main_split.locations[self.main_split.current_location].clone();
         ctx.submit_command(Command::new(
             LAPCE_UI_COMMAND,
-            LapceUICommand::GoToLocationNew(editor.view_id, location),
+            LapceUICommand::GoToLocation(
+                None,
+                location,
+                !self.config.editor.show_tab,
+            ),
             Target::Auto,
         ));
         None
     }
 
     fn jump_location_backward(&mut self, ctx: &mut EventCtx) -> Option<()> {
-        if self.editor.current_location < 1 {
+        if self.main_split.current_location < 1 {
             return None;
         }
-        if self.editor.current_location >= self.editor.locations.len() {
-            let editor = Arc::make_mut(&mut self.editor);
-            editor.save_jump_location(&self.doc);
-            editor.current_location -= 1;
+        if self.main_split.current_location >= self.main_split.locations.len() {
+            if let BufferContent::File(path) = &self.editor.content {
+                self.main_split.save_jump_location(
+                    path.to_path_buf(),
+                    self.editor.cursor.offset(),
+                    self.editor.scroll_offset,
+                );
+            }
+            self.main_split.current_location -= 1;
         }
-        let editor = Arc::make_mut(&mut self.editor);
-        editor.current_location -= 1;
-        let location = editor.locations[editor.current_location].clone();
+        self.main_split.current_location -= 1;
+        let location =
+            self.main_split.locations[self.main_split.current_location].clone();
         ctx.submit_command(Command::new(
             LAPCE_UI_COMMAND,
-            LapceUICommand::GoToLocationNew(editor.view_id, location),
+            LapceUICommand::GoToLocation(
+                None,
+                location,
+                !self.config.editor.show_tab,
+            ),
             Target::Auto,
         ));
         None
     }
 
     fn page_move(&mut self, ctx: &mut EventCtx, down: bool, mods: Modifiers) {
-        let line_height = self.config.editor.line_height as f64;
+        let line_height = self.config.editor.line_height() as f64;
         let lines =
             (self.editor.size.borrow().height / line_height / 2.0).round() as usize;
         let distance = (lines as f64) * line_height;
@@ -868,7 +1226,7 @@ impl LapceEditorBufferData {
         count: usize,
         mods: Modifiers,
     ) {
-        let line_height = self.config.editor.line_height as f64;
+        let line_height = self.config.editor.line_height() as f64;
         let diff = line_height * count as f64;
         let diff = if down { diff } else { -diff };
 
@@ -918,41 +1276,29 @@ impl LapceEditorBufferData {
         ));
     }
 
-    pub fn current_code_actions(&self) -> Option<&CodeActionResponse> {
+    pub fn current_code_actions(&self) -> Option<&(PluginId, CodeActionResponse)> {
         let offset = self.editor.cursor.offset();
         let prev_offset = self.doc.buffer().prev_code_boundary(offset);
         self.doc.code_actions.get(&prev_offset)
     }
 
     pub fn diagnostics(&self) -> Option<&Arc<Vec<EditorDiagnostic>>> {
-        if let BufferContent::File(path) = self.doc.content() {
-            self.main_split.diagnostics.get(path)
-        } else {
-            None
-        }
-    }
-
-    pub fn diagnostics_mut(&mut self) -> Option<&mut Vec<EditorDiagnostic>> {
-        if let BufferContent::File(path) = self.doc.content() {
-            self.main_split.diagnostics.get_mut(path).map(Arc::make_mut)
-        } else {
-            None
-        }
+        self.doc.diagnostics.as_ref()
     }
 
     pub fn offset_of_mouse(
         &self,
         text: &mut PietText,
         pos: Point,
-        config: &Config,
+        config: &LapceConfig,
     ) -> usize {
-        let (line, char_width) = if self.editor.code_lens {
+        let (line, char_width) = if self.editor.is_code_lens() {
             let (line, font_size) = if let Some(syntax) = self.doc.syntax() {
                 let line = syntax.lens.line_of_height(pos.y.floor() as usize);
                 let line_height = syntax.lens.height_of_line(line + 1)
                     - syntax.lens.height_of_line(line);
 
-                let font_size = if line_height < config.editor.line_height {
+                let font_size = if line_height < config.editor.line_height() {
                     config.editor.code_lens_font_size
                 } else {
                     config.editor.font_size
@@ -967,13 +1313,20 @@ impl LapceEditorBufferData {
                 )
             };
 
-            (line, config.char_width(text, font_size as f64))
+            (
+                line,
+                config.char_width(
+                    text,
+                    font_size as f64,
+                    config.editor.font_family(),
+                ),
+            )
         } else if let Some(compare) = self.editor.compare.as_ref() {
-            let line = (pos.y / config.editor.line_height as f64).floor() as usize;
+            let line = (pos.y / config.editor.line_height() as f64).floor() as usize;
             let line = self.doc.history_actual_line_from_visual(compare, line);
             (line, config.editor_char_width(text))
         } else {
-            let line = (pos.y / config.editor.line_height as f64).floor() as usize;
+            let line = (pos.y / config.editor.line_height() as f64).floor() as usize;
             (line, config.editor_char_width(text))
         };
 
@@ -1001,13 +1354,13 @@ impl LapceEditorBufferData {
         &mut self,
         ctx: &mut EventCtx,
         mouse_event: &MouseEvent,
-        config: &Config,
+        config: &LapceConfig,
     ) {
         let (new_offset, _) = self.doc.offset_of_point(
             ctx.text(),
             self.get_mode(),
             mouse_event.pos,
-            config.editor.font_size,
+            &self.editor.view,
             config,
         );
         let cursor = &mut Arc::make_mut(&mut self.editor).cursor;
@@ -1045,14 +1398,14 @@ impl LapceEditorBufferData {
         &mut self,
         ctx: &mut EventCtx,
         mouse_event: &MouseEvent,
-        config: &Config,
+        config: &LapceConfig,
     ) {
         ctx.set_active(true);
         let (mouse_offset, _) = self.doc.offset_of_point(
             ctx.text(),
             self.get_mode(),
             mouse_event.pos,
-            config.editor.font_size,
+            &self.editor.view,
             config,
         );
         let (start, end) = self.doc.buffer().select_word(mouse_offset);
@@ -1069,14 +1422,14 @@ impl LapceEditorBufferData {
         &mut self,
         ctx: &mut EventCtx,
         mouse_event: &MouseEvent,
-        config: &Config,
+        config: &LapceConfig,
     ) {
         ctx.set_active(true);
         let (mouse_offset, _) = self.doc.offset_of_point(
             ctx.text(),
             self.get_mode(),
             mouse_event.pos,
-            config.editor.font_size,
+            &self.editor.view,
             config,
         );
         let line = self.doc.buffer().line_of_offset(mouse_offset);
@@ -1091,15 +1444,15 @@ impl LapceEditorBufferData {
         );
     }
 
-    fn apply_deltas(&mut self, deltas: &[(RopeDelta, InvalLines)]) {
-        for (delta, _) in deltas {
+    fn apply_deltas(&mut self, deltas: &[(RopeDelta, InvalLines, SyntaxEdit)]) {
+        for (delta, _, _) in deltas {
             self.inactive_apply_delta(delta);
             self.update_snippet_offset(delta);
-            self.update_diagnostics_offset(delta);
         }
+        self.update_signature();
     }
 
-    fn save(&mut self, ctx: &mut EventCtx, exit: bool) {
+    fn save(&mut self, ctx: &mut EventCtx, exit: bool, allow_formatting: bool) {
         if self.doc.buffer().is_pristine() && self.doc.content().is_file() {
             if exit {
                 ctx.submit_command(Command::new(
@@ -1115,38 +1468,61 @@ impl LapceEditorBufferData {
         }
 
         if let BufferContent::File(path) = self.doc.content() {
-            let format_on_save = self.config.editor.format_on_save;
+            let format_on_save =
+                allow_formatting && self.config.editor.format_on_save;
             let path = path.clone();
             let proxy = self.proxy.clone();
-            let buffer_id = self.doc.id();
             let rev = self.doc.rev();
             let event_sink = ctx.get_external_handle();
             let view_id = self.editor.view_id;
-            let (sender, receiver) = bounded(1);
-            thread::spawn(move || {
-                proxy.get_document_formatting(
-                    buffer_id,
-                    Box::new(move |result| {
-                        let _ = sender.send(result);
-                    }),
-                );
-
-                let result =
-                    receiver.recv_timeout(Duration::from_secs(1)).map_or_else(
-                        |e| Err(anyhow!("{}", e)),
-                        |v| v.map_err(|e| anyhow!("{:?}", e)),
+            let tab_id = self.main_split.tab_id.clone();
+            let exit = if exit { Some(view_id) } else { None };
+
+            if format_on_save {
+                let (sender, receiver) = bounded(1);
+                thread::spawn(move || {
+                    proxy.proxy_rpc.get_document_formatting(
+                        path.clone(),
+                        Box::new(move |result| {
+                            let _ = sender.send(result);
+                        }),
                     );
 
-                let exit = if exit { Some(view_id) } else { None };
-                let cmd = if format_on_save {
-                    LapceUICommand::DocumentFormatAndSave(path, rev, result, exit)
-                } else {
-                    LapceUICommand::DocumentSave(path, exit)
-                };
+                    let result =
+                        receiver.recv_timeout(Duration::from_secs(1)).map_or_else(
+                            |e| Err(anyhow!("{}", e)),
+                            |v| {
+                                v.map_err(|e| anyhow!("{:?}", e)).and_then(|r| {
+                                    if let ProxyResponse::GetDocumentFormatting {
+                                        edits,
+                                    } = r
+                                    {
+                                        Ok(edits)
+                                    } else {
+                                        Err(anyhow!("wrong response"))
+                                    }
+                                })
+                            },
+                        );
 
-                let _ =
-                    event_sink.submit_command(LAPCE_UI_COMMAND, cmd, Target::Auto);
-            });
+                    let _ = event_sink.submit_command(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::DocumentFormatAndSave {
+                            path,
+                            rev,
+                            result,
+                            exit,
+                        },
+                        Target::Widget(*tab_id),
+                    );
+                });
+            } else {
+                let _ = event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::DocumentSave { path, exit },
+                    Target::Widget(*tab_id),
+                );
+            }
         } else if let BufferContent::Scratch(..) = self.doc.content() {
             let content = self.doc.content().clone();
             let view_id = self.editor.view_id;
@@ -1166,19 +1542,26 @@ impl LapceEditorBufferData {
         mods: Modifiers,
     ) -> CommandExecuted {
         if movement.is_jump() && movement != &self.editor.last_movement_new {
-            Arc::make_mut(&mut self.editor).save_jump_location(&self.doc);
+            if let BufferContent::File(path) = &self.editor.content {
+                self.main_split.save_jump_location(
+                    path.to_path_buf(),
+                    self.editor.cursor.offset(),
+                    self.editor.scroll_offset,
+                );
+            }
         }
         Arc::make_mut(&mut self.editor).last_movement_new = movement.clone();
 
         let register = Arc::make_mut(&mut self.main_split.register);
         let doc = Arc::make_mut(&mut self.doc);
+        let view = self.editor.view.clone();
         doc.move_cursor(
             ctx.text(),
             &mut Arc::make_mut(&mut self.editor).cursor,
             movement,
             count.unwrap_or(1),
             mods.shift(),
-            self.config.editor.font_size,
+            &view,
             register,
             &self.config,
         );
@@ -1196,6 +1579,7 @@ impl LapceEditorBufferData {
             }
         }
         self.cancel_completion();
+        self.update_signature();
         self.cancel_hover();
         CommandExecuted::Yes
     }
@@ -1205,8 +1589,9 @@ impl LapceEditorBufferData {
         ctx: &mut EventCtx,
         cmd: &EditCommand,
     ) -> CommandExecuted {
-        let modal = self.config.lapce.modal && !self.editor.content.is_input();
+        let modal = self.config.core.modal && !self.editor.content.is_input();
         let doc = Arc::make_mut(&mut self.doc);
+        let doc_before_edit = doc.buffer().text().clone();
         let register = Arc::make_mut(&mut self.main_split.register);
         let cursor = &mut Arc::make_mut(&mut self.editor).cursor;
         let yank_data =
@@ -1224,8 +1609,15 @@ impl LapceEditorBufferData {
             }
         }
 
-        self.update_completion(ctx, false);
+        if show_completion(cmd, &doc_before_edit, &deltas) {
+            self.update_completion(ctx, false);
+        } else {
+            self.cancel_completion();
+        }
         self.apply_deltas(&deltas);
+        if let EditCommand::NormalMode = cmd {
+            Arc::make_mut(&mut self.editor).snippet = None;
+        }
 
         CommandExecuted::Yes
     }
@@ -1253,14 +1645,20 @@ impl LapceEditorBufferData {
                 if self.has_completions() {
                     self.cancel_completion();
                 }
+                if self.has_signature() {
+                    self.cancel_signature();
+                }
                 if self.has_hover() {
                     self.cancel_hover();
                 }
+                if self.is_rename() {
+                    self.cancel_rename(ctx);
+                }
             }
             SplitVertical => {
                 self.main_split.split_editor(
                     ctx,
-                    Arc::make_mut(&mut self.editor),
+                    self.editor.view_id,
                     SplitDirection::Vertical,
                     &self.config,
                 );
@@ -1268,7 +1666,7 @@ impl LapceEditorBufferData {
             SplitHorizontal => {
                 self.main_split.split_editor(
                     ctx,
-                    Arc::make_mut(&mut self.editor),
+                    self.editor.view_id,
                     SplitDirection::Horizontal,
                     &self.config,
                 );
@@ -1331,7 +1729,8 @@ impl LapceEditorBufferData {
                     LapceUICommand::UpdateSearchInput(word.clone()),
                     Target::Widget(*self.main_split.tab_id),
                 ));
-                Arc::make_mut(&mut self.find).set_find(&word, false, false, true);
+
+                Arc::make_mut(&mut self.find).set_find(&word, false, true);
                 let next =
                     self.find
                         .next(self.doc.buffer().text(), offset, false, true);
@@ -1406,12 +1805,24 @@ impl LapceEditorBufferData {
                     }
                 }
             }
+            ToggleCaseSensitive => {
+                let tab_id = *self.main_split.tab_id;
+                let find = Arc::make_mut(&mut self.find);
+                let case_sensitive = find.toggle_case_sensitive();
+                let pattern = find.search_string.clone().unwrap_or_default();
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::UpdateSearch(pattern, Some(case_sensitive)),
+                    Target::Widget(tab_id),
+                ));
+                return CommandExecuted::No;
+            }
             GlobalSearchRefresh => {
                 let tab_id = *self.main_split.tab_id;
-                let pattern = self.doc.buffer().text().to_string();
+                let pattern = self.doc.buffer().to_string();
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::UpdateSearch(pattern),
+                    LapceUICommand::UpdateSearch(pattern, None),
                     Target::Widget(tab_id),
                 ));
             }
@@ -1433,12 +1844,12 @@ impl LapceEditorBufferData {
             }
             SearchInView => {
                 let start_line = ((self.editor.scroll_offset.y
-                    / self.config.editor.line_height as f64)
+                    / self.config.editor.line_height() as f64)
                     .ceil() as usize)
                     .max(self.doc.buffer().last_line());
                 let end_line = ((self.editor.scroll_offset.y
                     + self.editor.size.borrow().height
-                        / self.config.editor.line_height as f64)
+                        / self.config.editor.line_height() as f64)
                     .ceil() as usize)
                     .max(self.doc.buffer().last_line());
                 let end_offset = self.doc.buffer().offset_of_line(end_line + 1);
@@ -1488,41 +1899,14 @@ impl LapceEditorBufferData {
                         Target::Widget(self.palette.widget_id),
                     ));
                 } else {
-                    let item = self.completion.current_item().to_owned();
-                    self.cancel_completion();
-                    if item.data.is_some() {
-                        let view_id = self.editor.view_id;
-                        let buffer_id = self.doc.id();
-                        let rev = self.doc.rev();
-                        let offset = self.editor.cursor.offset();
-                        let event_sink = ctx.get_external_handle();
-                        self.proxy.completion_resolve(
-                            buffer_id,
-                            item.clone(),
-                            Box::new(move |result| {
-                                let mut item = item.clone();
-                                if let Ok(res) = result {
-                                    if let Ok(i) =
-                                        serde_json::from_value::<CompletionItem>(res)
-                                    {
-                                        item = i;
-                                    }
-                                };
-                                let _ = event_sink.submit_command(
-                                    LAPCE_UI_COMMAND,
-                                    LapceUICommand::ResolveCompletion(
-                                        buffer_id,
-                                        rev,
-                                        offset,
-                                        Box::new(item),
-                                    ),
-                                    Target::Widget(view_id),
-                                );
-                            }),
-                        );
-                    } else {
-                        let _ = self.apply_completion_item(&item);
-                    }
+                    let completion = Arc::make_mut(&mut self.completion);
+                    completion.run_focus_command(
+                        &self.editor,
+                        &mut self.doc,
+                        &self.config,
+                        ctx,
+                        cmd,
+                    );
                 }
             }
             ListNext => {
@@ -1537,7 +1921,34 @@ impl LapceEditorBufferData {
                     ));
                 } else {
                     let completion = Arc::make_mut(&mut self.completion);
-                    completion.next();
+                    completion.run_focus_command(
+                        &self.editor,
+                        &mut self.doc,
+                        &self.config,
+                        ctx,
+                        cmd,
+                    );
+                }
+            }
+            ListNextPage => {
+                if self.is_palette() {
+                    ctx.submit_command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Focus(FocusCommand::ListNextPage),
+                            data: None,
+                        },
+                        Target::Widget(self.palette.widget_id),
+                    ));
+                } else {
+                    let completion = Arc::make_mut(&mut self.completion);
+                    completion.run_focus_command(
+                        &self.editor,
+                        &mut self.doc,
+                        &self.config,
+                        ctx,
+                        cmd,
+                    );
                 }
             }
             ListPrevious => {
@@ -1552,7 +1963,34 @@ impl LapceEditorBufferData {
                     ));
                 } else {
                     let completion = Arc::make_mut(&mut self.completion);
-                    completion.previous();
+                    completion.run_focus_command(
+                        &self.editor,
+                        &mut self.doc,
+                        &self.config,
+                        ctx,
+                        cmd,
+                    );
+                }
+            }
+            ListPreviousPage => {
+                if self.is_palette() {
+                    ctx.submit_command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Focus(FocusCommand::ListPreviousPage),
+                            data: None,
+                        },
+                        Target::Widget(self.palette.widget_id),
+                    ));
+                } else {
+                    let completion = Arc::make_mut(&mut self.completion);
+                    completion.run_focus_command(
+                        &self.editor,
+                        &mut self.doc,
+                        &self.config,
+                        ctx,
+                        cmd,
+                    );
                 }
             }
             JumpToNextSnippetPlaceholder => {
@@ -1580,6 +2018,7 @@ impl LapceEditorBufferData {
                     if last_placeholder {
                         Arc::make_mut(&mut self.editor).snippet = None;
                     }
+                    self.update_signature();
                     self.cancel_completion();
                 }
             }
@@ -1606,6 +2045,7 @@ impl LapceEditorBufferData {
                                 .cursor
                                 .set_insert(selection);
                         }
+                        self.update_signature();
                         self.cancel_completion();
                     }
                 }
@@ -1660,26 +2100,31 @@ impl LapceEditorBufferData {
                 // we allow empty inputs to allow for cases where the user wants to get the autocompletion beforehand
                 self.update_completion(ctx, true);
             }
+            GetSignature => {
+                self.update_signature();
+            }
             GotoDefinition => {
-                let offset = self.editor.cursor.offset();
-                let start_offset = self.doc.buffer().prev_code_boundary(offset);
-                let start_position =
-                    self.doc.buffer().offset_to_position(start_offset);
-                let event_sink = ctx.get_external_handle();
-                let buffer_id = self.doc.id();
-                let position = self.doc.buffer().offset_to_position(offset);
-                let proxy = self.proxy.clone();
-                let editor_view_id = self.editor.view_id;
-                self.proxy.get_definition(
-                    offset,
-                    buffer_id,
-                    position,
-                    Box::new(move |result| {
-                        if let Ok(res) = result {
-                            if let Ok(resp) =
-                                serde_json::from_value::<GotoDefinitionResponse>(res)
+                if let BufferContent::File(path) = self.doc.content() {
+                    let offset = self.editor.cursor.offset();
+                    let start_offset = self.doc.buffer().prev_code_boundary(offset);
+                    let start_position =
+                        self.doc.buffer().offset_to_position(start_offset);
+                    let event_sink = ctx.get_external_handle();
+                    let position = self.doc.buffer().offset_to_position(offset);
+                    let proxy = self.proxy.clone();
+                    let editor_view_id = self.editor.view_id;
+                    let path = path.clone();
+                    self.proxy.proxy_rpc.get_definition(
+                        offset,
+                        path.clone(),
+                        position,
+                        move |result| {
+                            if let Ok(ProxyResponse::GetDefinitionResponse {
+                                          definition,
+                                          ..
+                                      }) = result
                             {
-                                if let Some(location) = match resp {
+                                if let Some(location) = match definition {
                                     GotoDefinitionResponse::Scalar(location) => {
                                         Some(location)
                                     }
@@ -1691,29 +2136,31 @@ impl LapceEditorBufferData {
                                         }
                                     }
                                     GotoDefinitionResponse::Link(
-                                        _location_links,
-                                    ) => None,
+                                        location_links,
+                                    ) => {
+                                        let location_link = location_links[0].clone();
+                                        Some(Location { uri: location_link.target_uri, range:location_link.target_selection_range  })
+                                    },
                                 } {
                                     if location.range.start == start_position {
-                                        proxy.get_references(
-                                            buffer_id,
+                                        proxy.proxy_rpc.get_references(
+                                            path.clone(),
                                             position,
-                                            Box::new(move |result| {
-                                                let _ = process_get_references(
-                                                    editor_view_id,
-                                                    offset,
-                                                    result,
-                                                    event_sink,
-                                                );
-                                            }),
+                                            move |result| {
+                                                if let Ok(ProxyResponse::GetReferencesResponse { references }) = result {
+                                                    process_get_references(
+                                                        offset, references, event_sink,
+                                                    );
+                                                }
+                                            },
                                         );
                                     } else {
                                         let _ = event_sink.submit_command(
                                             LAPCE_UI_COMMAND,
-                                            LapceUICommand::GotoDefinition(
+                                            LapceUICommand::GotoDefinition {
                                                 editor_view_id,
                                                 offset,
-                                                EditorLocation {
+                                                location: EditorLocation {
                                                     path: path_from_url(
                                                         &location.uri,
                                                     ),
@@ -1723,15 +2170,122 @@ impl LapceEditorBufferData {
                                                     scroll_offset: None,
                                                     history: None,
                                                 },
-                                            ),
+                                            },
                                             Target::Auto,
                                         );
                                     }
                                 }
                             }
-                        }
-                    }),
-                );
+                        },
+                    );
+                }
+            }
+            GotoTypeDefinition => {
+                if let BufferContent::File(path) = self.doc.content() {
+                    let offset = self.editor.cursor.offset();
+                    let event_sink = ctx.get_external_handle();
+                    let position = self.doc.buffer().offset_to_position(offset);
+                    let editor_view_id = self.editor.view_id;
+                    self.proxy.proxy_rpc.get_type_definition(
+                        offset,
+                        path.clone(),
+                        position,
+                        move |result| {
+                            if let Ok(ProxyResponse::GetTypeDefinition {
+                                          definition,
+                                          ..
+                                      }) = result
+                            {
+                                match definition {
+                                    GotoTypeDefinitionResponse::Scalar(location) => {
+                                        let _ = event_sink.submit_command(
+                                            LAPCE_UI_COMMAND,
+                                            LapceUICommand::GotoDefinition {
+                                                editor_view_id,
+                                                offset,
+                                                location: EditorLocation {
+                                                    path: path_from_url(
+                                                        &location.uri,
+                                                    ),
+                                                    position: Some(
+                                                        location.range.start,
+                                                    ),
+                                                    scroll_offset: None,
+                                                    history: None,
+                                                },
+                                            },
+                                            Target::Auto,
+                                        );
+                                    }
+                                    GotoTypeDefinitionResponse::Array(locations) => {
+                                        let len = locations.len();
+                                        match len {
+                                            1 => {
+                                                let _ = event_sink.submit_command(
+                                                    LAPCE_UI_COMMAND,
+                                                    LapceUICommand::GotoDefinition {
+                                                        editor_view_id,
+                                                        offset,
+                                                        location: EditorLocation {
+                                                            path: path_from_url(
+                                                                &locations[0].uri,
+                                                            ),
+                                                            position: Some(
+                                                                locations[0]
+                                                                    .range
+                                                                    .start,
+                                                            ),
+                                                            scroll_offset: None,
+                                                            history: None,
+                                                        },
+                                                    },
+                                                    Target::Auto,
+                                                );
+                                            }
+                                            _ if len > 1 => {
+                                                let _ = event_sink.submit_command(
+                                                    LAPCE_UI_COMMAND,
+                                                    LapceUICommand::PaletteReferences(
+                                                        offset, locations,
+                                                    ),
+                                                    Target::Auto,
+                                                );
+                                            }
+                                            _ => (),
+                                        }
+                                    }
+                                    GotoTypeDefinitionResponse::Link(
+                                        location_links,
+                                    ) => {
+                                        let location_link = location_links[0].clone();
+                                        let _ = event_sink.submit_command(
+                                            LAPCE_UI_COMMAND,
+                                            LapceUICommand::GotoDefinition {
+                                                editor_view_id,
+                                                offset,
+                                                location: EditorLocation {
+                                                    path: path_from_url(
+                                                        &location_link.target_uri,
+                                                    ),
+                                                    position: Some(
+                                                        location_link.target_selection_range.start
+                                                    ),
+                                                    scroll_offset: None,
+                                                    history: None,
+                                                },
+                                            },
+                                            Target::Auto,
+                                        );
+                                    }
+                                }
+                            }
+                        },
+                    );
+                }
+            }
+            ShowHover => {
+                let offset = self.editor.cursor.offset();
+                self.update_hover(ctx, offset);
             }
             JumpLocationBackward => {
                 self.jump_location_backward(ctx);
@@ -1742,24 +2296,42 @@ impl LapceEditorBufferData {
             NextError => {
                 self.next_error(ctx);
             }
+            PreviousDiff => {
+                self.prev_diff(ctx);
+            }
             NextDiff => {
                 self.next_diff(ctx);
             }
             ToggleCodeLens => {
                 let editor = Arc::make_mut(&mut self.editor);
-                editor.code_lens = !editor.code_lens;
+                editor.view = match editor.view {
+                    EditorView::Normal => EditorView::Lens,
+                    EditorView::Lens => EditorView::Normal,
+                    EditorView::Diff(_) => return CommandExecuted::Yes,
+                };
+            }
+            ToggleHistory => {
+                let editor = Arc::make_mut(&mut self.editor);
+                (editor.view, editor.compare) = match editor.view {
+                    EditorView::Normal => (
+                        EditorView::Diff(String::from("head")),
+                        Some(String::from("head")),
+                    ),
+                    EditorView::Diff(_) => (EditorView::Normal, None),
+                    EditorView::Lens => return CommandExecuted::Yes,
+                };
             }
             FormatDocument => {
                 if let BufferContent::File(path) = self.doc.content() {
                     let path = path.clone();
                     let proxy = self.proxy.clone();
-                    let buffer_id = self.doc.id();
                     let rev = self.doc.rev();
                     let event_sink = ctx.get_external_handle();
                     let (sender, receiver) = bounded(1);
+                    let tab_id = self.main_split.tab_id.clone();
                     thread::spawn(move || {
-                        proxy.get_document_formatting(
-                            buffer_id,
+                        proxy.proxy_rpc.get_document_formatting(
+                            path.clone(),
                             Box::new(move |result| {
                                 let _ = sender.send(result);
                             }),
@@ -1769,12 +2341,23 @@ impl LapceEditorBufferData {
                             .recv_timeout(Duration::from_secs(1))
                             .map_or_else(
                                 |e| Err(anyhow!("{}", e)),
-                                |v| v.map_err(|e| anyhow!("{:?}", e)),
+                                |v| {
+                                    v.map_err(|e| anyhow!("{:?}", e)).and_then(|r| {
+                                        if let ProxyResponse::GetDocumentFormatting {
+                                            edits,
+                                        } = r
+                                        {
+                                            Ok(edits)
+                                        } else {
+                                            Err(anyhow!("wrong response"))
+                                        }
+                                    })
+                                },
                             );
                         let _ = event_sink.submit_command(
                             LAPCE_UI_COMMAND,
-                            LapceUICommand::DocumentFormat(path, rev, result),
-                            Target::Auto,
+                            LapceUICommand::DocumentFormat { path, rev, result },
+                            Target::Widget(*tab_id),
                         );
                     });
                 }
@@ -1812,8 +2395,7 @@ impl LapceEditorBufferData {
                         .to_string()
                 };
                 if !pattern.contains('\n') {
-                    Arc::make_mut(&mut self.find)
-                        .set_find(&pattern, false, false, false);
+                    Arc::make_mut(&mut self.find).set_find(&pattern, false, false);
                     ctx.submit_command(Command::new(
                         LAPCE_UI_COMMAND,
                         LapceUICommand::UpdateSearchInput(pattern),
@@ -1852,16 +2434,155 @@ impl LapceEditorBufferData {
                 }
             }
             SaveAndExit => {
-                self.save(ctx, true);
+                self.save(ctx, true, true);
             }
             Save => {
-                self.save(ctx, false);
+                self.save(ctx, false, true);
+            }
+            SaveWithoutFormatting => {
+                self.save(ctx, false, false);
+            }
+            Rename => {
+                if let BufferContent::File(path) = self.doc.content() {
+                    let offset = self.editor.cursor.offset();
+                    let buffer = self.doc.buffer().clone();
+                    let rev = self.doc.rev();
+                    let path = path.to_path_buf();
+                    let tab_id = *self.main_split.tab_id;
+                    let event_sink = ctx.get_external_handle();
+
+                    let position = self.doc.buffer().offset_to_position(offset);
+
+                    Arc::make_mut(&mut self.rename).update(
+                        path.clone(),
+                        rev,
+                        offset,
+                        position,
+                        self.editor.view_id,
+                    );
+                    self.proxy.proxy_rpc.prepare_rename(
+                        path.clone(),
+                        position,
+                        move |result| {
+                            if let Ok(ProxyResponse::PrepareRename { resp }) = result
+                            {
+                                RenameData::prepare_rename(
+                                    tab_id, path, offset, rev, buffer, resp,
+                                    event_sink,
+                                );
+                            }
+                        },
+                    );
+                }
+            }
+            ConfirmRename => {
+                let new_name = self
+                    .main_split
+                    .local_docs
+                    .get(&LocalBufferKind::Rename)
+                    .unwrap()
+                    .buffer()
+                    .text()
+                    .to_string();
+                let new_name = new_name.trim();
+                if !new_name.is_empty() {
+                    let event_sink = ctx.get_external_handle();
+                    let view_id = self.rename.from_editor;
+                    self.proxy.proxy_rpc.rename(
+                        self.rename.path.clone(),
+                        self.rename.position,
+                        new_name.to_string(),
+                        move |result| {
+                            if let Ok(ProxyResponse::Rename { edit }) = result {
+                                let _ = event_sink.submit_command(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::ApplyWorkspaceEdit(edit),
+                                    Target::Widget(view_id),
+                                );
+                            }
+                        },
+                    );
+                }
+                ctx.submit_command(Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Focus(FocusCommand::ModalClose),
+                        data: None,
+                    },
+                    Target::Widget(self.rename.view_id),
+                ));
+            }
+            SelectNextSyntaxItem => {
+                self.run_selection_range_command(ctx, SelectionRangeDirection::Next)
             }
+            SelectPreviousSyntaxItem => self
+                .run_selection_range_command(ctx, SelectionRangeDirection::Previous),
             _ => return CommandExecuted::No,
         }
         CommandExecuted::Yes
     }
 
+    fn run_selection_range_command(
+        &mut self,
+        ctx: &mut EventCtx,
+        direction: SelectionRangeDirection,
+    ) {
+        let offset = self.editor.cursor.offset();
+        if let BufferContent::File(path) = self.doc.content() {
+            let rev = self.doc.buffer().rev();
+            let buffer_id = self.doc.id();
+            let event_sink = ctx.get_external_handle();
+            let current_selection = self.editor.cursor.get_selection();
+
+            match &self.doc.syntax_selection_range {
+                // If the cached selection range match current revision, no need to call the
+                // LSP server, we ca apply it right now
+                Some(selection_range)
+                    if selection_range.match_request(
+                        buffer_id,
+                        rev,
+                        current_selection,
+                    ) =>
+                {
+                    let _ = event_sink.submit_command(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::ApplySelectionRange {
+                            rev,
+                            buffer_id,
+                            direction,
+                        },
+                        Target::Auto,
+                    );
+                }
+                // Otherwise, ask the LSP server for `textDocument/selectionRange`
+                _ => {
+                    let position = self.doc.buffer().offset_to_position(offset);
+                    self.proxy.proxy_rpc.get_selection_range(
+                        path.to_owned(),
+                        vec![position],
+                        move |result| {
+                            if let Ok(ProxyResponse::GetSelectionRange { ranges }) =
+                                result
+                            {
+                                let _ = event_sink.submit_command(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::StoreSelectionRangeAndApply {
+                                        ranges,
+                                        rev,
+                                        buffer_id,
+                                        direction,
+                                        current_selection,
+                                    },
+                                    Target::Auto,
+                                );
+                            }
+                        },
+                    )
+                }
+            }
+        }
+    }
+
     fn run_motion_mode_command(
         &mut self,
         _ctx: &mut EventCtx,
@@ -1885,9 +2606,11 @@ impl LapceEditorBufferData {
         ctx: &mut EventCtx,
         cmd: &MultiSelectionCommand,
     ) -> CommandExecuted {
+        let view = self.editor.view.clone();
         let cursor = &mut Arc::make_mut(&mut self.editor).cursor;
         self.doc
-            .do_multi_selection(ctx.text(), cursor, cmd, &self.config);
+            .do_multi_selection(ctx.text(), cursor, cmd, &view, &self.config);
+        self.cancel_signature();
         self.cancel_completion();
         CommandExecuted::Yes
     }
@@ -1908,6 +2631,13 @@ impl KeyPressFocus for LapceEditorBufferData {
 
     fn check_condition(&self, condition: &str) -> bool {
         match condition {
+            "search_active" => {
+                if self.config.core.modal && !self.editor.cursor.is_normal() {
+                    false
+                } else {
+                    self.find.visual
+                }
+            }
             "search_focus" => {
                 self.editor.content == BufferContent::Local(LocalBufferKind::Search)
                     && self.editor.parent_view_id.is_some()
@@ -1932,10 +2662,12 @@ impl KeyPressFocus for LapceEditorBufferData {
             "completion_focus" => self.has_completions(),
             "hover_focus" => self.has_hover(),
             "list_focus" => self.has_completions() || self.is_palette(),
+            "rename_focus" => self.has_rename(),
             "modal_focus" => {
-                (self.has_completions() && !self.config.lapce.modal)
+                (self.has_completions() && !self.config.core.modal)
                     || self.has_hover()
                     || self.is_palette()
+                    || self.has_rename()
             }
             _ => false,
         }
@@ -1943,12 +2675,18 @@ impl KeyPressFocus for LapceEditorBufferData {
 
     fn receive_char(&mut self, ctx: &mut EventCtx, c: &str) {
         if self.get_mode() == Mode::Insert {
-            self.initiate_diagnostics_offset();
             let doc = Arc::make_mut(&mut self.doc);
             let cursor = &mut Arc::make_mut(&mut self.editor).cursor;
-            let deltas = doc.do_insert(cursor, c);
+            let deltas = doc.do_insert(cursor, c, &self.config);
 
-            self.update_completion(ctx, false);
+            if !c
+                .chars()
+                .all(|c| c.is_whitespace() || c.is_ascii_whitespace())
+            {
+                self.update_completion(ctx, false);
+            } else {
+                self.cancel_completion();
+            }
             self.cancel_hover();
             self.apply_deltas(&deltas);
         } else if let Some(direction) = self.editor.inline_find.clone() {
@@ -1967,7 +2705,6 @@ impl KeyPressFocus for LapceEditorBufferData {
         mods: Modifiers,
         _env: &Env,
     ) -> CommandExecuted {
-        self.initiate_diagnostics_offset();
         let old_doc = self.doc.clone();
         let executed = match &command.kind {
             CommandKind::Edit(cmd) => self.run_edit_command(ctx, cmd),
@@ -1997,9 +2734,11 @@ impl KeyPressFocus for LapceEditorBufferData {
 #[derive(Clone)]
 pub struct TabRect {
     pub svg: Svg,
+    pub svg_color: Option<Color>,
     pub rect: Rect,
     pub close_rect: Rect,
     pub text_layout: PietTextLayout,
+    pub path_layout: Option<PietTextLayout>,
 }
 
 #[derive(Clone)]
@@ -2009,27 +2748,44 @@ pub struct HighlightTextLayout {
     pub highlights: Vec<(usize, usize, String)>,
 }
 
-fn next_in_file_diff_offset(
-    position: Position,
+fn prev_in_file_diff_offset<'a>(
+    offset: usize,
     path: &Path,
-    file_diffs: &[(PathBuf, Vec<Position>)],
-) -> (PathBuf, Position) {
-    for (current_path, positions) in file_diffs {
+    file_diffs: &'a [(PathBuf, Vec<usize>)],
+) -> (&'a Path, usize) {
+    for (current_path, offsets) in file_diffs.iter().rev() {
         if path == current_path {
-            for diff_position in positions {
-                if diff_position.line > position.line
-                    || (diff_position.line == position.line
-                        && diff_position.character > position.character)
-                {
-                    return ((*current_path).clone(), *diff_position);
+            for diff_offset in offsets.iter().rev() {
+                if *diff_offset < offset {
+                    return (current_path.as_ref(), *diff_offset);
+                }
+            }
+        }
+        if current_path < path {
+            return (current_path.as_ref(), offsets[0]);
+        }
+    }
+    (file_diffs[0].0.as_ref(), file_diffs[0].1[0])
+}
+
+fn next_in_file_diff_offset<'a>(
+    offset: usize,
+    path: &Path,
+    file_diffs: &'a [(PathBuf, Vec<usize>)],
+) -> (&'a Path, usize) {
+    for (current_path, offsets) in file_diffs {
+        if path == current_path {
+            for diff_offset in offsets {
+                if *diff_offset > offset {
+                    return (current_path.as_ref(), *diff_offset);
                 }
             }
         }
         if current_path > path {
-            return ((*current_path).clone(), positions[0]);
+            return (current_path.as_ref(), offsets[0]);
         }
     }
-    ((file_diffs[0].0).clone(), file_diffs[0].1[0])
+    (file_diffs[0].0.as_ref(), file_diffs[0].1[0])
 }
 
 fn next_in_file_errors_offset(
@@ -2056,39 +2812,37 @@ fn next_in_file_errors_offset(
 }
 
 fn process_get_references(
-    editor_view_id: WidgetId,
     offset: usize,
-    result: Result<Value, Value>,
+    locations: Vec<Location>,
     event_sink: ExtEventSink,
-) -> Result<()> {
-    let res = result.map_err(|e| anyhow!("{:?}", e))?;
-    let locations: Vec<Location> = serde_json::from_value(res)?;
+) {
     if locations.is_empty() {
-        return Ok(());
+        return;
     }
     if locations.len() == 1 {
+        // If there's only a single location then just jump directly to it
         let location = &locations[0];
         let _ = event_sink.submit_command(
             LAPCE_UI_COMMAND,
-            LapceUICommand::GotoReference(
-                editor_view_id,
-                offset,
+            LapceUICommand::JumpToLspLocation(
+                None,
                 EditorLocation {
                     path: path_from_url(&location.uri),
                     position: Some(location.range.start),
                     scroll_offset: None,
                     history: None,
                 },
+                true,
             ),
             Target::Auto,
         );
+    } else {
+        let _ = event_sink.submit_command(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::PaletteReferences(offset, locations),
+            Target::Auto,
+        );
     }
-    let _ = event_sink.submit_command(
-        LAPCE_UI_COMMAND,
-        LapceUICommand::PaletteReferences(offset, locations),
-        Target::Auto,
-    );
-    Ok(())
 }
 
 fn workspace_edits(edit: &WorkspaceEdit) -> Option<HashMap<Url, Vec<TextEdit>>> {
@@ -2132,3 +2886,93 @@ fn workspace_edits(edit: &WorkspaceEdit) -> Option<HashMap<Url, Vec<TextEdit>>>
     };
     Some(edits)
 }
+
+fn workspace_operation(op: &ResourceOp) -> Option<LapceUICommand> {
+    Some(match op {
+        ResourceOp::Create(p) => LapceUICommand::CreateFileOpen {
+            path: p.uri.to_file_path().ok()?,
+        },
+        ResourceOp::Rename(p) => LapceUICommand::RenamePath {
+            from: p.old_uri.to_file_path().ok()?,
+            to: p.new_uri.to_file_path().ok()?,
+        },
+        ResourceOp::Delete(p) => LapceUICommand::TrashPath {
+            path: p.uri.to_file_path().ok()?,
+        },
+    })
+}
+
+/// Check if a [`Url`] matches the path
+fn url_matches_path(path: &Path, url: &Url) -> bool {
+    // TODO: Neither of these methods work for paths
+    // on different filesystems (i.e. windows and linux),
+    // as pathbuf is meant to represent a path on the host
+    let mut matches = false;
+    // This handles windows drive letters, which rust-url doesn't do.
+    if let Ok(url_path) = url.to_file_path() {
+        matches |= url_path == path;
+    }
+    // This is the previous check, to ensure this isn't a regression
+    if let Ok(path_url) = Url::from_file_path(path) {
+        matches |= &path_url == url;
+    }
+
+    matches
+}
+
+fn apply_edit(main_split: &mut LapceMainSplitData, path: &Path, edits: &[TextEdit]) {
+    let doc = match main_split.open_docs.get(path) {
+        Some(doc) => doc,
+        None => return,
+    };
+
+    let edits = edits
+        .iter()
+        .map(|edit| {
+            let selection = lapce_core::selection::Selection::region(
+                doc.buffer().offset_of_position(&edit.range.start),
+                doc.buffer().offset_of_position(&edit.range.end),
+            );
+            (selection, edit.new_text.as_str())
+        })
+        .collect::<Vec<_>>();
+
+    main_split.edit(path, &edits, lapce_core::editor::EditType::Other);
+}
+
+/// Checks if completion should be triggered if the received command
+/// is one that inserts whitespace or deletes whitespace
+fn show_completion(
+    cmd: &EditCommand,
+    doc: &Rope,
+    deltas: &[(RopeDelta, InvalLines, SyntaxEdit)],
+) -> bool {
+    let show_completion = match cmd {
+        EditCommand::DeleteBackward
+        | EditCommand::DeleteForward
+        | EditCommand::DeleteWordBackward
+        | EditCommand::DeleteWordForward
+        | EditCommand::DeleteForwardAndInsert => {
+            let start = match deltas.get(0).and_then(|delta| delta.0.els.get(0)) {
+                Some(lapce_xi_rope::DeltaElement::Copy(_, start)) => *start,
+                _ => 0,
+            };
+
+            let end = match deltas.get(0).and_then(|delta| delta.0.els.get(1)) {
+                Some(lapce_xi_rope::DeltaElement::Copy(end, _)) => *end,
+                _ => 0,
+            };
+
+            if start > 0 && end > start {
+                !doc.slice_to_cow(start..end)
+                    .chars()
+                    .all(|c| c.is_whitespace() || c.is_ascii_whitespace())
+            } else {
+                true
+            }
+        }
+        _ => false,
+    };
+
+    show_completion
+}
diff --git a/lapce-data/src/explorer.rs b/lapce-data/src/explorer.rs
index f8eb5007e5..62cec42e17 100644
--- a/lapce-data/src/explorer.rs
+++ b/lapce-data/src/explorer.rs
@@ -1,18 +1,65 @@
-use std::collections::HashMap;
-use std::path::Path;
-use std::path::PathBuf;
-use std::sync::Arc;
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
-use druid::ExtEventSink;
-use druid::{Target, WidgetId};
+use druid::{Command, EventCtx, ExtEventSink, Target, WidgetId};
+use lapce_core::{cursor::CursorMode, selection::Selection};
+use lapce_rpc::{file::FileNodeItem, proxy::ProxyResponse};
+use lapce_xi_rope::Rope;
 
-use lapce_rpc::file::FileNodeItem;
-use lapce_rpc::proxy::ReadDirResponse;
+use crate::{
+    command::{LapceUICommand, LAPCE_UI_COMMAND},
+    data::{LapceMainSplitData, LapceWorkspace},
+    document::LocalBufferKind,
+    proxy::LapceProxy,
+};
 
-use crate::data::LapceWorkspace;
-use crate::proxy::LapceProxy;
-
-use crate::{command::LapceUICommand, command::LAPCE_UI_COMMAND};
+#[derive(Clone)]
+pub enum Naming {
+    /// Renaming an existing file
+    Renaming {
+        /// The index into the file list of the file being renamed
+        list_index: usize,
+        /// Indentation level
+        indent_level: usize,
+    },
+    /// Naming a file that has yet to be created
+    Naming {
+        /// The index that the file being created should appear at
+        /// Note that when naming, it is not yet actually created.
+        list_index: usize,
+        /// Indentation level
+        indent_level: usize,
+        /// If true, then we are creating a directory
+        /// If false, then we are creating a file
+        is_dir: bool,
+        /// The folder that the file/directory is being created within
+        base_path: PathBuf,
+    },
+    /// Duplicating an existing file
+    Duplicating {
+        /// The index that the file being created should appear at
+        /// Note that when duplicating, it is not yet actually created.
+        list_index: usize,
+        /// Indentation level
+        indent_level: usize,
+        /// The folder that the file/directory is being created within
+        base_path: PathBuf,
+        /// The name of the file being duplicated
+        name: String,
+    },
+}
+impl Naming {
+    pub fn list_index(&self) -> usize {
+        match self {
+            Naming::Renaming { list_index, .. }
+            | Naming::Naming { list_index, .. }
+            | Naming::Duplicating { list_index, .. } => *list_index,
+        }
+    }
+}
 
 #[derive(Clone)]
 pub struct FileExplorerData {
@@ -20,6 +67,12 @@ pub struct FileExplorerData {
     pub widget_id: WidgetId,
     pub workspace: Option<FileNodeItem>,
     pub active_selected: Option<PathBuf>,
+    /// The status of renaming/naming a file/directory
+    pub naming: Option<Naming>,
+    /// The id of the editor (in `main_split.editors`) for renaming
+    pub renaming_editor_view_id: WidgetId,
+    pub proxy: Arc<LapceProxy>,
+    pub event_sink: ExtEventSink,
 }
 
 impl FileExplorerData {
@@ -41,9 +94,7 @@ impl FileExplorerData {
                 children_open_count: 0,
             });
             let path = path.clone();
-            std::thread::spawn(move || {
-                Self::read_dir(&path, true, tab_id, &proxy, event_sink);
-            });
+            Self::read_dir(&path, true, tab_id, &proxy, event_sink.clone());
         }
         Self {
             tab_id,
@@ -57,6 +108,10 @@ impl FileExplorerData {
                 children_open_count: 0,
             }),
             active_selected: None,
+            naming: None,
+            renaming_editor_view_id: WidgetId::next(),
+            proxy,
+            event_sink,
         }
     }
 
@@ -66,8 +121,8 @@ impl FileExplorerData {
             if node.open {
                 node.children_open_count = node
                     .children
-                    .iter()
-                    .map(|(_, item)| item.children_open_count + 1)
+                    .values()
+                    .map(|item| item.children_open_count + 1)
                     .sum::<usize>();
             } else {
                 node.children_open_count = 0;
@@ -86,8 +141,20 @@ impl FileExplorerData {
         )
     }
 
-    pub fn get_node_by_index(&mut self, index: usize) -> Option<&mut FileNodeItem> {
-        let (_, node) = get_item_children_mut(0, index, self.workspace.as_mut()?);
+    /// Get the node by its index into the file list
+    /// Returns the node and its indentation level
+    pub fn get_node_by_index(&self, index: usize) -> Option<(usize, &FileNodeItem)> {
+        let (_, node) = get_item_children(0, index, 0, self.workspace.as_ref()?);
+        node
+    }
+
+    /// Get the node by its index into the file list
+    /// Returns the node and its indentation level
+    pub fn get_node_by_index_mut(
+        &mut self,
+        index: usize,
+    ) -> Option<(usize, &mut FileNodeItem)> {
+        let (_, node) = get_item_children_mut(0, index, 0, self.workspace.as_mut()?);
         node
     }
 
@@ -107,12 +174,43 @@ impl FileExplorerData {
         Some(node)
     }
 
+    pub fn get_node_index(&self, path: &Path) -> Option<usize> {
+        self.workspace.as_ref().and_then(|root| {
+            let mut node = Some(root);
+            let mut index = 0;
+
+            while let Some(current) = node {
+                if current.path_buf == path {
+                    return Some(index);
+                }
+
+                for child in current.sorted_children() {
+                    index += 1;
+
+                    if path.starts_with(&child.path_buf) {
+                        node = Some(child);
+                        break;
+                    }
+
+                    index += child.children_open_count;
+                }
+            }
+
+            None
+        })
+    }
+
     pub fn update_children(
         &mut self,
         path: &Path,
         children: HashMap<PathBuf, FileNodeItem>,
         expand: bool,
     ) -> Option<()> {
+        // Ignore updates while naming a file
+        if self.naming.is_some() {
+            return None;
+        }
+
         let node = self.workspace.as_mut()?.get_file_node_mut(path)?;
 
         let removed_paths: Vec<PathBuf> = node
@@ -126,7 +224,17 @@ impl FileExplorerData {
         }
 
         for (path, child) in children.into_iter() {
-            if !node.children.contains_key(&path) {
+            if let Some(existing) = node.children.get(&path) {
+                if existing.read {
+                    Self::read_dir(
+                        &path,
+                        existing.open,
+                        self.tab_id,
+                        &self.proxy,
+                        self.event_sink.clone(),
+                    );
+                }
+            } else {
                 node.children.insert(child.path_buf.clone(), child);
             }
         }
@@ -143,51 +251,304 @@ impl FileExplorerData {
         Some(())
     }
 
+    pub fn reload(&self) {
+        if let Some(workspace) = self.workspace.as_ref() {
+            let workspace = workspace.clone();
+            Self::read_dir(
+                &workspace.path_buf,
+                true,
+                self.tab_id,
+                &self.proxy,
+                self.event_sink.clone(),
+            );
+        }
+    }
+
     pub fn read_dir(
         path: &Path,
         expand: bool,
         tab_id: WidgetId,
         proxy: &LapceProxy,
         event_sink: ExtEventSink,
+    ) {
+        FileExplorerData::read_dir_cb::<fn()>(
+            path, expand, tab_id, proxy, event_sink, None,
+        )
+    }
+
+    pub fn read_dir_cb<F: FnOnce() + Send + 'static>(
+        path: &Path,
+        expand: bool,
+        tab_id: WidgetId,
+        proxy: &LapceProxy,
+        event_sink: ExtEventSink,
+        on_finished: Option<F>,
     ) {
         let path = PathBuf::from(path);
         let local_path = path.clone();
-        proxy.read_dir(
-            &local_path,
-            Box::new(move |result| {
-                if let Ok(res) = result {
-                    let path = path.clone();
-                    let resp: Result<ReadDirResponse, serde_json::Error> =
-                        serde_json::from_value(res);
-                    if let Ok(resp) = resp {
-                        let _ = event_sink.submit_command(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::UpdateExplorerItems(
-                                path, resp.items, expand,
-                            ),
-                            Target::Widget(tab_id),
-                        );
-                    }
+        proxy.proxy_rpc.read_dir(local_path, move |result| {
+            if let Ok(ProxyResponse::ReadDirResponse { items }) = result {
+                let path = path.clone();
+                let _ = event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::UpdateExplorerItems {
+                        path,
+                        items,
+                        expand,
+                    },
+                    Target::Widget(tab_id),
+                );
+
+                if let Some(on_finished) = on_finished {
+                    on_finished();
                 }
-            }),
-        );
+            }
+        });
+    }
+
+    /// Stop naming the file/directory, discarding any changes
+    pub fn cancel_naming(&mut self) {
+        self.naming = None;
+    }
+
+    /// Apply the current naming/renaming text (if it is nonempty and not the same as before)
+    /// Also stops the naming.
+    pub fn apply_naming(
+        &mut self,
+        ctx: &mut EventCtx,
+        main_split: &LapceMainSplitData,
+    ) {
+        let naming = if let Some(naming) = &self.naming {
+            naming
+        } else {
+            return;
+        };
+
+        // Get the text in the input
+        let doc = main_split
+            .local_docs
+            .get(&LocalBufferKind::PathName)
+            .unwrap();
+        let target_name = doc.buffer().to_string();
+        // If the name is empty, then we just ignore it
+        if target_name.is_empty() {
+            self.cancel_naming();
+            return;
+        }
+
+        match naming {
+            Naming::Renaming { list_index, .. } => {
+                let renaming =
+                    if let Some((_, node)) = self.get_node_by_index(*list_index) {
+                        &node.path_buf
+                    } else {
+                        // There was either nothing we were renaming, or the index disappeared
+                        return;
+                    };
+
+                let target_path = renaming.with_file_name(target_name);
+
+                // If it is the same, then we don't bother renaming it
+                if &target_path == renaming {
+                    return;
+                }
+
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::RenamePath {
+                        from: renaming.clone(),
+                        to: target_path,
+                    },
+                    Target::Auto,
+                ));
+            }
+            Naming::Naming {
+                is_dir, base_path, ..
+            } => {
+                let mut path = base_path.clone();
+                path.push(target_name);
+
+                let cmd = if *is_dir {
+                    LapceUICommand::CreateDirectory { path }
+                } else {
+                    LapceUICommand::CreateFileOpen { path }
+                };
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    cmd,
+                    Target::Auto,
+                ));
+            }
+            Naming::Duplicating {
+                base_path, name, ..
+            } => {
+                let new_path = base_path.join(target_name);
+
+                let cmd = LapceUICommand::DuplicateFileOpen {
+                    existing_path: base_path.join(name),
+                    new_path,
+                };
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    cmd,
+                    Target::Auto,
+                ));
+            }
+        }
+
+        self.cancel_naming();
+    }
+
+    pub fn start_naming(
+        &mut self,
+        ctx: &mut EventCtx,
+        main_split: &mut LapceMainSplitData,
+        list_index: usize,
+        indent_level: usize,
+        is_dir: bool,
+        base_path: PathBuf,
+    ) {
+        self.cancel_naming();
+        self.naming = Some(Naming::Naming {
+            list_index,
+            indent_level,
+            is_dir,
+            base_path,
+        });
+
+        // Clear the text of the input
+        let doc = main_split
+            .local_docs
+            .get_mut(&LocalBufferKind::PathName)
+            .unwrap();
+        Arc::make_mut(doc).reload(Rope::from(String::new()), true);
+
+        // Make sure the cursor is at the right position
+        let editor = main_split
+            .editors
+            .get_mut(&self.renaming_editor_view_id)
+            .unwrap();
+        Arc::make_mut(editor).cursor.mode = CursorMode::Insert(Selection::caret(0));
+
+        // Focus on the input
+        ctx.submit_command(Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::Focus,
+            Target::Widget(editor.view_id),
+        ));
+    }
+
+    /// Show the naming input for the given file at the index
+    /// Requires `main_split` for getting the input to set its content
+    /// Requires `ctx` to switch focus to the input
+    pub fn start_duplicating(
+        &mut self,
+        ctx: &mut EventCtx,
+        main_split: &mut LapceMainSplitData,
+        list_index: usize,
+        indent_level: usize,
+        base_path: PathBuf,
+        name: String,
+    ) {
+        self.cancel_naming();
+        self.naming = Some(Naming::Duplicating {
+            list_index,
+            indent_level,
+            base_path,
+            name: name.clone(),
+        });
+
+        // Set the text of the input
+        let doc = main_split
+            .local_docs
+            .get_mut(&LocalBufferKind::PathName)
+            .unwrap();
+        Arc::make_mut(doc).reload(Rope::from(name), true);
+
+        // TODO: We could provide a configuration option to only select the filename at first,
+        // which would fit a common case of just wanting to change the filename and not the ext
+        // (or that could be the default)
+
+        // Select all of the text, allowing them to quickly completely change the name if they wish
+        let editor = main_split
+            .editors
+            .get_mut(&self.renaming_editor_view_id)
+            .unwrap();
+        let offset = doc.buffer().line_end_offset(0, true);
+        Arc::make_mut(editor).cursor.mode =
+            CursorMode::Insert(Selection::region(0, offset));
+
+        // Focus on the input
+        ctx.submit_command(Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::Focus,
+            Target::Widget(editor.view_id),
+        ));
+    }
+
+    /// Show the renaming input for the given file at the index
+    /// Requires `main_split` for getting the input to set its content
+    /// Requires `ctx` to switch focus to the input
+    pub fn start_renaming(
+        &mut self,
+        ctx: &mut EventCtx,
+        main_split: &mut LapceMainSplitData,
+        list_index: usize,
+        indent_level: usize,
+        text: String,
+    ) {
+        self.cancel_naming();
+        self.naming = Some(Naming::Renaming {
+            list_index,
+            indent_level,
+        });
+
+        // Set the text of the input
+        let doc = main_split
+            .local_docs
+            .get_mut(&LocalBufferKind::PathName)
+            .unwrap();
+        Arc::make_mut(doc).reload(Rope::from(text), true);
+
+        // TODO: We could provide a configuration option to only select the filename at first,
+        // which would fit a common case of just wanting to change the filename and not the ext
+        // (or that could be the default)
+
+        // Select all of the text, allowing them to quickly completely change the name if they wish
+        let editor = main_split
+            .editors
+            .get_mut(&self.renaming_editor_view_id)
+            .unwrap();
+        let offset = doc.buffer().line_end_offset(0, true);
+        Arc::make_mut(editor).cursor.mode =
+            CursorMode::Insert(Selection::region(0, offset));
+
+        // Focus on the input
+        ctx.submit_command(Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::Focus,
+            Target::Widget(editor.view_id),
+        ));
     }
 }
 
+/// Returns (current index, Option<(indentation level of item, item)>)
 pub fn get_item_children(
     i: usize,
     index: usize,
+    indent: usize,
     item: &FileNodeItem,
-) -> (usize, Option<&FileNodeItem>) {
+) -> (usize, Option<(usize, &FileNodeItem)>) {
     if i == index {
-        return (i, Some(item));
+        return (i, Some((indent, item)));
     }
     let mut i = i;
     if item.open {
         for child in item.sorted_children() {
             let count = child.children_open_count;
             if i + count + 1 >= index {
-                let (new_index, node) = get_item_children(i + 1, index, child);
+                let (new_index, node) =
+                    get_item_children(i + 1, index, indent + 1, child);
                 if new_index == index {
                     return (new_index, node);
                 }
@@ -201,17 +562,19 @@ pub fn get_item_children(
 pub fn get_item_children_mut(
     i: usize,
     index: usize,
+    indent: usize,
     item: &mut FileNodeItem,
-) -> (usize, Option<&mut FileNodeItem>) {
+) -> (usize, Option<(usize, &mut FileNodeItem)>) {
     if i == index {
-        return (i, Some(item));
+        return (i, Some((indent, item)));
     }
     let mut i = i;
     if item.open {
         for child in item.sorted_children_mut() {
             let count = child.children_open_count;
             if i + count + 1 >= index {
-                let (new_index, node) = get_item_children_mut(i + 1, index, child);
+                let (new_index, node) =
+                    get_item_children_mut(i + 1, index, indent + 1, child);
                 if new_index == index {
                     return (new_index, node);
                 }
diff --git a/lapce-data/src/find.rs b/lapce-data/src/find.rs
index 5de230e137..5726f573f6 100644
--- a/lapce-data/src/find.rs
+++ b/lapce-data/src/find.rs
@@ -1,15 +1,16 @@
+use std::cmp::{max, min};
+
 use lapce_core::{
     selection::{InsertDrift, SelRegion, Selection},
     word::WordCursor,
 };
-use regex::{Regex, RegexBuilder};
-use serde::{Deserialize, Serialize};
-use std::cmp::{max, min};
-use xi_rope::{
+use lapce_xi_rope::{
     delta::DeltaRegion,
     find::{find, is_multiline_regex, CaseMatching},
     Cursor, Interval, LinesMetric, Metric, Rope, RopeDelta,
 };
+use regex::{Regex, RegexBuilder};
+use serde::{Deserialize, Serialize};
 
 const REGEX_SIZE_LIMIT: usize = 1000000;
 
@@ -106,6 +107,26 @@ impl Find {
         self.hls_dirty = is_dirty
     }
 
+    /// Returns `true` if case sensitive, otherwise `false`
+    pub fn case_sensitive(&self) -> bool {
+        match self.case_matching {
+            CaseMatching::Exact => true,
+            CaseMatching::CaseInsensitive => false,
+        }
+    }
+
+    /// FLips the current case sensitivity and return the new sensitivity
+    /// `true` for case_sensitive, `false` for case insensitive.
+    pub fn toggle_case_sensitive(&mut self) -> bool {
+        let case_matching = match self.case_matching {
+            CaseMatching::Exact => CaseMatching::CaseInsensitive,
+            CaseMatching::CaseInsensitive => CaseMatching::Exact,
+        };
+
+        self.case_matching = case_matching;
+        self.case_sensitive()
+    }
+
     /// Returns `true` if the search query is a multi-line regex.
     pub(crate) fn is_multiline_regex(&self) -> bool {
         self.regex.is_some()
@@ -119,40 +140,40 @@ impl Find {
         self.hls_dirty = true;
     }
 
+    /// Sets find case sensitivity.
+    pub fn set_case_sensitive(&mut self, case_sensitive: bool) {
+        let case_matching = if case_sensitive {
+            CaseMatching::Exact
+        } else {
+            CaseMatching::CaseInsensitive
+        };
+
+        self.case_matching = case_matching;
+    }
+
     /// Sets find parameters and search query. Returns `true` if parameters have been updated.
     /// Returns `false` to indicate that parameters haven't change.
     pub fn set_find(
         &mut self,
         search_string: &str,
-        case_sensitive: bool,
         is_regex: bool,
         whole_words: bool,
-    ) -> bool {
+    ) {
         if search_string.is_empty() {
             self.unset();
         }
-
-        let case_matching = if case_sensitive {
-            CaseMatching::Exact
-        } else {
-            CaseMatching::CaseInsensitive
-        };
-
         if let Some(ref s) = self.search_string {
             if s == search_string
-                && case_matching == self.case_matching
                 && self.regex.is_some() == is_regex
                 && self.whole_words == whole_words
             {
                 // search parameters did not change
-                return false;
             }
         }
 
         self.unset();
 
         self.search_string = Some(search_string.to_string());
-        self.case_matching = case_matching;
         self.whole_words = whole_words;
 
         // create regex from untrusted input
@@ -160,12 +181,10 @@ impl Find {
             false => None,
             true => RegexBuilder::new(search_string)
                 .size_limit(REGEX_SIZE_LIMIT)
-                .case_insensitive(case_matching == CaseMatching::CaseInsensitive)
+                .case_insensitive(!self.case_sensitive())
                 .build()
                 .ok(),
         };
-
-        true
     }
 
     pub fn next(
@@ -374,8 +393,7 @@ impl Find {
                 old_offset, len, ..
             } in delta.iter_deletions()
             {
-                self.occurrences
-                    .delete_range(old_offset, old_offset + len, false);
+                self.occurrences.delete_range(old_offset, old_offset + len);
             }
 
             self.occurrences =
@@ -389,11 +407,8 @@ impl Find {
             {
                 // also invalidate previous occurrence since it might expand after insertion
                 // eg. for regex .* every insertion after match will be part of match
-                self.occurrences.delete_range(
-                    new_offset.saturating_sub(1),
-                    new_offset + len,
-                    false,
-                );
+                self.occurrences
+                    .delete_range(new_offset.saturating_sub(1), new_offset + len);
             }
 
             // update find for the whole delta and everything after
@@ -402,7 +417,7 @@ impl Find {
             // get last valid occurrence that was unaffected by the delta
             let start = match self.occurrences.regions_in_range(0, iv.start()).last()
             {
-                Some(reg) => reg.end(),
+                Some(reg) => reg.end,
                 None => 0,
             };
 
@@ -412,7 +427,7 @@ impl Find {
 
             if is_multiline || self.is_multiline_regex() {
                 // ... the end of the file
-                self.occurrences.delete_range(iv.start(), text.len(), false);
+                self.occurrences.delete_range(iv.start(), text.len());
                 self.update_find(text, start, text.len(), false);
             } else {
                 // ... the end of the line including line break
@@ -424,8 +439,7 @@ impl Find {
                     _ => return,
                 };
 
-                self.occurrences
-                    .delete_range(iv.start(), end_of_line, false);
+                self.occurrences.delete_range(iv.start(), end_of_line);
                 self.update_find(text, start, end_of_line, false);
             }
         }
diff --git a/lapce-data/src/history.rs b/lapce-data/src/history.rs
index a55dda5224..c8dbf5d7d5 100644
--- a/lapce-data/src/history.rs
+++ b/lapce-data/src/history.rs
@@ -1,28 +1,31 @@
 use std::{
     cell::RefCell,
+    collections::HashMap,
+    ops::Range,
     rc::Rc,
     sync::{atomic, Arc},
 };
 
 use druid::{
-    piet::{PietText, PietTextLayout, Text, TextAttribute, TextLayoutBuilder},
+    piet::{PietText, Text, TextAttribute, TextLayoutBuilder},
     Target,
 };
+use itertools::Itertools;
 use lapce_core::{
     buffer::{rope_diff, Buffer, DiffLines},
     style::line_styles,
     syntax::Syntax,
 };
 use lapce_rpc::{
-    buffer::BufferHeadResponse,
+    proxy::ProxyResponse,
     style::{LineStyle, LineStyles, Style},
 };
-use xi_rope::{spans::Spans, Rope};
+use lapce_xi_rope::{spans::Spans, Rope};
 
 use crate::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::{Config, LapceTheme},
-    document::{BufferContent, Document, TextLayoutCache},
+    config::{LapceConfig, LapceTheme},
+    document::{BufferContent, Document, TextLayoutCache, TextLayoutLine},
 };
 
 #[derive(Clone)]
@@ -33,6 +36,7 @@ pub struct DocumentHistory {
     line_styles: Rc<RefCell<LineStyles>>,
     changes: Arc<Vec<DiffLines>>,
     text_layouts: Rc<RefCell<TextLayoutCache>>,
+    diff_context_lines: i32,
 }
 
 impl druid::Data for DocumentHistory {
@@ -54,9 +58,9 @@ impl druid::Data for DocumentHistory {
         }
     }
 }
-
+pub const DEFAULT_DIFF_CONTEXT_LINES: usize = 3;
 impl DocumentHistory {
-    pub fn new(version: String) -> Self {
+    pub fn new(version: String, diff_context_lines: i32) -> Self {
         Self {
             version,
             buffer: None,
@@ -64,6 +68,7 @@ impl DocumentHistory {
             line_styles: Rc::new(RefCell::new(LineStyles::new())),
             text_layouts: Rc::new(RefCell::new(TextLayoutCache::new())),
             changes: Arc::new(Vec::new()),
+            diff_context_lines,
         }
     }
 
@@ -79,18 +84,35 @@ impl DocumentHistory {
         &self,
         text: &mut PietText,
         line: usize,
-        config: &Config,
-    ) -> Arc<PietTextLayout> {
+        config: &LapceConfig,
+    ) -> Arc<TextLayoutLine> {
+        let font_size = 0;
         self.text_layouts.borrow_mut().check_attributes(config.id);
-        if self.text_layouts.borrow().layouts.get(&line).is_none() {
+        if self.text_layouts.borrow().layouts.get(&font_size).is_none() {
+            let mut cache = self.text_layouts.borrow_mut();
+            cache.layouts.insert(font_size, HashMap::new());
+        }
+        if self
+            .text_layouts
+            .borrow()
+            .layouts
+            .get(&font_size)
+            .unwrap()
+            .get(&line)
+            .is_none()
+        {
             self.text_layouts
                 .borrow_mut()
                 .layouts
+                .get_mut(&font_size)
+                .unwrap()
                 .insert(line, Arc::new(self.new_text_layout(text, line, config)));
         }
         self.text_layouts
             .borrow()
             .layouts
+            .get(&font_size)
+            .unwrap()
             .get(&line)
             .cloned()
             .unwrap()
@@ -100,8 +122,8 @@ impl DocumentHistory {
         &self,
         text: &mut PietText,
         line: usize,
-        config: &Config,
-    ) -> PietTextLayout {
+        config: &LapceConfig,
+    ) -> TextLayoutLine {
         let line_content = self.buffer.as_ref().unwrap().line_content(line);
         let font_family = config.editor.font_family();
         let font_size = config.editor.font_size;
@@ -129,7 +151,12 @@ impl DocumentHistory {
             }
         }
 
-        layout_builder.build().unwrap()
+        TextLayoutLine {
+            text: layout_builder.build().unwrap(),
+            extra_style: Vec::new(),
+            whitespaces: None,
+            indent: 0.0,
+        }
     }
 
     fn line_style(&self, line: usize) -> Arc<Vec<LineStyle>> {
@@ -146,6 +173,7 @@ impl DocumentHistory {
         self.line_styles.borrow().get(&line).cloned().unwrap()
     }
 
+    /// Retrieve the `head` version of the buffer
     pub fn retrieve(&self, doc: &Document) {
         if let BufferContent::File(path) = &doc.content() {
             let id = doc.id();
@@ -154,28 +182,181 @@ impl DocumentHistory {
             let proxy = doc.proxy.clone();
             let event_sink = doc.event_sink.clone();
             std::thread::spawn(move || {
-                proxy.get_buffer_head(
-                    id,
-                    path.clone(),
-                    Box::new(move |result| {
-                        if let Ok(res) = result {
-                            if let Ok(resp) =
-                                serde_json::from_value::<BufferHeadResponse>(res)
-                            {
-                                let _ = event_sink.submit_command(
-                                    LAPCE_UI_COMMAND,
-                                    LapceUICommand::LoadBufferHead {
-                                        path,
-                                        content: Rope::from(resp.content),
-                                        version: resp.version,
+                proxy
+                    .proxy_rpc
+                    .get_buffer_head(id, path.clone(), move |result| {
+                        if let Ok(ProxyResponse::BufferHeadResponse {
+                            version,
+                            content,
+                        }) = result
+                        {
+                            let _ = event_sink.submit_command(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::LoadBufferHead {
+                                    path,
+                                    content: Rope::from(content),
+                                    version,
+                                },
+                                Target::Widget(tab_id),
+                            );
+                        }
+                    })
+            });
+        }
+    }
+
+    pub fn trigger_increase_diff_extend_lines(
+        &self,
+        doc: &Document,
+        diff_skip: DiffLines,
+    ) {
+        let incr = 5_usize;
+        if self.buffer.is_none() {
+            return;
+        }
+        if let BufferContent::File(path) = &doc.content() {
+            let id = doc.id();
+            let rev = doc.rev();
+            let path = path.clone();
+            let event_sink = doc.event_sink.clone();
+            let tab_id = doc.tab_id;
+
+            let old_changes = self.changes.clone();
+            let changes_len = old_changes.len();
+            let mut changes = self.changes.clone().to_vec();
+            for (i, change) in old_changes.iter().enumerate() {
+                if let DiffLines::Skip(left, right) = change {
+                    if *change == diff_skip {
+                        if i == 0 {
+                            let l_incr =
+                                if left.len() < incr { left.len() } else { incr };
+                            let r_incr =
+                                if right.len() < 5 { right.len() } else { incr };
+                            changes[i] = DiffLines::Skip(
+                                Range {
+                                    start: left.start,
+                                    end: left.end - l_incr,
+                                },
+                                Range {
+                                    start: right.start,
+                                    end: right.end - r_incr,
+                                },
+                            );
+                            if let DiffLines::Both(l, r) = &old_changes[i + 1] {
+                                changes[i + 1] = DiffLines::Both(
+                                    Range {
+                                        start: l.start - l_incr,
+                                        end: l.end,
+                                    },
+                                    Range {
+                                        start: r.start - r_incr,
+                                        end: r.end,
+                                    },
+                                );
+                            }
+                        } else if i == changes_len - 1 {
+                            let l_incr =
+                                if left.len() < incr { left.len() } else { incr };
+                            let r_incr =
+                                if right.len() < 5 { right.len() } else { incr };
+                            if let DiffLines::Both(l, r) = &old_changes[i - 1] {
+                                changes[i - 1] = DiffLines::Both(
+                                    Range {
+                                        start: l.start,
+                                        end: l.end + l_incr,
+                                    },
+                                    Range {
+                                        start: r.start,
+                                        end: r.end + r_incr,
+                                    },
+                                );
+                            }
+                            changes[i] = DiffLines::Skip(
+                                Range {
+                                    start: left.start + l_incr,
+                                    end: left.end,
+                                },
+                                Range {
+                                    start: right.start + r_incr,
+                                    end: right.end,
+                                },
+                            );
+                        } else {
+                            let mut l_s_incr = incr; // left start increasement
+                            let mut l_e_incr = incr; // left end increasement
+                            let mut r_s_incr = incr; // right start increasement
+                            let mut r_e_incr = incr; // right end increasement
+                            if left.len() < incr * 2 {
+                                l_s_incr = left.len();
+                                l_e_incr = 0;
+                            }
+                            if right.len() < incr * 2 {
+                                r_s_incr = right.len();
+                                r_e_incr = 0;
+                            }
+
+                            if let DiffLines::Both(l, r) = &old_changes[i - 1] {
+                                changes[i - 1] = DiffLines::Both(
+                                    Range {
+                                        start: l.start,
+                                        end: l.end + l_s_incr,
+                                    },
+                                    Range {
+                                        start: r.start,
+                                        end: r.end + r_s_incr,
+                                    },
+                                );
+                            }
+                            changes[i] = DiffLines::Skip(
+                                Range {
+                                    start: left.start + l_s_incr,
+                                    end: left.end - l_e_incr,
+                                },
+                                Range {
+                                    start: right.start + r_s_incr,
+                                    end: right.end - r_e_incr,
+                                },
+                            );
+                            if let DiffLines::Both(l, r) = &old_changes[i + 1] {
+                                changes[i + 1] = DiffLines::Both(
+                                    Range {
+                                        start: l.start - l_e_incr,
+                                        end: l.end,
+                                    },
+                                    Range {
+                                        start: r.start - r_e_incr,
+                                        end: r.end,
                                     },
-                                    Target::Widget(tab_id),
                                 );
                             }
                         }
-                    }),
-                )
-            });
+                    }
+                }
+            }
+            let changes = changes
+                .iter()
+                .filter(|change| {
+                    if let DiffLines::Skip(left, right) = change {
+                        if left.is_empty() && right.is_empty() {
+                            return false;
+                        }
+                    }
+                    true
+                })
+                .cloned()
+                .collect_vec();
+            let _ = event_sink.submit_command(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::UpdateHistoryChanges {
+                    id,
+                    path,
+                    rev,
+                    history: "head".to_string(),
+                    changes: Arc::new(changes),
+                    diff_context_lines: self.diff_context_lines,
+                },
+                Target::Widget(tab_id),
+            );
         }
     }
 
@@ -192,12 +373,27 @@ impl DocumentHistory {
             let right_rope = doc.buffer().text().clone();
             let event_sink = doc.event_sink.clone();
             let tab_id = doc.tab_id;
+            let diff_context_lines = self.diff_context_lines;
             rayon::spawn(move || {
+                let context_lines = if diff_context_lines == -1 {
+                    // infinite context lines
+                    None
+                } else if diff_context_lines < 0 {
+                    // default context lines
+                    Some(DEFAULT_DIFF_CONTEXT_LINES)
+                } else {
+                    Some(diff_context_lines as usize)
+                };
                 if atomic_rev.load(atomic::Ordering::Acquire) != rev {
                     return;
                 }
-                let changes =
-                    rope_diff(left_rope, right_rope, rev, atomic_rev.clone());
+                let changes = rope_diff(
+                    left_rope,
+                    right_rope,
+                    rev,
+                    atomic_rev.clone(),
+                    context_lines,
+                );
                 if changes.is_none() {
                     return;
                 }
@@ -214,6 +410,7 @@ impl DocumentHistory {
                         rev,
                         history: "head".to_string(),
                         changes: Arc::new(changes),
+                        diff_context_lines,
                     },
                     Target::Widget(tab_id),
                 );
@@ -225,8 +422,17 @@ impl DocumentHistory {
         &self.changes
     }
 
-    pub fn update_changes(&mut self, changes: Arc<Vec<DiffLines>>) {
+    pub fn diff_context_lines(&self) -> i32 {
+        self.diff_context_lines
+    }
+
+    pub fn update_changes(
+        &mut self,
+        changes: Arc<Vec<DiffLines>>,
+        diff_context_lines: i32,
+    ) {
         self.changes = changes;
+        self.diff_context_lines = diff_context_lines;
     }
 
     pub fn update_styles(&mut self, styles: Arc<Spans<Style>>) {
@@ -247,9 +453,8 @@ impl DocumentHistory {
 
             let content = self.buffer.as_ref().unwrap().text().clone();
             rayon::spawn(move || {
-                if let Some(syntax) =
-                    Syntax::init(&path).map(|s| s.parse(0, content, None))
-                {
+                if let Ok(mut syntax) = Syntax::init(&path) {
+                    syntax.parse(0, content, None);
                     if let Some(styles) = syntax.styles {
                         let _ = event_sink.submit_command(
                             LAPCE_UI_COMMAND,
diff --git a/lapce-data/src/hover.rs b/lapce-data/src/hover.rs
index 2d6e556862..e12b2eb24c 100644
--- a/lapce-data/src/hover.rs
+++ b/lapce-data/src/hover.rs
@@ -1,19 +1,17 @@
 use std::{cell::RefCell, rc::Rc, sync::Arc};
 
-use druid::{ExtEventSink, FontStyle, FontWeight, Size, Target, WidgetId};
-use lapce_core::syntax::Syntax;
-use lapce_rpc::buffer::BufferId;
-use lsp_types::{Hover, HoverContents, MarkedString, MarkupKind, Position};
-use pulldown_cmark::Tag;
-use xi_rope::Rope;
+use druid::{ExtEventSink, Size, Target, WidgetId};
+use lapce_rpc::{buffer::BufferId, proxy::ProxyResponse};
+use lsp_types::{HoverContents, MarkedString, MarkupKind, Position};
 
 use crate::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::{Config, LapceTheme},
+    config::{LapceConfig, LapceTheme},
     data::EditorDiagnostic,
-    document::Document,
+    document::{BufferContent, Document},
+    markdown::{from_marked_string, parse_markdown, Content},
     proxy::LapceProxy,
-    rich_text::{AttributesAdder, RichText, RichTextBuilder},
+    rich_text::{RichText, RichTextBuilder},
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -41,13 +39,8 @@ pub struct HoverData {
     pub size: Size,
     /// Stores the actual size of the hover content
     pub content_size: Rc<RefCell<Size>>,
-
-    /// The current hover string that is active, because there can be multiple for a single entry
-    /// (such as if there is uncertainty over the exact version, such as in overloading or
-    /// scripting languages where the declaration is uncertain)
-    pub active_item_index: usize,
     /// The hover items that are currently loaded
-    pub items: Arc<Vec<RichText>>,
+    pub items: Arc<Vec<Content>>,
     /// The text for the diagnostic(s) at the position
     pub diagnostic_content: Option<RichText>,
 }
@@ -66,14 +59,17 @@ impl HoverData {
             size: Size::new(600.0, 300.0),
             content_size: Rc::new(RefCell::new(Size::ZERO)),
 
-            active_item_index: 0,
             items: Arc::new(Vec::new()),
             diagnostic_content: None,
         }
     }
 
-    pub fn get_current_item(&self) -> Option<&RichText> {
-        self.items.get(self.active_item_index)
+    pub fn get_current_items(&self) -> Option<&[Content]> {
+        if self.items.is_empty() {
+            None
+        } else {
+            Some(&self.items)
+        }
     }
 
     /// The length of the current hover items
@@ -85,21 +81,6 @@ impl HoverData {
         self.items.is_empty()
     }
 
-    /// Move to the next hover item
-    pub fn next(&mut self) {
-        // If there is an item after the current one, then actually change
-        if self.active_item_index + 1 < self.len() {
-            self.active_item_index += 1;
-        }
-    }
-
-    /// Move to the previous hover item
-    pub fn previous(&mut self) {
-        if self.active_item_index > 0 {
-            self.active_item_index -= 1;
-        }
-    }
-
     /// Cancel the current hover information, clearing out held data
     pub fn cancel(&mut self) {
         if self.status == HoverStatus::Inactive {
@@ -108,7 +89,6 @@ impl HoverData {
 
         self.status = HoverStatus::Inactive;
         Arc::make_mut(&mut self.items).clear();
-        self.active_item_index = 0;
     }
 
     /// Send a request to update the hover at the given position and file
@@ -122,39 +102,37 @@ impl HoverData {
         position: Position,
         hover_widget_id: WidgetId,
         event_sink: ExtEventSink,
-        config: Arc<Config>,
+        config: Arc<LapceConfig>,
     ) {
-        let buffer_id = doc.id();
-        let syntax = doc.syntax().cloned();
-
-        // Clone config for use inside the proxy callback
-        let p_config = config.clone();
-        // Get the information/documentation that should be shown on hover
-        proxy.get_hover(
-            request_id,
-            buffer_id,
-            position,
-            Box::new(move |result| {
-                if let Ok(resp) = result {
-                    if let Ok(resp) = serde_json::from_value::<Hover>(resp) {
-                        let items =
-                            parse_hover_resp(syntax.as_ref(), resp, &p_config);
+        if let BufferContent::File(path) = doc.content() {
+            // Clone config for use inside the proxy callback
+            let p_config = config.clone();
+            // Get the information/documentation that should be shown on hover
+            proxy.proxy_rpc.get_hover(
+                request_id,
+                path.clone(),
+                position,
+                Box::new(move |result| {
+                    if let Ok(ProxyResponse::HoverResponse { request_id, hover }) =
+                        result
+                    {
+                        let items = parse_hover_resp(hover, &p_config);
+                        let items = Arc::new(items);
 
                         let _ = event_sink.submit_command(
                             LAPCE_UI_COMMAND,
-                            LapceUICommand::UpdateHover(request_id, Arc::new(items)),
+                            LapceUICommand::UpdateHover { request_id, items },
                             Target::Widget(hover_widget_id),
                         );
                     }
-                }
-            }),
-        );
-
-        self.collect_diagnostics(position, diagnostics, config);
+                }),
+            );
+            self.collect_diagnostics(position, diagnostics, config);
+        }
     }
 
     /// Receive the result of a hover request
-    pub fn receive(&mut self, request_id: usize, items: Arc<Vec<RichText>>) {
+    pub fn receive(&mut self, request_id: usize, items: Arc<Vec<Content>>) {
         // If we've moved to inactive between the time the request started and now
         // or we've moved to a different request
         // then don't bother processing the received data
@@ -170,7 +148,7 @@ impl HoverData {
         &mut self,
         position: Position,
         diagnostics: Option<Arc<Vec<EditorDiagnostic>>>,
-        config: Arc<Config>,
+        config: Arc<LapceConfig>,
     ) {
         if let Some(diagnostics) = diagnostics {
             let diagnostics = diagnostics
@@ -187,6 +165,7 @@ impl HoverData {
 
             // Build up the text for all the diagnostics
             let mut content = RichTextBuilder::new();
+            content.set_line_height(1.5);
             for diagnostic in diagnostics {
                 content.push(&diagnostic.message);
 
@@ -240,234 +219,35 @@ impl Default for HoverData {
     }
 }
 
-fn parse_hover_markdown(
-    syntax: Option<&Syntax>,
-    text: &str,
-    config: &Config,
-) -> RichText {
-    use pulldown_cmark::{CowStr, Event, Options, Parser};
-
-    let mut builder = RichTextBuilder::new();
-    builder.set_line_height(1.5);
-
-    // Our position within the text
-    let mut pos = 0;
-
-    // TODO: (minor): This could use a smallvec since most tags are probably not that nested
-    // Stores the current tags (like italics/bold/strikethrough) so that they can be nested
-    let mut tag_stack = Vec::new();
-
-    let mut code_block_indices = Vec::new();
-
-    // Construct the markdown parser. We enable most of the options in order to provide the most
-    // compatibility that pulldown_cmark allows.
-    let parser = Parser::new_ext(
-        text,
-        Options::ENABLE_TABLES
-            | Options::ENABLE_FOOTNOTES
-            | Options::ENABLE_STRIKETHROUGH
-            | Options::ENABLE_TASKLISTS
-            | Options::ENABLE_HEADING_ATTRIBUTES,
-    );
-    let mut last_text = CowStr::from("");
-    for event in parser {
-        match event {
-            Event::Start(tag) => {
-                tag_stack.push((pos, tag));
-            }
-            Event::End(end_tag) => {
-                if let Some((start_offset, tag)) = tag_stack.pop() {
-                    if end_tag != tag {
-                        log::warn!("Mismatched markdown tag");
-                        continue;
-                    }
-
-                    if let Tag::CodeBlock(_kind) = &tag {
-                        code_block_indices.push(start_offset..pos);
-                    }
-
-                    add_attribute_for_tag(
-                        &tag,
-                        builder.add_attributes_for_range(start_offset..pos),
-                        config,
-                    );
-
-                    if let Tag::CodeBlock(_) = &tag {
-                        if let Some(syntax) = syntax {
-                            if let Some(styles) =
-                                syntax.parse(0, Rope::from(&last_text), None).styles
-                            {
-                                for (range, style) in styles.iter() {
-                                    if let Some(color) = style
-                                        .fg_color
-                                        .as_ref()
-                                        .and_then(|fg| config.get_style_color(fg))
-                                    {
-                                        builder
-                                            .add_attributes_for_range(
-                                                start_offset + range.start
-                                                    ..start_offset + range.end,
-                                            )
-                                            .text_color(color.clone());
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    if should_add_newline_after_tag(&tag) {
-                        builder.push("\n");
-                        pos += 1;
-                    }
-                } else {
-                    log::warn!("Unbalanced markdown tag")
-                }
-            }
-            Event::Text(text) => {
-                builder.push(&text);
-                pos += text.len();
-                last_text = text;
-            }
-            Event::Code(text) => {
-                builder.push(&text).font_family(config.editor.font_family());
-                code_block_indices.push(pos..(pos + text.len()));
-                pos += text.len();
-            }
-            // TODO: Some minimal 'parsing' of html could be useful here, since some things use
-            // basic html like `<code>text</code>`.
-            Event::Html(text) => {
-                builder
-                    .push(&text)
-                    .font_family(config.editor.font_family())
-                    .text_color(
-                        config
-                            .get_color_unchecked(LapceTheme::MARKDOWN_BLOCKQUOTE)
-                            .clone(),
-                    );
-                pos += text.len();
-            }
-            Event::HardBreak => {
-                builder.push("\n");
-                pos += 1;
-            }
-            Event::SoftBreak => {
-                builder.push(" ");
-                pos += 1;
-            }
-            Event::Rule => {}
-            Event::FootnoteReference(_text) => {}
-            Event::TaskListMarker(_text) => {}
-        }
-    }
-
-    builder.build()
-}
-
-fn from_marked_string(
-    syntax: Option<&Syntax>,
-    text: MarkedString,
-    config: &Config,
-) -> RichText {
-    match text {
-        MarkedString::String(text) => parse_hover_markdown(syntax, &text, config),
-        // This is a short version of a code block
-        MarkedString::LanguageString(code) => {
-            // TODO: We could simply construct the MarkdownText directly
-            // Simply construct the string as if it was written directly
-            parse_hover_markdown(
-                syntax,
-                &format!("```{}\n{}\n```", code.language, code.value),
-                config,
-            )
-        }
-    }
-}
-
-fn parse_hover_resp(
-    syntax: Option<&Syntax>,
-    hover: lsp_types::Hover,
-    config: &Config,
-) -> Vec<RichText> {
+fn parse_hover_resp(hover: lsp_types::Hover, config: &LapceConfig) -> Vec<Content> {
     match hover.contents {
         HoverContents::Scalar(text) => match text {
-            MarkedString::String(text) => {
-                vec![parse_hover_markdown(syntax, &text, config)]
-            }
-            MarkedString::LanguageString(code) => vec![parse_hover_markdown(
-                syntax,
+            MarkedString::String(text) => parse_markdown(&text, 1.5, config),
+            MarkedString::LanguageString(code) => parse_markdown(
                 &format!("```{}\n{}\n```", code.language, code.value),
+                1.5,
                 config,
-            )],
+            ),
         },
-        HoverContents::Array(array) => array
-            .into_iter()
-            .map(|t| from_marked_string(syntax, t, config))
-            .collect(),
+        HoverContents::Array(array) => {
+            let entries = array
+                .into_iter()
+                .map(|t| from_marked_string(t, config))
+                .rev();
+
+            // TODO: It'd be nice to avoid this vec
+            itertools::Itertools::intersperse(entries, vec![Content::Separator])
+                .flatten()
+                .collect()
+        }
         HoverContents::Markup(content) => match content.kind {
             MarkupKind::PlainText => {
                 let mut builder = RichTextBuilder::new();
                 builder.set_line_height(1.5);
                 builder.push(&content.value);
-                vec![builder.build()]
-            }
-            MarkupKind::Markdown => {
-                vec![parse_hover_markdown(syntax, &content.value, config)]
+                vec![Content::Text(builder.build())]
             }
+            MarkupKind::Markdown => parse_markdown(&content.value, 1.5, config),
         },
     }
 }
-
-fn add_attribute_for_tag(tag: &Tag, mut attrs: AttributesAdder, config: &Config) {
-    use pulldown_cmark::HeadingLevel;
-    match tag {
-        Tag::Heading(level, _, _) => {
-            // The size calculations are based on the em values given at
-            // https://drafts.csswg.org/css2/#html-stylesheet
-            let font_scale = match level {
-                HeadingLevel::H1 => 2.0,
-                HeadingLevel::H2 => 1.5,
-                HeadingLevel::H3 => 1.17,
-                HeadingLevel::H4 => 1.0,
-                HeadingLevel::H5 => 0.83,
-                HeadingLevel::H6 => 0.75,
-            };
-            let font_size = font_scale * config.ui.font_size() as f64;
-            attrs.size(font_size).weight(FontWeight::BOLD);
-        }
-        Tag::BlockQuote => {
-            attrs.style(FontStyle::Italic).text_color(
-                config
-                    .get_color_unchecked(LapceTheme::MARKDOWN_BLOCKQUOTE)
-                    .clone(),
-            );
-        }
-        // TODO: We could use the language paired with treesitter to highlight the code
-        // within code blocks.
-        Tag::CodeBlock(_) => {
-            attrs.font_family(config.editor.font_family());
-        }
-        Tag::Emphasis => {
-            attrs.style(FontStyle::Italic);
-        }
-        Tag::Strong => {
-            attrs.weight(FontWeight::BOLD);
-        }
-        // TODO: Strikethrough support
-        Tag::Link(_link_type, _target, _title) => {
-            // TODO: Link support
-            attrs.underline(true).text_color(
-                config.get_color_unchecked(LapceTheme::EDITOR_LINK).clone(),
-            );
-        }
-        // All other tags are currently ignored
-        _ => {}
-    }
-}
-
-/// Decides whether newlines should be added after a specific markdown tag
-fn should_add_newline_after_tag(tag: &Tag) -> bool {
-    !matches!(
-        tag,
-        Tag::Emphasis | Tag::Strong | Tag::Strikethrough | Tag::Link(..)
-    )
-}
diff --git a/lapce-data/src/images.rs b/lapce-data/src/images.rs
new file mode 100644
index 0000000000..e63eb916aa
--- /dev/null
+++ b/lapce-data/src/images.rs
@@ -0,0 +1,155 @@
+use std::sync::Arc;
+
+use druid::{piet::PietImage, ExtEventSink, Target};
+use lapce_core::directory::Directory;
+use sha2::{Digest, Sha256};
+use url::Url;
+
+use crate::command::{LapceUICommand, LAPCE_UI_COMMAND};
+
+#[derive(Clone)]
+pub enum Image {
+    Image(Arc<PietImage>),
+}
+impl std::fmt::Debug for Image {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Image::Image(_) => f.debug_tuple("Image").finish(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ImageStatus {
+    /// The image is being requested
+    Loading,
+    // TODO: Give this some error string to display? Maybe use thiserror or whatever?
+    /// There was some error in loading the image
+    Error,
+    /// The image has been loaded
+    Loaded(Image),
+}
+
+#[derive(Clone)]
+struct ImageCacheEntry {
+    /// The number of active entries for this image, used for reference counting
+    pub count: usize,
+    pub image: ImageStatus,
+}
+
+#[derive(Clone, Default)]
+pub struct ImageCache {
+    images: im::HashMap<Url, ImageCacheEntry>,
+}
+impl ImageCache {
+    /// Loads the given url, and submits the `ImageLoaded` event to the event sink when it's done.  
+    /// You can use [`ImageCache::get`] to get the image's status, and content once it is finished.
+    pub fn load_url_cmd(&mut self, url: Url, event_sink: ExtEventSink) {
+        self.load_url_cb(url.clone(), move |image| {
+            let _ = event_sink.submit_command(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::ImageLoaded { url, image },
+                Target::Auto,
+            );
+        });
+    }
+
+    fn load_url_cb(
+        &mut self,
+        url: Url,
+        cb: impl FnOnce(anyhow::Result<Image>) + Send + 'static,
+    ) {
+        let has_img = self.images.contains_key(&url);
+        let img =
+            self.images
+                .entry(url.clone())
+                .or_insert_with(|| ImageCacheEntry {
+                    count: 0,
+                    image: ImageStatus::Loading,
+                });
+        img.count += 1;
+
+        // If we've already started loading the image, then assume that we don't need to load it
+        // again. If this is incorrect, then that's a sign of some bug in the code which uses
+        // the cache. Either forgetting to call `load_finished` or accidentally unregistering
+        // an image too many times.
+        if has_img {
+            return;
+        }
+
+        std::thread::spawn(move || cb(get_image(url)));
+    }
+
+    pub fn load_finished(
+        &mut self,
+        url: &Url,
+        image: &Result<Image, anyhow::Error>,
+    ) {
+        let image = match image {
+            Ok(image) => ImageStatus::Loaded(image.clone()),
+            Err(_) => ImageStatus::Error,
+        };
+
+        if let Some(img) = self.images.get_mut(url) {
+            img.image = image;
+        } else {
+            log::warn!("Image loading for '{url}' finished, but it was not present in the cache.");
+            self.images
+                .insert(url.clone(), ImageCacheEntry { count: 1, image });
+        }
+    }
+
+    pub fn done_with_image(&mut self, url: &Url) {
+        if let Some(img) = self.images.get_mut(url) {
+            img.count = img.count.saturating_sub(1);
+        } else {
+            log::warn!("Image '{url}' was not present in the cache.");
+        }
+    }
+
+    pub fn get(&self, url: &Url) -> Option<&ImageStatus> {
+        self.images.get(url).map(|x| &x.image)
+    }
+}
+
+fn get_image(url: Url) -> Result<Image, anyhow::Error> {
+    // Load the image's raw bytes
+    let content = if url.scheme() == "file" {
+        // If it's a file, then we can just load it directly rather than
+        // storing it in a cache directory.
+        let path = url.to_file_path().unwrap();
+        std::fs::read(path)?
+    } else {
+        // Hash the url to get a safe and basically-unique filename
+        let cache_file_path = Directory::cache_directory().map(|cache_dir| {
+            let mut hasher = Sha256::new();
+            hasher.update(url.as_str().as_bytes());
+            let filename = format!("{:x}", hasher.finalize());
+            cache_dir.join(filename)
+        });
+
+        let cache_content =
+            cache_file_path.as_ref().and_then(|p| std::fs::read(p).ok());
+
+        match cache_content {
+            Some(content) => content,
+            None => {
+                let resp = reqwest::blocking::get(url.clone())?;
+                if !resp.status().is_success() {
+                    return Err(anyhow::anyhow!("can't download icon"));
+                }
+                let buf = resp.bytes()?.to_vec();
+
+                if let Some(path) = cache_file_path.as_ref() {
+                    let _ = std::fs::write(path, &buf);
+                }
+
+                buf
+            }
+        }
+    };
+
+    let image = PietImage::from_bytes(&content)
+        .map_err(|_| anyhow::anyhow!("can't resolve image from '{url}'"))?;
+    Ok(Image::Image(Arc::new(image)))
+}
diff --git a/lapce-data/src/keypress/keypress.rs b/lapce-data/src/keypress/keypress.rs
index 51c3056f45..0cff096544 100644
--- a/lapce-data/src/keypress/keypress.rs
+++ b/lapce-data/src/keypress/keypress.rs
@@ -1,4 +1,8 @@
-use std::fmt::Display;
+use std::{
+    fmt::Display,
+    hash::{Hash, Hasher},
+    str::FromStr,
+};
 
 use druid::{
     piet::{PietTextLayout, Text, TextLayout, TextLayoutBuilder},
@@ -6,51 +10,76 @@ use druid::{
 };
 
 use crate::{
-    config::{Config, LapceTheme},
+    config::{LapceConfig, LapceTheme},
     keypress::paint_key,
 };
 
+use super::KeyPressData;
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct KeyPress {
-    pub key: druid::KbKey,
-    pub mods: Modifiers,
+    pub(super) key: Key,
+    pub(super) mods: Modifiers,
 }
 
-impl Display for KeyPress {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.mods.ctrl() {
-            let _ = f.write_str("Ctrl+");
-        }
-        if self.mods.alt() {
-            let _ = f.write_str("Alt+");
-        }
-        if self.mods.meta() {
-            let _ = f.write_str("Meta+");
+impl KeyPress {
+    pub fn keyboard(ev: &druid::KeyEvent) -> Option<KeyPress> {
+        use druid::KbKey as K;
+
+        match ev.key {
+            K::Shift | K::Meta | K::Super | K::Alt | K::Control => None,
+            ref key => Some(Self {
+                key: Key::Keyboard(match key {
+                    K::Character(c) => K::Character(c.to_lowercase()),
+                    key => key.clone(),
+                }),
+                mods: KeyPressData::get_key_modifiers(ev),
+            }),
         }
-        if self.mods.shift() {
-            let _ = f.write_str("Shift+");
+    }
+
+    pub fn mouse(ev: &druid::MouseEvent) -> KeyPress {
+        Self {
+            key: Key::Mouse(ev.button),
+            mods: ev.mods,
         }
-        f.write_str(&self.key.to_string())
     }
-}
 
-impl KeyPress {
+    pub fn hotkey(&self) -> Option<druid::HotKey> {
+        self.key
+            .as_keyboard()
+            .map(|k| druid::HotKey::new(self.mods, k.clone()))
+    }
+
     pub fn is_char(&self) -> bool {
         let mut mods = self.mods;
         mods.set(Modifiers::SHIFT, false);
         if mods.is_empty() {
-            if let druid::KbKey::Character(_c) = &self.key {
+            if let Key::Keyboard(druid::KbKey::Character(_c)) = &self.key {
                 return true;
             }
         }
         false
     }
 
+    pub fn to_lowercase(&self) -> Self {
+        let key = match &self.key {
+            Key::Keyboard(druid::KbKey::Character(c)) => {
+                Key::Keyboard(druid::KbKey::Character(c.to_lowercase()))
+            }
+            _ => self.key.clone(),
+        };
+        Self {
+            key,
+            mods: self.mods,
+        }
+    }
+
     pub fn paint(
         &self,
         ctx: &mut PaintCtx,
         origin: Point,
-        config: &Config,
+        config: &LapceConfig,
     ) -> (Point, Vec<(Option<Rect>, PietTextLayout, Point)>) {
         let mut origin = origin;
         let mut keys = Vec::new();
@@ -71,20 +100,7 @@ impl KeyPress {
         if self.mods.shift() {
             keys.push("Shift".to_string());
         }
-        match &self.key {
-            druid::keyboard_types::Key::Character(c) => {
-                if *c == c.to_uppercase()
-                    && c.to_lowercase() != c.to_uppercase()
-                    && !self.mods.shift()
-                {
-                    keys.push("Shift".to_string());
-                }
-                keys.push(c.to_uppercase());
-            }
-            _ => {
-                keys.push(self.key.to_string());
-            }
-        }
+        keys.push(self.key.to_string());
 
         let mut items = Vec::new();
         let keys_len = keys.len();
@@ -125,7 +141,7 @@ impl KeyPress {
                     None => ("", k),
                 };
 
-                let key = match Self::map_str_to_key(key) {
+                let key = match key.parse().ok() {
                     Some(key) => key,
                     None => {
                         // Skip past unrecognized key definitions
@@ -146,14 +162,45 @@ impl KeyPress {
                     }
                 }
 
-                Some(KeyPress { mods, key })
+                Some(KeyPress { key, mods })
             })
             .collect()
     }
+}
 
-    /// Convert a piece of text representing a key in a keymaps file to the actual key
-    /// Returns `None` if it was not able to find a key with that name
-    fn map_str_to_key(key_part: &str) -> Option<druid::KbKey> {
+impl Display for KeyPress {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.mods.ctrl() {
+            let _ = f.write_str("Ctrl+");
+        }
+        if self.mods.alt() {
+            let _ = f.write_str("Alt+");
+        }
+        if self.mods.meta() {
+            let _ = f.write_str("Meta+");
+        }
+        if self.mods.shift() {
+            let _ = f.write_str("Shift+");
+        }
+        f.write_str(&self.key.to_string())
+    }
+}
+
+#[derive(Clone, Debug, Eq)]
+pub(super) enum Key {
+    Keyboard(druid::KbKey),
+    Mouse(druid::MouseButton),
+}
+
+impl Key {
+    pub(super) fn as_keyboard(&self) -> Option<&'_ druid::KbKey> {
+        match self {
+            Self::Keyboard(key) => Some(key),
+            Self::Mouse(_) => None,
+        }
+    }
+
+    fn keyboard_from_str(s: &str) -> Option<druid::KbKey> {
         // Checks if it is a character key
         fn is_key_string(s: &str) -> bool {
             s.chars().all(|c| !c.is_control())
@@ -162,8 +209,8 @@ impl KeyPress {
 
         // Import into scope to reduce noise
         use druid::keyboard_types::Key::*;
-        Some(match key_part.to_lowercase().as_str() {
-            s if is_key_string(s) => Character(key_part.to_string()),
+        Some(match s {
+            s if is_key_string(s) => Character(s.to_string()),
             "unidentified" => Unidentified,
             "alt" => Alt,
             "altgraph" => AltGraph,
@@ -462,4 +509,63 @@ impl KeyPress {
             _ => return None,
         })
     }
+
+    fn mouse_from_str(s: &str) -> Option<druid::MouseButton> {
+        use druid::MouseButton as B;
+
+        Some(match s {
+            "mousemiddle" => B::Middle,
+            "mouseforward" => B::X2,
+            "mousebackward" => B::X1,
+            _ => return None,
+        })
+    }
+}
+
+impl Display for Key {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use druid::MouseButton as B;
+
+        match self {
+            Self::Keyboard(key) => return key.fmt(f),
+            Self::Mouse(B::Middle) => "MouseMiddle",
+            Self::Mouse(B::X2) => "MouseForward",
+            Self::Mouse(B::X1) => "MouseBackward",
+            Self::Mouse(_) => "MouseUnimplemented",
+        }
+        .fmt(f)
+    }
+}
+
+impl FromStr for Key {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_lowercase();
+
+        Key::keyboard_from_str(&s)
+            .map(Key::Keyboard)
+            .or_else(|| Key::mouse_from_str(&s).map(Key::Mouse))
+            .ok_or(())
+    }
+}
+
+impl Hash for Key {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        match self {
+            Self::Keyboard(key) => key.hash(state),
+            // TODO: Implement `Hash` for `druid::MouseButton`
+            Self::Mouse(btn) => (*btn as u8).hash(state),
+        }
+    }
+}
+
+impl PartialEq for Key {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Key::Keyboard(a), Key::Keyboard(b)) => a.eq(b),
+            (Key::Mouse(a), Key::Mouse(b)) => a.eq(b),
+            _ => false,
+        }
+    }
 }
diff --git a/lapce-data/src/keypress/loader.rs b/lapce-data/src/keypress/loader.rs
index 7a58d074fa..93464db2fe 100644
--- a/lapce-data/src/keypress/loader.rs
+++ b/lapce-data/src/keypress/loader.rs
@@ -22,10 +22,10 @@ impl KeyMapLoader {
         s: &str,
         modal: bool,
     ) -> Result<&'a mut Self> {
-        let toml_keymaps: toml::Value = toml::from_str(s)?;
+        let toml_keymaps: toml_edit::Document = s.parse()?;
         let toml_keymaps = toml_keymaps
             .get("keymaps")
-            .and_then(|v| v.as_array())
+            .and_then(|v| v.as_array_of_tables())
             .ok_or_else(|| anyhow!("no keymaps"))?;
 
         for toml_keymap in toml_keymaps {
@@ -90,7 +90,10 @@ impl KeyMapLoader {
         (map, command_map)
     }
 
-    fn get_keymap(toml_keymap: &toml::Value, modal: bool) -> Result<Option<KeyMap>> {
+    fn get_keymap(
+        toml_keymap: &toml_edit::Table,
+        modal: bool,
+    ) -> Result<Option<KeyMap>> {
         let key = toml_keymap
             .get("key")
             .and_then(|v| v.as_str())
@@ -98,7 +101,11 @@ impl KeyMapLoader {
 
         let modes = get_modes(toml_keymap);
         // If not using modal editing, remove keymaps that only make sense in modal.
-        if !modal && !modes.is_empty() && !modes.contains(Modes::INSERT) {
+        if !modal
+            && !modes.is_empty()
+            && !modes.contains(Modes::INSERT)
+            && !modes.contains(Modes::TERMINAL)
+        {
             log::debug!("Keymap ignored: {}", key);
             return Ok(None);
         }
@@ -126,14 +133,47 @@ mod tests {
     #[test]
     fn test_keymap() {
         let keymaps = r###"
-keymaps = [
-    { key = "ctrl+w l l", command = "right", when = "n" },
-    { key = "ctrl+w l", command = "right", when = "n" },
-    { key = "ctrl+w h", command = "left", when = "n" },
-    { key = "ctrl+w",   command = "left", when = "n" },
-    { key = "End", command = "line_end", when = "n" },
-    { key = "I", command = "insert_first_non_blank", when = "n" },
-]
+[[keymaps]]
+key = "ctrl+w l l"
+command = "right"
+when = "n"
+
+[[keymaps]]
+key = "ctrl+w l"
+command = "right"
+when = "n"
+
+[[keymaps]]
+key = "ctrl+w h"
+command = "left"
+when = "n"
+
+[[keymaps]]
+key = "ctrl+w"
+command = "left"
+when = "n"
+
+[[keymaps]]
+key = "End"
+command = "line_end"
+when = "n"
+
+[[keymaps]]
+key = "shift+i"
+command = "insert_first_non_blank"
+when = "n"
+        
+[[keymaps]]
+key = "MouseForward"
+command = "jump_location_forward"
+
+[[keymaps]]
+key = "MouseBackward"
+command = "jump_location_backward"
+        
+[[keymaps]]
+key = "Ctrl+MouseMiddle"
+command = "goto_definition"
         "###;
         let mut loader = KeyMapLoader::new();
         loader.load_from_str(keymaps, true).unwrap();
@@ -173,7 +213,17 @@ keymaps = [
         assert_eq!(keymaps.get(&keypress).unwrap().len(), 1);
 
         // No modifier
-        let keypress = KeyPress::parse("I");
+        let keypress = KeyPress::parse("shift+i");
+        assert_eq!(keymaps.get(&keypress).unwrap().len(), 1);
+
+        // Mouse keys
+        let keypress = KeyPress::parse("MouseForward");
+        assert_eq!(keymaps.get(&keypress).unwrap().len(), 1);
+
+        let keypress = KeyPress::parse("mousebackward");
+        assert_eq!(keymaps.get(&keypress).unwrap().len(), 1);
+
+        let keypress = KeyPress::parse("Ctrl+MouseMiddle");
         assert_eq!(keymaps.get(&keypress).unwrap().len(), 1);
     }
 }
diff --git a/lapce-data/src/keypress/mod.rs b/lapce-data/src/keypress/mod.rs
index 1d064ce80a..fe52edcb87 100644
--- a/lapce-data/src/keypress/mod.rs
+++ b/lapce-data/src/keypress/mod.rs
@@ -1,34 +1,34 @@
 #![allow(clippy::module_inception)]
 
-use std::path::PathBuf;
-use std::sync::Arc;
+use std::{path::PathBuf, sync::Arc};
 
 use anyhow::Result;
-use druid::piet::{PietTextLayout, Text, TextLayout, TextLayoutBuilder};
-use druid::{Command, KbKey};
 use druid::{
-    Env, EventCtx, ExtEventSink, KeyEvent, Modifiers, PaintCtx, Point, Rect,
-    RenderContext, Size, Target,
+    piet::{PietTextLayout, Text, TextLayout, TextLayoutBuilder},
+    Command, Env, EventCtx, ExtEventSink, KbKey, KeyEvent, Modifiers, PaintCtx,
+    Point, Rect, RenderContext, Size, Target,
 };
-use fuzzy_matcher::skim::SkimMatcherV2;
-use fuzzy_matcher::FuzzyMatcher;
+use fuzzy_matcher::{skim::SkimMatcherV2, FuzzyMatcher};
 use indexmap::IndexMap;
 use itertools::Itertools;
 use lapce_core::mode::{Mode, Modes};
-use toml;
 
 mod keypress;
 mod loader;
 
-use crate::command::{
-    lapce_internal_commands, CommandExecuted, CommandKind, LapceCommand,
-    LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
-};
-use crate::config::{Config, LapceTheme};
-use crate::keypress::loader::KeyMapLoader;
-
 pub use keypress::KeyPress;
 
+use keypress::Key;
+
+use crate::{
+    command::{
+        lapce_internal_commands, CommandExecuted, CommandKind, LapceCommand,
+        LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
+    },
+    config::{LapceConfig, LapceTheme},
+    keypress::loader::KeyMapLoader,
+};
+
 const DEFAULT_KEYMAPS_COMMON: &str =
     include_str!("../../../defaults/keymaps-common.toml");
 const DEFAULT_KEYMAPS_MACOS: &str =
@@ -48,7 +48,7 @@ pub fn paint_key(
     ctx: &mut PaintCtx,
     text: &str,
     origin: Point,
-    config: &Config,
+    config: &LapceConfig,
 ) -> (Rect, PietTextLayout, Point) {
     let text_layout = ctx
         .text()
@@ -62,7 +62,7 @@ pub fn paint_key(
         .build()
         .unwrap();
     let text_size = text_layout.size();
-    let text_layout_point = origin + (5.0, -(text_size.height / 2.0));
+    let text_layout_point = origin + (5.0, -text_layout.cap_center());
     let rect = Size::new(text_size.width, 0.0)
         .to_rect()
         .with_origin(origin + (5.0, 0.0))
@@ -85,12 +85,18 @@ pub enum Alignment {
 }
 
 impl KeyMap {
+    /// Returns the first [`KeyPress`] of this [`KeyMap`] that can be converted into
+    /// [`druid::HotKey`].
+    pub fn hotkey(&self) -> Option<druid::HotKey> {
+        self.key.iter().find_map(KeyPress::hotkey)
+    }
+
     pub fn paint(
         &self,
         ctx: &mut PaintCtx,
         origin: Point,
         align: Alignment,
-        config: &Config,
+        config: &LapceConfig,
     ) {
         let old_origin = origin;
 
@@ -105,7 +111,7 @@ impl KeyMap {
         let x_shift = match align {
             Alignment::Left => 0.0,
             Alignment::Center => (origin.x - old_origin.x) / 2.0,
-            Alignment::Right => (origin.x - old_origin.x),
+            Alignment::Right => origin.x - old_origin.x,
         };
 
         for (rect, text_layout, text_layout_pos) in items {
@@ -143,6 +149,24 @@ pub trait KeyPressFocus {
     fn receive_char(&mut self, ctx: &mut EventCtx, c: &str);
 }
 
+#[derive(Clone, Copy, Debug)]
+pub enum EventRef<'a> {
+    Keyboard(&'a druid::KeyEvent),
+    Mouse(&'a druid::MouseEvent),
+}
+
+impl<'a> From<&'a druid::KeyEvent> for EventRef<'a> {
+    fn from(ev: &'a druid::KeyEvent) -> Self {
+        Self::Keyboard(ev)
+    }
+}
+
+impl<'a> From<&'a druid::MouseEvent> for EventRef<'a> {
+    fn from(ev: &'a druid::MouseEvent) -> Self {
+        Self::Mouse(ev)
+    }
+}
+
 #[derive(Clone)]
 pub struct KeyPressData {
     pending_keypress: Vec<KeyPress>,
@@ -162,7 +186,7 @@ pub struct KeyPressData {
 }
 
 impl KeyPressData {
-    pub fn new(config: &Config, event_sink: ExtEventSink) -> Self {
+    pub fn new(config: &LapceConfig, event_sink: ExtEventSink) -> Self {
         let (keymaps, command_keymaps) =
             Self::get_keymaps(config).unwrap_or((IndexMap::new(), IndexMap::new()));
         let mut keypress = Self {
@@ -182,7 +206,7 @@ impl KeyPressData {
         keypress
     }
 
-    pub fn update_keymaps(&mut self, config: &Config) {
+    pub fn update_keymaps(&mut self, config: &LapceConfig) {
         if let Ok((new_keymaps, new_command_keymaps)) = Self::get_keymaps(config) {
             self.keymaps = Arc::new(new_keymaps);
             self.command_keymaps = Arc::new(new_command_keymaps);
@@ -265,7 +289,7 @@ impl KeyPressData {
             return false;
         }
 
-        if let druid::KbKey::Character(c) = &keypress.key {
+        if let Key::Keyboard(druid::KbKey::Character(c)) = &keypress.key {
             if let Ok(n) = c.parse::<usize>() {
                 if self.count.is_some() || n > 0 {
                     self.count = Some(self.count.unwrap_or(0) * 10 + n);
@@ -279,14 +303,20 @@ impl KeyPressData {
 
     fn get_key_modifiers(key_event: &KeyEvent) -> Modifiers {
         // We only care about some modifiers
-        let mut mods = (Modifiers::ALT
+        let mods = (Modifiers::ALT
             | Modifiers::CONTROL
             | Modifiers::SHIFT
             | Modifiers::META)
             & key_event.mods;
 
-        if matches!(key_event.key, KbKey::Shift | KbKey::Character(_)) {
-            mods.set(Modifiers::SHIFT, false);
+        if mods == Modifiers::SHIFT {
+            if let druid::KbKey::Character(c) = &key_event.key {
+                if !c.chars().all(|c| c.is_alphabetic()) {
+                    // We remove the shift if there's only shift pressed,
+                    // and the character isn't a letter
+                    return Modifiers::empty();
+                }
+            }
         }
 
         mods
@@ -300,32 +330,44 @@ impl KeyPressData {
             | KbKey::Alt
             | KbKey::Control => None,
             ref key => Some(KeyPress {
-                key: key.clone(),
+                key: Key::Keyboard(match key {
+                    druid::KbKey::Character(c) => {
+                        druid::KbKey::Character(c.to_lowercase())
+                    }
+                    key => key.clone(),
+                }),
                 mods: Self::get_key_modifiers(key_event),
             }),
         }
     }
 
-    pub fn key_down<T: KeyPressFocus>(
+    pub fn key_down<'a, T: KeyPressFocus>(
         &mut self,
         ctx: &mut EventCtx,
-        key_event: &KeyEvent,
+        event: impl Into<EventRef<'a>>,
         focus: &mut T,
         env: &Env,
     ) -> bool {
-        log::info!("Keypress: {key_event:?}");
-
-        // We are removing Shift modifier since the character is already upper case.
-        let mods = Self::get_key_modifiers(key_event);
-
-        if key_event.key == KbKey::Shift && mods.is_empty() {
-            return false;
-        }
+        let event = event.into();
+        log::info!(target: "lapce_data::keypress::key_down", "{event:?}");
 
-        let keypress = KeyPress {
-            key: key_event.key.clone(),
-            mods,
+        let keypress = match event {
+            EventRef::Keyboard(ev)
+                if ev.key == KbKey::Shift && ev.mods.is_empty() =>
+            {
+                return false;
+            }
+            EventRef::Keyboard(ev) => KeyPress {
+                key: Key::Keyboard(ev.key.clone()),
+                // We are removing Shift modifier since the character is already upper case.
+                mods: Self::get_key_modifiers(ev),
+            },
+            EventRef::Mouse(ev) => KeyPress {
+                key: Key::Mouse(ev.button),
+                mods: ev.mods,
+            },
         };
+        let mods = keypress.mods;
 
         let mode = focus.get_mode();
         if self.handle_count(focus, &keypress) {
@@ -388,12 +430,22 @@ impl KeyPressData {
 
         self.count = None;
 
-        if keypress.mods.is_empty() {
-            if let druid::KbKey::Character(c) = &key_event.key {
+        #[cfg(not(target_os = "macos"))]
+        if (keypress.mods - Modifiers::SHIFT).is_empty() {
+            if let Key::Keyboard(druid::KbKey::Character(c)) = &keypress.key {
+                focus.receive_char(ctx, c);
+                return true;
+            }
+        }
+
+        #[cfg(target_os = "macos")]
+        if (keypress.mods - (Modifiers::SHIFT | Modifiers::ALT)).is_empty() {
+            if let Key::Keyboard(druid::KbKey::Character(c)) = &keypress.key {
                 focus.receive_char(ctx, c);
                 return true;
             }
         }
+
         false
     }
 
@@ -402,9 +454,11 @@ impl KeyPressData {
         keypresses: &[KeyPress],
         check: &T,
     ) -> KeymapMatch {
+        let keypresses: Vec<KeyPress> =
+            keypresses.iter().map(KeyPress::to_lowercase).collect();
         let matches = self
             .keymaps
-            .get(keypresses)
+            .get(&keypresses)
             .map(|keymaps| {
                 keymaps
                     .iter()
@@ -476,12 +530,15 @@ impl KeyPressData {
         }
     }
 
-    fn get_file_array() -> Option<toml::value::Array> {
+    fn get_file_array() -> Option<toml_edit::ArrayOfTables> {
         let path = Self::file()?;
-        let content = std::fs::read(&path).ok()?;
-        let toml_value: toml::Value = toml::from_slice(&content).ok()?;
-        let table = toml_value.as_table()?;
-        table.get("keymaps")?.as_array().cloned()
+        let content = std::fs::read_to_string(path).ok()?;
+        let document: toml_edit::Document = content.parse().ok()?;
+        document
+            .as_table()
+            .get("keymaps")?
+            .as_array_of_tables()
+            .cloned()
     }
 
     pub fn filter_commands(&mut self, pattern: &str) {
@@ -521,11 +578,11 @@ impl KeyPressData {
 
             let _ = event_sink.submit_command(
                 LAPCE_UI_COMMAND,
-                LapceUICommand::FilterKeymaps(
+                LapceUICommand::FilterKeymaps {
                     pattern,
-                    Arc::new(filtered_commands_with_keymap),
-                    Arc::new(filtered_commands_without_keymap),
-                ),
+                    keymaps: Arc::new(filtered_commands_with_keymap),
+                    commands: Arc::new(filtered_commands_without_keymap),
+                },
                 Target::Auto,
             );
         });
@@ -533,7 +590,7 @@ impl KeyPressData {
 
     pub fn update_file(keymap: &KeyMap, keys: &[KeyPress]) -> Option<()> {
         let mut array = Self::get_file_array().unwrap_or_default();
-        if let Some(index) = array.iter().position(|value| {
+        let index = array.iter().position(|value| {
             Some(keymap.command.as_str())
                 == value.get("command").and_then(|c| c.as_str())
                 && keymap.when.as_deref()
@@ -544,103 +601,87 @@ impl KeyPressData {
                         .get("key")
                         .and_then(|v| v.as_str())
                         .map(KeyPress::parse)
-        }) {
+        });
+
+        if let Some(index) = index {
             if !keys.is_empty() {
-                array[index].as_table_mut()?.insert(
-                    "key".to_string(),
-                    toml::Value::String(
+                array.get_mut(index)?.insert(
+                    "key",
+                    toml_edit::value(toml_edit::Value::from(
                         keys.iter().map(|k| k.to_string()).join(" "),
-                    ),
+                    )),
                 );
             } else {
                 array.remove(index);
             };
         } else {
-            let mut table = toml::value::Table::new();
+            let mut table = toml_edit::Table::new();
             table.insert(
-                "command".to_string(),
-                toml::Value::String(keymap.command.clone()),
+                "command",
+                toml_edit::value(toml_edit::Value::from(keymap.command.clone())),
             );
             if !keymap.modes.is_empty() {
                 table.insert(
-                    "mode".to_string(),
-                    toml::Value::String(keymap.modes.to_string()),
+                    "mode",
+                    toml_edit::value(toml_edit::Value::from(
+                        keymap.modes.to_string(),
+                    )),
                 );
             }
             if let Some(when) = keymap.when.as_ref() {
                 table.insert(
-                    "when".to_string(),
-                    toml::Value::String(when.to_string()),
+                    "when",
+                    toml_edit::value(toml_edit::Value::from(when.to_string())),
                 );
             }
 
             if !keys.is_empty() {
                 table.insert(
-                    "key".to_string(),
-                    toml::Value::String(
+                    "key",
+                    toml_edit::value(toml_edit::Value::from(
                         keys.iter().map(|k| k.to_string()).join(" "),
-                    ),
+                    )),
                 );
-                array.push(toml::Value::Table(table.clone()));
+                array.push(table.clone());
             }
 
             if !keymap.key.is_empty() {
                 table.insert(
-                    "key".to_string(),
-                    toml::Value::String(
+                    "key",
+                    toml_edit::value(toml_edit::Value::from(
                         keymap.key.iter().map(|k| k.to_string()).join(" "),
-                    ),
+                    )),
                 );
                 table.insert(
-                    "command".to_string(),
-                    toml::Value::String(format!("-{}", keymap.command)),
+                    "command",
+                    toml_edit::value(toml_edit::Value::from(format!(
+                        "-{}",
+                        keymap.command
+                    ))),
                 );
-                array.push(toml::Value::Table(table.clone()));
+                array.push(table.clone());
             }
         }
 
-        let mut table = toml::value::Table::new();
-        table.insert("keymaps".to_string(), toml::Value::Array(array));
-        let value = toml::Value::Table(table);
-
+        let mut table = toml_edit::Document::new();
+        table.insert("keymaps", toml_edit::Item::ArrayOfTables(array));
         let path = Self::file()?;
-        std::fs::write(&path, toml::to_string(&value).ok()?.as_bytes()).ok()?;
+        std::fs::write(path, table.to_string().as_bytes()).ok()?;
         None
     }
 
     pub fn file() -> Option<PathBuf> {
-        let path = Config::dir().map(|d| {
-            d.join(if !cfg!(debug_assertions) {
-                "keymaps.toml"
-            } else {
-                "debug-keymaps.toml"
-            })
-        })?;
-
-        if let Some(dir) = path.parent() {
-            if !dir.exists() {
-                let _ = std::fs::create_dir_all(dir);
-            }
-        }
-
-        if !path.exists() {
-            let _ = std::fs::OpenOptions::new()
-                .create_new(true)
-                .write(true)
-                .open(&path);
-        }
-
-        Some(path)
+        LapceConfig::keymaps_file()
     }
 
     #[allow(clippy::type_complexity)]
     fn get_keymaps(
-        config: &Config,
+        config: &LapceConfig,
     ) -> Result<(
         IndexMap<Vec<KeyPress>, Vec<KeyMap>>,
         IndexMap<String, Vec<KeyMap>>,
     )> {
-        let is_modal = config.lapce.modal;
+        let is_modal = config.core.modal;
 
         let mut loader = KeyMapLoader::new();
 
@@ -695,7 +736,7 @@ impl KeyPressFocus for DefaultKeyPressHandler {
     fn receive_char(&mut self, _ctx: &mut EventCtx, _c: &str) {}
 }
 
-fn get_modes(toml_keymap: &toml::Value) -> Modes {
+fn get_modes(toml_keymap: &toml_edit::Table) -> Modes {
     toml_keymap
         .get("mode")
         .and_then(|v| v.as_str())
@@ -736,9 +777,10 @@ impl<'a> Condition<'a> {
 
 #[cfg(test)]
 mod test {
-    use crate::keypress::{Condition, KeyPressData, KeyPressFocus};
     use lapce_core::mode::Mode;
 
+    use crate::keypress::{Condition, KeyPressData, KeyPressFocus};
+
     struct MockFocus {
         accepted_conditions: &'static [&'static str],
     }
diff --git a/lapce-data/src/lib.rs b/lapce-data/src/lib.rs
index e693596342..a5754e76e9 100644
--- a/lapce-data/src/lib.rs
+++ b/lapce-data/src/lib.rs
@@ -1,4 +1,8 @@
+#![allow(clippy::manual_clamp)]
+
+pub mod about;
 pub mod alert;
+pub mod atomic_soft_tabs;
 pub mod command;
 pub mod completion;
 pub mod config;
@@ -6,12 +10,16 @@ pub mod container;
 pub mod data;
 pub mod db;
 pub mod document;
+pub mod dropdown;
 pub mod editor;
 pub mod explorer;
 pub mod find;
 pub mod history;
 pub mod hover;
+pub mod images;
 pub mod keypress;
+pub mod list;
+pub mod markdown;
 pub mod menu;
 pub mod palette;
 pub mod panel;
@@ -19,10 +27,15 @@ pub mod picker;
 pub mod plugin;
 pub mod problem;
 pub mod proxy;
+pub mod rename;
 pub mod rich_text;
 pub mod search;
+pub mod selection_range;
 pub mod settings;
 pub mod signature;
 pub mod source_control;
 pub mod split;
+mod svg;
 pub mod terminal;
+pub mod title;
+pub mod update;
diff --git a/lapce-data/src/list.rs b/lapce-data/src/list.rs
new file mode 100644
index 0000000000..3cfb62c66b
--- /dev/null
+++ b/lapce-data/src/list.rs
@@ -0,0 +1,203 @@
+use std::sync::Arc;
+
+use druid::{Command, Data, EventCtx, Target, WidgetId};
+use lapce_core::{command::FocusCommand, movement::Movement};
+
+use crate::{
+    command::{
+        CommandExecuted, CommandKind, LapceCommand, LapceUICommand, LAPCE_UI_COMMAND,
+    },
+    config::{GetConfig, LapceConfig},
+};
+
+// Note: when adding fields to this, make sure to think whether they need to be added to the `same`
+// implementation
+/// Note: all `T` are going to be required by the UI code to implement `ListPaint<D>`  
+#[derive(Clone)]
+pub struct ListData<T: Clone, D: Data> {
+    /// The id of the widget that contains the [`ListData`] which wishes to receive
+    /// events (such as when an entry is selected)
+    pub parent: WidgetId,
+
+    /// The items that can be selected from the list  
+    /// Note that since this is an `im::Vector`, cloning is cheap.  
+    pub items: im::Vector<T>,
+    /// Extra data attached to the list for the item rendering to use.
+    pub data: D,
+
+    /// The index of the item which is selected
+    pub selected_index: usize,
+
+    /// The maximum number of items to render in the list.
+    pub max_displayed_items: usize,
+
+    /// The line height of each list element  
+    /// Defaults to the editor line height if not set
+    pub line_height: Option<usize>,
+
+    // These should be filled whenever you call into the `List` widget
+    pub config: Arc<LapceConfig>,
+}
+impl<T: Clone, D: Data> ListData<T, D> {
+    pub fn new(
+        config: Arc<LapceConfig>,
+        parent: WidgetId,
+        held_data: D,
+    ) -> ListData<T, D> {
+        ListData {
+            parent,
+            items: im::Vector::new(),
+            data: held_data,
+            selected_index: 0,
+            max_displayed_items: 15,
+            line_height: None,
+            config,
+        }
+    }
+
+    /// Clone the list data, giving it data needed to update it  
+    /// This is typically what you need to use to ensure that it has the
+    /// appropriately updated data when passing the data to the list's widget functions    
+    /// Note that due to the usage of `Arc` and `im::Vector`, cloning is relatively cheap.
+    pub fn clone_with(&self, config: Arc<LapceConfig>) -> ListData<T, D> {
+        let mut data = self.clone();
+        data.update_data(config);
+
+        data
+    }
+
+    pub fn update_data(&mut self, config: Arc<LapceConfig>) {
+        self.config = config;
+    }
+
+    pub fn line_height(&self) -> usize {
+        self.line_height
+            .unwrap_or_else(|| self.config.ui.list_line_height())
+    }
+
+    /// The maximum number of items in the list that can be displayed  
+    /// This is limited by `max_displayed_items` *or* by the number of items
+    pub fn max_display_count(&self) -> usize {
+        let mut count = 0;
+        for _ in self.items.iter() {
+            count += 1;
+            if count >= self.max_displayed_items {
+                return self.max_displayed_items;
+            }
+        }
+
+        count
+    }
+
+    pub fn clear_items(&mut self) {
+        self.items.clear();
+        self.selected_index = 0;
+    }
+
+    /// Run a command, like those received from KeyPressFocus  
+    pub fn run_command(
+        &mut self,
+        ctx: &mut EventCtx,
+        command: &LapceCommand,
+    ) -> CommandExecuted {
+        match &command.kind {
+            CommandKind::Focus(cmd) => self.run_focus_command(ctx, cmd),
+            _ => CommandExecuted::No,
+        }
+    }
+
+    pub fn run_focus_command(
+        &mut self,
+        ctx: &mut EventCtx,
+        command: &FocusCommand,
+    ) -> CommandExecuted {
+        match command {
+            // ModalClose should be handled (if desired) by the containing widget
+            FocusCommand::ListNext => {
+                self.next();
+            }
+            FocusCommand::ListNextPage => {
+                self.next_page();
+            }
+            FocusCommand::ListPrevious => {
+                self.previous();
+            }
+            FocusCommand::ListPreviousPage => {
+                self.previous_page();
+            }
+            FocusCommand::ListSelect => {
+                self.select(ctx);
+            }
+            _ => return CommandExecuted::No,
+        }
+        CommandExecuted::Yes
+    }
+
+    // TODO: Option for whether moving should be wrapping
+
+    pub fn next(&mut self) {
+        self.selected_index = Movement::Down.update_index(
+            self.selected_index,
+            self.items.len(),
+            1,
+            true,
+        );
+    }
+
+    pub fn next_page(&mut self) {
+        self.selected_index = Movement::Down.update_index(
+            self.selected_index,
+            self.items.len(),
+            self.max_displayed_items - 1,
+            false,
+        );
+    }
+
+    pub fn previous(&mut self) {
+        self.selected_index = Movement::Up.update_index(
+            self.selected_index,
+            self.items.len(),
+            1,
+            true,
+        );
+    }
+
+    pub fn previous_page(&mut self) {
+        self.selected_index = Movement::Up.update_index(
+            self.selected_index,
+            self.items.len(),
+            self.max_displayed_items - 1,
+            false,
+        );
+    }
+
+    pub fn select(&self, ctx: &mut EventCtx) {
+        ctx.submit_command(Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::ListItemSelected,
+            Target::Widget(self.parent),
+        ));
+    }
+
+    pub fn current_selected_item(&self) -> Option<&T> {
+        self.items.get(self.selected_index)
+    }
+}
+impl<T: Clone + PartialEq + 'static, D: Data> Data for ListData<T, D> {
+    fn same(&self, other: &Self) -> bool {
+        // We don't compare the held Config, because that should be updated whenever
+        // the widget is used
+
+        self.parent == other.parent
+            && self.items == other.items
+            && self.data.same(&other.data)
+            && self.selected_index.same(&other.selected_index)
+            && self.max_displayed_items.same(&other.max_displayed_items)
+            && self.line_height.same(&other.line_height)
+    }
+}
+impl<T: Clone + PartialEq + 'static, D: Data> GetConfig for ListData<T, D> {
+    fn get_config(&self) -> &LapceConfig {
+        &self.config
+    }
+}
diff --git a/lapce-data/src/markdown/layout_content.rs b/lapce-data/src/markdown/layout_content.rs
new file mode 100644
index 0000000000..728d541f31
--- /dev/null
+++ b/lapce-data/src/markdown/layout_content.rs
@@ -0,0 +1,280 @@
+use std::sync::Arc;
+
+use druid::{
+    kurbo::Line,
+    piet::{InterpolationMode, PietText},
+    ArcStr, Color, Env, EventCtx, ExtEventSink, FontDescriptor, PaintCtx, Point,
+    Rect, RenderContext, Size, TextLayout, UpdateCtx, Vec2,
+};
+use lsp_types::Url;
+
+use crate::{
+    config::{LapceConfig, LapceIcons, LapceTheme},
+    data::LapceTabData,
+    images::{Image, ImageCache, ImageStatus},
+    rich_text::RichText,
+};
+
+use super::Content;
+
+#[derive(Clone)]
+pub enum LayoutContent {
+    Text(TextLayout<RichText>),
+    // TODO: keep title with it to inform the user on hover
+    Image { url: Url, size: Size },
+    BrokenImage { text: TextLayout<RichText> },
+    Separator { width: f64 },
+}
+impl LayoutContent {
+    // TODO: Add configuration for whether it should allow loading local file urls
+    // (And it would be desirable to have them be fine-grained enough to allow previewing
+    // local markdown files to load local images, but not allow loading local images in hover)
+
+    /// Transform a `MarkdownContent` instance into one which can be rendered.  
+    /// This loads images as needed. Specify a `base_url` for the root of relative urls, typically
+    /// the current workspace.  
+    pub fn from_content(
+        event_sink: ExtEventSink,
+        images: &mut ImageCache,
+        base_url: Option<&Url>,
+        content: &Content,
+    ) -> LayoutContent {
+        match content {
+            Content::Text(text) => {
+                let mut layout = TextLayout::new();
+                layout.set_text(text.clone());
+                LayoutContent::Text(layout)
+            }
+            Content::Image { url, .. } => {
+                if let Ok(url) = Url::options().base_url(base_url).parse(url) {
+                    images.load_url_cmd(url.clone(), event_sink);
+
+                    LayoutContent::Image {
+                        url,
+                        size: Size::ZERO,
+                    }
+                } else {
+                    // TODO: highlight this with red text and make it italics or something?
+                    let mut layout = TextLayout::new();
+                    layout.set_text(RichText::new(ArcStr::from(format!(
+                        "Bad Image URL: {url}"
+                    ))));
+                    LayoutContent::BrokenImage { text: layout }
+                }
+            }
+            Content::Separator => LayoutContent::Separator { width: 0.0 },
+        }
+    }
+
+    pub fn set_font(&mut self, font: FontDescriptor) {
+        match self {
+            LayoutContent::Text(layout) => {
+                layout.set_font(font);
+            }
+            LayoutContent::BrokenImage { text } => {
+                text.set_font(font);
+            }
+            LayoutContent::Image { .. } | LayoutContent::Separator { .. } => {}
+        }
+    }
+
+    pub fn set_text_color(&mut self, color: Color) {
+        match self {
+            LayoutContent::Text(layout) => {
+                layout.set_text_color(color);
+            }
+            LayoutContent::BrokenImage { text } => {
+                text.set_text_color(color);
+            }
+            LayoutContent::Image { .. } | LayoutContent::Separator { .. } => {}
+        }
+    }
+
+    pub fn set_max_width(&mut self, images: &ImageCache, max_width: f64) {
+        match self {
+            LayoutContent::Text(layout) => {
+                layout.set_wrap_width(max_width);
+            }
+            LayoutContent::BrokenImage { text } => {
+                text.set_wrap_width(max_width);
+            }
+            LayoutContent::Image { url, size } => {
+                if let Some(ImageStatus::Loaded(image)) = images.get(url) {
+                    *size = get_image_size(image, max_width);
+                }
+            }
+            LayoutContent::Separator { width } => {
+                *width = max_width - 2.0;
+            }
+        }
+    }
+
+    pub fn needs_rebuild_after_update(&mut self, ctx: &mut UpdateCtx) -> bool {
+        match self {
+            LayoutContent::Text(layout) => layout.needs_rebuild_after_update(ctx),
+            LayoutContent::BrokenImage { text } => {
+                text.needs_rebuild_after_update(ctx)
+            }
+            LayoutContent::Image { .. } | LayoutContent::Separator { .. } => false,
+        }
+    }
+
+    pub fn rebuild_if_needed(&mut self, factory: &mut PietText, env: &Env) {
+        match self {
+            LayoutContent::Text(layout) => {
+                layout.rebuild_if_needed(factory, env);
+            }
+            LayoutContent::BrokenImage { text } => {
+                text.rebuild_if_needed(factory, env);
+            }
+            LayoutContent::Image { .. } | LayoutContent::Separator { .. } => {}
+        }
+    }
+
+    /// `width` is only used for images currently, and should probably be the same as
+    /// `set_wrap_width`'s call
+    pub fn size(&self, images: &ImageCache, config: &LapceConfig) -> Size {
+        match self {
+            LayoutContent::Text(layout) => layout.size(),
+            LayoutContent::Image { url, size } => match images.get(url) {
+                Some(ImageStatus::Loading | ImageStatus::Error) | None => {
+                    get_svg_size(config)
+                }
+                Some(ImageStatus::Loaded(_)) => *size,
+            },
+            LayoutContent::BrokenImage { text } => text.size(),
+            // TODO: Separator side margin should perhaps be supplied by some margin setting??
+            LayoutContent::Separator { width } => Size::new(*width, 1.0),
+        }
+    }
+
+    /// `width` is only used for images currently, and should probably be the same as
+    /// `set_wrap_width`'s call
+    pub fn draw(
+        &self,
+        ctx: &mut PaintCtx,
+        images: &ImageCache,
+        config: &LapceConfig,
+        origin: Point,
+    ) {
+        match self {
+            LayoutContent::Text(layout) => {
+                layout.draw(ctx, origin);
+            }
+            LayoutContent::Image { url, size } => {
+                match images.get(url) {
+                    Some(ImageStatus::Loading) => {
+                        // TODO: Animating this as spinning would be nice, but would be easier
+                        // to do once we have some general textview widget to hold renderalbe
+                        // content
+                        ctx.draw_svg(
+                            &config.ui_svg(LapceIcons::IMAGE_LOADING),
+                            get_svg_size(config).to_rect().with_origin(origin),
+                            Some(
+                                config.get_color_unchecked(
+                                    LapceTheme::LAPCE_ICON_ACTIVE,
+                                ),
+                            ),
+                        );
+                    }
+                    Some(ImageStatus::Error) | None => {
+                        // TODO: On hover, give the user the information about image that
+                        // failed to load
+                        ctx.draw_svg(
+                            &config.ui_svg(LapceIcons::IMAGE_ERROR),
+                            get_svg_size(config).to_rect().with_origin(origin),
+                            Some(
+                                config.get_color_unchecked(
+                                    LapceTheme::LAPCE_ICON_ACTIVE,
+                                ),
+                            ),
+                        );
+                    }
+                    Some(ImageStatus::Loaded(image)) => match image {
+                        Image::Image(image) => {
+                            ctx.draw_image(
+                                image,
+                                Rect::from_origin_size(origin, *size),
+                                InterpolationMode::Bilinear,
+                            );
+                        }
+                    },
+                }
+            }
+            LayoutContent::BrokenImage { text } => {
+                text.draw(ctx, origin);
+            }
+            LayoutContent::Separator { width } => {
+                let line = Line::new(
+                    origin + Vec2::new(1.0, 0.0),
+                    origin + Vec2::new(1.0 + *width, 0.0),
+                );
+                ctx.stroke(
+                    line,
+                    config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                    1.0,
+                );
+            }
+        }
+    }
+}
+
+fn get_svg_size(config: &LapceConfig) -> Size {
+    let svg_size = config.ui.icon_size() as f64;
+    Size::new(svg_size, svg_size)
+}
+
+fn get_image_size(image: &Image, max_width: f64) -> Size {
+    match image {
+        Image::Image(image) => {
+            // This needs piet-wgpu updated with the size implementation for WgpuImage
+            // let size = image.size();
+            let (width, height) = image.img.dimensions();
+            let size = Size::new(width as f64, height as f64);
+            let aspect_ratio = size.width / size.height;
+            let height = max_width / aspect_ratio;
+            Size::new(max_width, height)
+        }
+    }
+}
+
+/// Utility function to make constructing a vector of `LayoutContent` from a vector of `Content`
+pub fn layouts_from_contents<'a>(
+    ctx: &mut EventCtx,
+    data: &mut LapceTabData,
+    items: impl Iterator<Item = &'a Content>,
+) -> Vec<LayoutContent> {
+    let event_sink = ctx.get_external_handle();
+    let images = Arc::make_mut(&mut data.images);
+    let base_url = data
+        .workspace
+        .path
+        .as_deref()
+        .and_then(|p| Url::from_directory_path(p).ok());
+    let base_url = base_url.as_ref();
+    let mut layouts = Vec::new();
+
+    for content in items {
+        layouts.push(LayoutContent::from_content(
+            event_sink.clone(),
+            images,
+            base_url,
+            content,
+        ));
+    }
+
+    layouts
+}
+
+/// Mark that you're done with the layout content, so that they can be cleaned up
+pub fn layout_content_clean_up(
+    layouts: &mut Vec<LayoutContent>,
+    data: &mut LapceTabData,
+) {
+    let images = Arc::make_mut(&mut data.images);
+    for item in layouts.drain(..) {
+        if let LayoutContent::Image { url, .. } = item {
+            images.done_with_image(&url);
+        }
+    }
+}
diff --git a/lapce-data/src/markdown/mod.rs b/lapce-data/src/markdown/mod.rs
new file mode 100644
index 0000000000..0ad3c023a5
--- /dev/null
+++ b/lapce-data/src/markdown/mod.rs
@@ -0,0 +1,328 @@
+use std::str::FromStr;
+
+use druid::{FontStyle, FontWeight};
+use lapce_core::{
+    language::LapceLanguage,
+    syntax::{highlight::HighlightIssue, Syntax},
+};
+use lapce_xi_rope::Rope;
+use lsp_types::{Documentation, MarkedString, MarkupKind};
+use pulldown_cmark::{CodeBlockKind, Tag};
+use smallvec::SmallVec;
+
+use crate::{
+    config::{LapceConfig, LapceTheme},
+    rich_text::{AttributesAdder, RichText, RichTextBuilder},
+};
+
+pub mod layout_content;
+
+#[derive(Clone)]
+pub enum Content {
+    Text(RichText),
+    Image { url: String, title: String },
+    Separator,
+}
+
+/// Parse the LSP documentation structure
+pub fn parse_documentation(
+    doc: &Documentation,
+    config: &LapceConfig,
+) -> Vec<Content> {
+    match doc {
+        // We assume this is plain text
+        Documentation::String(text) => {
+            let mut builder = RichTextBuilder::new();
+            builder.set_line_height(1.5);
+            builder.push(text);
+            vec![Content::Text(builder.build())]
+        }
+        Documentation::MarkupContent(content) => match content.kind {
+            MarkupKind::PlainText => {
+                let mut builder = RichTextBuilder::new();
+                builder.set_line_height(1.5);
+                builder.push(&content.value);
+                vec![Content::Text(builder.build())]
+            }
+            MarkupKind::Markdown => parse_markdown(&content.value, 1.5, config),
+        },
+    }
+}
+
+// TODO: It would be nicer if this returned an iterator
+pub fn parse_markdown(
+    text: &str,
+    line_height: f64,
+    config: &LapceConfig,
+) -> Vec<Content> {
+    use pulldown_cmark::{CowStr, Event, Options, Parser};
+
+    let mut res = Vec::new();
+
+    let mut builder = RichTextBuilder::new();
+    builder.set_line_height(line_height);
+
+    let mut builder_dirty = false;
+
+    let mut pos = 0;
+
+    let mut tag_stack: SmallVec<[(usize, Tag); 4]> = SmallVec::new();
+
+    let parser = Parser::new_ext(
+        text,
+        Options::ENABLE_TABLES
+            | Options::ENABLE_FOOTNOTES
+            | Options::ENABLE_STRIKETHROUGH
+            | Options::ENABLE_TASKLISTS
+            | Options::ENABLE_HEADING_ATTRIBUTES,
+    );
+    let mut last_text = CowStr::from("");
+    // Whether we should add a newline on the next entry
+    // This is used so that we don't emit newlines at the very end of the generation
+    let mut add_newline = false;
+    for event in parser {
+        // Add the newline since we're going to be outputting more
+        if add_newline {
+            builder.push("\n");
+            builder_dirty = true;
+            pos += 1;
+            add_newline = false;
+        }
+
+        match event {
+            Event::Start(tag) => {
+                tag_stack.push((pos, tag));
+            }
+            Event::End(end_tag) => {
+                if let Some((start_offset, tag)) = tag_stack.pop() {
+                    if end_tag != tag {
+                        log::warn!("Mismatched markdown tag");
+                        continue;
+                    }
+
+                    add_attribute_for_tag(
+                        &tag,
+                        builder.add_attributes_for_range(start_offset..pos),
+                        config,
+                    );
+
+                    if should_add_newline_after_tag(&tag) {
+                        add_newline = true;
+                    }
+
+                    match &tag {
+                        Tag::CodeBlock(kind) => {
+                            let language =
+                                if let CodeBlockKind::Fenced(language) = kind {
+                                    md_language_to_lapce_language(language)
+                                } else {
+                                    None
+                                };
+
+                            highlight_as_code(
+                                &mut builder,
+                                config,
+                                language,
+                                &last_text,
+                                start_offset,
+                            );
+                            builder_dirty = true;
+                        }
+                        Tag::Image(_link_type, dest, title) => {
+                            // TODO: Are there any link types that would change how the
+                            // image is rendered?
+
+                            if builder_dirty {
+                                res.push(Content::Text(builder.build()));
+                                builder = RichTextBuilder::new();
+                                builder.set_line_height(line_height);
+                                pos = 0;
+                                builder_dirty = false;
+                            }
+
+                            res.push(Content::Image {
+                                url: dest.to_string(),
+                                title: title.to_string(),
+                            });
+                        }
+                        _ => {
+                            // Presumably?
+                            builder_dirty = true;
+                        }
+                    }
+                } else {
+                    log::warn!("Unbalanced markdown tag")
+                }
+            }
+            Event::Text(text) => {
+                if let Some((_, tag)) = tag_stack.last() {
+                    if should_skip_text_in_tag(tag) {
+                        continue;
+                    }
+                }
+                builder.push(&text);
+                pos += text.len();
+                last_text = text;
+                builder_dirty = true;
+            }
+            Event::Code(text) => {
+                builder.push(&text).font_family(config.editor.font_family());
+                pos += text.len();
+                builder_dirty = true;
+            }
+            // TODO: Some minimal 'parsing' of html could be useful here, since some things use
+            // basic html like `<code>text</code>`.
+            Event::Html(text) => {
+                builder
+                    .push(&text)
+                    .font_family(config.editor.font_family())
+                    .text_color(
+                        config
+                            .get_color_unchecked(LapceTheme::MARKDOWN_BLOCKQUOTE)
+                            .clone(),
+                    );
+                pos += text.len();
+                builder_dirty = true;
+            }
+            Event::HardBreak => {
+                builder.push("\n");
+                pos += 1;
+                builder_dirty = true;
+            }
+            Event::SoftBreak => {
+                builder.push(" ");
+                pos += 1;
+                builder_dirty = true;
+            }
+            Event::Rule => {}
+            Event::FootnoteReference(_text) => {}
+            Event::TaskListMarker(_text) => {}
+        }
+    }
+
+    if builder_dirty {
+        res.push(Content::Text(builder.build()));
+    }
+
+    res
+}
+
+/// Highlight the text in a richtext builder like it was a markdown codeblock
+pub fn highlight_as_code(
+    builder: &mut RichTextBuilder,
+    config: &LapceConfig,
+    language: Option<LapceLanguage>,
+    text: &str,
+    start_offset: usize,
+) {
+    let syntax = language
+        .map(Syntax::from_language)
+        .unwrap_or(Err(HighlightIssue::NotAvailable));
+
+    let styles = syntax
+        .map(|mut syntax| {
+            syntax.parse(0, Rope::from(text), None);
+            syntax.styles
+        })
+        .unwrap_or(None);
+
+    if let Some(styles) = styles {
+        for (range, style) in styles.iter() {
+            if let Some(color) = style
+                .fg_color
+                .as_ref()
+                .and_then(|fg| config.get_style_color(fg))
+            {
+                builder
+                    .add_attributes_for_range(
+                        start_offset + range.start..start_offset + range.end,
+                    )
+                    .text_color(color.clone());
+            }
+        }
+    }
+}
+
+pub fn from_marked_string(text: MarkedString, config: &LapceConfig) -> Vec<Content> {
+    match text {
+        MarkedString::String(text) => parse_markdown(&text, 1.5, config),
+        // This is a short version of a code block
+        MarkedString::LanguageString(code) => {
+            // TODO: We could simply construct the MarkdownText directly
+            // Simply construct the string as if it was written directly
+            parse_markdown(
+                &format!("```{}\n{}\n```", code.language, code.value),
+                1.5,
+                config,
+            )
+        }
+    }
+}
+
+fn add_attribute_for_tag(
+    tag: &Tag,
+    mut attrs: AttributesAdder,
+    config: &LapceConfig,
+) {
+    use pulldown_cmark::HeadingLevel;
+    match tag {
+        Tag::Heading(level, _, _) => {
+            // The size calculations are based on the em values given at
+            // https://drafts.csswg.org/css2/#html-stylesheet
+            let font_scale = match level {
+                HeadingLevel::H1 => 2.0,
+                HeadingLevel::H2 => 1.5,
+                HeadingLevel::H3 => 1.17,
+                HeadingLevel::H4 => 1.0,
+                HeadingLevel::H5 => 0.83,
+                HeadingLevel::H6 => 0.75,
+            };
+            let font_size = font_scale * config.ui.font_size() as f64;
+            attrs.size(font_size).weight(FontWeight::BOLD);
+        }
+        Tag::BlockQuote => {
+            attrs.style(FontStyle::Italic).text_color(
+                config
+                    .get_color_unchecked(LapceTheme::MARKDOWN_BLOCKQUOTE)
+                    .clone(),
+            );
+        }
+        Tag::CodeBlock(_) => {
+            attrs.font_family(config.editor.font_family());
+        }
+        Tag::Emphasis => {
+            attrs.style(FontStyle::Italic);
+        }
+        Tag::Strong => {
+            attrs.weight(FontWeight::BOLD);
+        }
+        // TODO: Strikethrough support
+        Tag::Link(_link_type, _target, _title) => {
+            // TODO: Link support
+            attrs.underline(true).text_color(
+                config.get_color_unchecked(LapceTheme::EDITOR_LINK).clone(),
+            );
+        }
+        // All other tags are currently ignored
+        _ => {}
+    }
+}
+
+/// Decides whether newlines should be added after a specific markdown tag
+fn should_add_newline_after_tag(tag: &Tag) -> bool {
+    !matches!(
+        tag,
+        Tag::Emphasis | Tag::Strong | Tag::Strikethrough | Tag::Link(..)
+    )
+}
+
+/// Whether it should skip the text node after a specific tag  
+/// For example, images are skipped because it emits their title as a separate text node.  
+fn should_skip_text_in_tag(tag: &Tag) -> bool {
+    matches!(tag, Tag::Image(..))
+}
+
+fn md_language_to_lapce_language(lang: &str) -> Option<LapceLanguage> {
+    // TODO: There are many other names commonly used that should be supported
+    LapceLanguage::from_str(lang).ok()
+}
diff --git a/lapce-data/src/menu.rs b/lapce-data/src/menu.rs
index 8e396e4de0..b281206f1f 100644
--- a/lapce-data/src/menu.rs
+++ b/lapce-data/src/menu.rs
@@ -1,5 +1,6 @@
 use crate::command::LapceCommand;
 
+#[derive(Debug)]
 pub enum MenuKind {
     Item(MenuItem),
     Separator,
@@ -9,6 +10,7 @@ pub enum MenuKind {
 pub struct MenuItem {
     pub desc: Option<String>,
     pub command: LapceCommand,
+    pub enabled: bool,
 }
 
 impl MenuItem {
diff --git a/lapce-data/src/palette.rs b/lapce-data/src/palette.rs
index dd4544f4f3..018bfa6e23 100644
--- a/lapce-data/src/palette.rs
+++ b/lapce-data/src/palette.rs
@@ -1,63 +1,84 @@
+use std::{
+    cell::RefCell,
+    cmp::Ordering,
+    collections::{HashMap, HashSet},
+    path::PathBuf,
+    rc::Rc,
+    sync::Arc,
+    time::Instant,
+};
+
 use alacritty_terminal::{grid::Dimensions, term::cell::Flags};
 use anyhow::Result;
 use crossbeam_channel::{unbounded, Receiver, Sender, TryRecvError};
-use druid::{Command, ExtEventSink, Lens, Modifiers, Target, WidgetId};
-use druid::{Data, Env, EventCtx};
-use fuzzy_matcher::skim::SkimMatcherV2;
-use fuzzy_matcher::FuzzyMatcher;
+use druid::{
+    Command, Data, Env, EventCtx, ExtEventSink, Lens, Modifiers, Target, WidgetId,
+};
+use fuzzy_matcher::{skim::SkimMatcherV2, FuzzyMatcher};
+use indexmap::IndexMap;
 use itertools::Itertools;
-use lapce_core::command::{EditCommand, FocusCommand};
-use lapce_core::mode::Mode;
-use lapce_core::movement::Movement;
-use lsp_types::{DocumentSymbolResponse, Range, SymbolKind};
-use serde_json;
-use std::cmp::Ordering;
-use std::collections::HashSet;
-use std::path::PathBuf;
-use std::sync::Arc;
+use lapce_core::{
+    command::{EditCommand, FocusCommand},
+    language::LapceLanguage,
+    mode::Mode,
+};
+use lapce_rpc::{proxy::ProxyResponse, source_control::FileDiff};
+use lsp_types::{DocumentSymbolResponse, Position, Range, SymbolKind};
 use uuid::Uuid;
 
-use crate::command::CommandKind;
-use crate::data::{LapceWorkspace, LapceWorkspaceType};
-use crate::document::BufferContent;
-use crate::editor::EditorLocation;
 use crate::{
-    command::LAPCE_UI_COMMAND,
-    command::{CommandExecuted, LAPCE_COMMAND},
-    command::{LapceCommand, LapceUICommand},
-    config::Config,
-    data::{FocusArea, LapceMainSplitData, LapceTabData, PanelKind},
+    command::{
+        CommandExecuted, CommandKind, LapceCommand, LapceUICommand, LAPCE_COMMAND,
+        LAPCE_UI_COMMAND,
+    },
+    config::LapceConfig,
+    data::{
+        FocusArea, LapceMainSplitData, LapceTabData, LapceWorkspace,
+        LapceWorkspaceType, SshHost,
+    },
+    db::LapceDb,
+    document::BufferContent,
+    editor::EditorLocation,
     find::Find,
-    keypress::{KeyPressData, KeyPressFocus},
-    proxy::LapceProxy,
-    terminal::TerminalSplitData,
+    keypress::{KeyMap, KeyPressData, KeyPressFocus},
+    list::ListData,
+    panel::PanelKind,
+    proxy::{path_from_url, LapceProxy},
+    source_control::SourceControlData,
+    terminal::TerminalPanelData,
 };
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum PaletteType {
     File,
     Line,
     GlobalSearch,
     DocumentSymbol,
+    WorkspaceSymbol,
     Workspace,
     Command,
     Reference,
-    Theme,
+    ColorTheme,
+    IconTheme,
     SshHost,
+    Language,
 }
 
 impl PaletteType {
     fn string(&self) -> String {
         match &self {
-            PaletteType::File => "".to_string(),
             PaletteType::Line => "/".to_string(),
             PaletteType::DocumentSymbol => "@".to_string(),
+            PaletteType::WorkspaceSymbol => "#".to_string(),
             PaletteType::GlobalSearch => "?".to_string(),
             PaletteType::Workspace => ">".to_string(),
             PaletteType::Command => ":".to_string(),
-            PaletteType::Reference => "".to_string(),
-            PaletteType::Theme => "".to_string(),
-            PaletteType::SshHost => "".to_string(),
+            PaletteType::File
+            | PaletteType::Reference
+            | PaletteType::ColorTheme
+            | PaletteType::IconTheme
+            | PaletteType::SshHost
+            | PaletteType::Language => "".to_string(),
         }
     }
 
@@ -66,29 +87,56 @@ impl PaletteType {
             self,
             PaletteType::Line
                 | PaletteType::DocumentSymbol
+                | PaletteType::WorkspaceSymbol
                 | PaletteType::GlobalSearch
                 | PaletteType::Reference
         )
     }
+
+    /// Get the palette type that it should be considered as based on the current
+    /// [`PaletteType`] and the current input.
+    fn get_palette_type(current_type: &PaletteType, input: &str) -> PaletteType {
+        match current_type {
+            PaletteType::Reference
+            | PaletteType::SshHost
+            | PaletteType::ColorTheme
+            | PaletteType::IconTheme
+            | PaletteType::Language => {
+                return current_type.clone();
+            }
+            _ => (),
+        }
+        if input.is_empty() {
+            return PaletteType::File;
+        }
+        match input {
+            _ if input.starts_with('/') => PaletteType::Line,
+            _ if input.starts_with('@') => PaletteType::DocumentSymbol,
+            _ if input.starts_with('#') => PaletteType::WorkspaceSymbol,
+            _ if input.starts_with('>') => PaletteType::Workspace,
+            _ if input.starts_with(':') => PaletteType::Command,
+            _ => PaletteType::File,
+        }
+    }
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum PaletteIcon {
     File(String),
     Symbol(SymbolKind),
     None,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Eq)]
 pub enum PaletteStatus {
     Inactive,
     Started,
     Done,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum PaletteItemContent {
-    File(PathBuf, PathBuf),
+    File(PathBuf, PathBuf, Option<FileDiff>),
     Line(usize, String),
     TerminalLine(i32, String),
     DocumentSymbol {
@@ -97,11 +145,20 @@ pub enum PaletteItemContent {
         range: Range,
         container_name: Option<String>,
     },
-    ReferenceLocation(PathBuf, EditorLocation),
+    WorkspaceSymbol {
+        // TODO: Include what language it is from?
+        kind: SymbolKind,
+        name: String,
+        container_name: Option<String>,
+        location: EditorLocation<Position>,
+    },
+    ReferenceLocation(PathBuf, EditorLocation<Position>),
     Workspace(LapceWorkspace),
-    SshHost(String, String),
+    SshHost(SshHost),
     Command(LapceCommand),
-    Theme(String),
+    ColorTheme(String),
+    IconTheme(String),
+    Language(String),
 }
 
 impl PaletteItemContent {
@@ -112,11 +169,11 @@ impl PaletteItemContent {
         preview_editor_id: WidgetId,
     ) -> bool {
         match &self {
-            PaletteItemContent::File(_, full_path) => {
+            PaletteItemContent::File(_, full_path, _) => {
                 if !preview {
                     ctx.submit_command(Command::new(
                         LAPCE_UI_COMMAND,
-                        LapceUICommand::OpenFile(full_path.clone()),
+                        LapceUICommand::OpenFile(full_path.clone(), true),
                         Target::Auto,
                     ));
                 }
@@ -129,7 +186,23 @@ impl PaletteItemContent {
                 };
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::JumpToPosition(editor_id, range.start),
+                    LapceUICommand::JumpToPosition(editor_id, range.start, true),
+                    Target::Auto,
+                ));
+            }
+            PaletteItemContent::WorkspaceSymbol { location, .. } => {
+                let editor_id = if preview {
+                    Some(preview_editor_id)
+                } else {
+                    None
+                };
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::JumpToLspLocation(
+                        editor_id,
+                        location.clone(),
+                        true,
+                    ),
                     Target::Auto,
                 ));
             }
@@ -153,7 +226,11 @@ impl PaletteItemContent {
                 };
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::JumpToLocation(editor_id, location.clone()),
+                    LapceUICommand::JumpToLspLocation(
+                        editor_id,
+                        location.clone(),
+                        true,
+                    ),
                     Target::Auto,
                 ));
             }
@@ -166,13 +243,36 @@ impl PaletteItemContent {
                     ));
                 }
             }
-            PaletteItemContent::Theme(theme) => {
+            PaletteItemContent::ColorTheme(theme) => {
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::SetTheme(theme.to_string(), preview),
+                    LapceUICommand::SetColorTheme {
+                        theme: theme.to_string(),
+                        preview,
+                    },
                     Target::Auto,
                 ));
             }
+            PaletteItemContent::IconTheme(theme) => {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::SetIconTheme {
+                        theme: theme.to_string(),
+                        preview,
+                    },
+                    Target::Auto,
+                ));
+            }
+            PaletteItemContent::Language(name) => {
+                if !preview {
+                    let name = name.to_string();
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::SetLanguage(name),
+                        Target::Auto,
+                    ))
+                }
+            }
             PaletteItemContent::Command(command) => {
                 if !preview {
                     ctx.submit_command(Command::new(
@@ -192,15 +292,12 @@ impl PaletteItemContent {
                     ));
                 }
             }
-            PaletteItemContent::SshHost(user, host) => {
+            PaletteItemContent::SshHost(ssh) => {
                 if !preview {
                     ctx.submit_command(Command::new(
                         LAPCE_UI_COMMAND,
                         LapceUICommand::SetWorkspace(LapceWorkspace {
-                            kind: LapceWorkspaceType::RemoteSSH(
-                                user.to_string(),
-                                host.to_string(),
-                            ),
+                            kind: LapceWorkspaceType::RemoteSSH(ssh.clone()),
                             path: None,
                             last_open: 0,
                         }),
@@ -213,7 +310,7 @@ impl PaletteItemContent {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct PaletteItem {
     pub content: PaletteItemContent,
     pub filter_text: String,
@@ -230,9 +327,11 @@ pub struct PaletteViewData {
     pub workspace: Arc<LapceWorkspace>,
     pub main_split: LapceMainSplitData,
     pub keypress: Arc<KeyPressData>,
-    pub config: Arc<Config>,
+    pub config: Arc<LapceConfig>,
+    pub db: Arc<LapceDb>,
     pub focus_area: FocusArea,
-    pub terminal: Arc<TerminalSplitData>,
+    pub terminal: Arc<TerminalPanelData>,
+    pub source_control: Arc<SourceControlData>,
 }
 
 impl Lens<LapceTabData, PaletteViewData> for PaletteViewLens {
@@ -261,23 +360,40 @@ impl Lens<LapceTabData, PaletteViewData> for PaletteViewLens {
     }
 }
 
+/// Data to be held by the palette list
+#[derive(Data, Clone)]
+pub struct PaletteListData {
+    /// Should only be `None` when it hasn't been updated initially  
+    /// We need this just for some rendering, and not editing it.
+    pub workspace: Option<Arc<LapceWorkspace>>,
+    /// Should only be `None` when it hasn't been updated initially.
+    /// We need this just for some rendering, and not editing it.
+    pub keymaps: Option<Arc<IndexMap<String, Vec<KeyMap>>>>,
+    /// The mode of the current editor/terminal/none
+    #[data(eq)]
+    pub mode: Option<Mode>,
+}
+
 #[derive(Clone)]
 pub struct PaletteData {
     pub widget_id: WidgetId,
     pub scroll_id: WidgetId,
     pub status: PaletteStatus,
+    /// Holds information about the list, including the filtered items
+    pub list_data: ListData<PaletteItem, PaletteListData>,
     pub proxy: Arc<LapceProxy>,
     pub palette_type: PaletteType,
-    pub sender: Sender<(String, String, Vec<PaletteItem>)>,
-    pub receiver: Option<Receiver<(String, String, Vec<PaletteItem>)>>,
+    pub sender: Sender<(String, String, im::Vector<PaletteItem>)>,
+    pub receiver: Option<Receiver<(String, String, im::Vector<PaletteItem>)>>,
     pub run_id: String,
     pub input: String,
     pub cursor: usize,
-    pub index: usize,
-    pub items: Vec<PaletteItem>,
-    pub filtered_items: Vec<PaletteItem>,
+    pub has_nonzero_default_index: bool,
+    /// The unfiltered items list
+    pub total_items: im::Vector<PaletteItem>,
     pub preview_editor: WidgetId,
     pub input_editor: WidgetId,
+    pub executed_commands: Rc<RefCell<HashMap<String, Instant>>>,
 }
 
 impl KeyPressFocus for PaletteViewData {
@@ -289,38 +405,6 @@ impl KeyPressFocus for PaletteViewData {
         matches!(condition, "list_focus" | "palette_focus" | "modal_focus")
     }
 
-    // fn run_command(
-    //     &mut self,
-    //     ctx: &mut EventCtx,
-    //     command: &LapceCommand,
-    //     _count: Option<usize>,
-    //     _mods: Modifiers,
-    //     _env: &Env,
-    // ) -> CommandExecuted {
-    //     match command {
-    //         LapceCommand::ModalClose => {
-    //             self.cancel(ctx);
-    //         }
-    //         LapceCommand::DeleteBackward => {
-    //             self.delete_backward(ctx);
-    //         }
-    //         LapceCommand::DeleteToBeginningOfLine => {
-    //             self.delete_to_beginning_of_line(ctx);
-    //         }
-    //         LapceCommand::ListNext => {
-    //             self.next(ctx);
-    //         }
-    //         LapceCommand::ListPrevious => {
-    //             self.previous(ctx);
-    //         }
-    //         LapceCommand::ListSelect => {
-    //             self.select(ctx);
-    //         }
-    //         _ => return CommandExecuted::No,
-    //     }
-    //     CommandExecuted::Yes
-    // }
-
     fn receive_char(&mut self, ctx: &mut EventCtx, c: &str) {
         let palette = Arc::make_mut(&mut self.palette);
         palette.input.insert_str(palette.cursor, c);
@@ -336,22 +420,22 @@ impl KeyPressFocus for PaletteViewData {
         _mods: Modifiers,
         _env: &Env,
     ) -> CommandExecuted {
+        let selected_index = self.palette.list_data.selected_index;
+
+        // Pass any commands, like list movement, to the selector list
+        Arc::make_mut(&mut self.palette)
+            .list_data
+            .run_command(ctx, command);
+
+        // If the selection changed, then update the preview
+        if selected_index != self.palette.list_data.selected_index {
+            self.palette.preview(ctx);
+        }
+
         match &command.kind {
-            CommandKind::Focus(cmd) => match cmd {
-                FocusCommand::ModalClose => {
-                    self.cancel(ctx);
-                }
-                FocusCommand::ListNext => {
-                    self.next(ctx);
-                }
-                FocusCommand::ListPrevious => {
-                    self.previous(ctx);
-                }
-                FocusCommand::ListSelect => {
-                    self.select(ctx);
-                }
-                _ => return CommandExecuted::No,
-            },
+            CommandKind::Focus(FocusCommand::ModalClose) => {
+                self.cancel(ctx);
+            }
             CommandKind::Edit(cmd) => match cmd {
                 EditCommand::DeleteBackward => {
                     self.delete_backward(ctx);
@@ -359,6 +443,9 @@ impl KeyPressFocus for PaletteViewData {
                 EditCommand::DeleteToBeginningOfLine => {
                     self.delete_to_beginning_of_line(ctx);
                 }
+                EditCommand::DeleteToEndOfLine => {
+                    self.delete_to_beginning_of_line(ctx);
+                }
                 _ => return CommandExecuted::No,
             },
             _ => return CommandExecuted::No,
@@ -368,15 +455,28 @@ impl KeyPressFocus for PaletteViewData {
 }
 
 impl PaletteData {
-    pub fn new(proxy: Arc<LapceProxy>) -> Self {
+    pub fn new(config: Arc<LapceConfig>, proxy: Arc<LapceProxy>) -> Self {
         let (sender, receiver) = unbounded();
         let widget_id = WidgetId::next();
         let scroll_id = WidgetId::next();
         let preview_editor = WidgetId::next();
+        let mut list_data = ListData::new(
+            config,
+            widget_id,
+            PaletteListData {
+                workspace: None,
+                keymaps: None,
+                mode: None,
+            },
+        );
+        // TODO: Make these configurable
+        list_data.line_height = Some(25);
+        list_data.max_displayed_items = 15;
         Self {
             widget_id,
             scroll_id,
             status: PaletteStatus::Inactive,
+            list_data,
             proxy,
             palette_type: PaletteType::File,
             sender,
@@ -384,11 +484,11 @@ impl PaletteData {
             run_id: Uuid::new_v4().to_string(),
             input: "".to_string(),
             cursor: 0,
-            index: 0,
-            items: Vec::new(),
-            filtered_items: Vec::new(),
+            has_nonzero_default_index: false,
+            total_items: im::Vector::new(),
             preview_editor,
             input_editor: WidgetId::next(),
+            executed_commands: Rc::new(RefCell::new(HashMap::new())),
         }
     }
 
@@ -400,69 +500,79 @@ impl PaletteData {
         self.len() == 0
     }
 
-    pub fn current_items(&self) -> &Vec<PaletteItem> {
+    pub fn current_items(&self) -> &im::Vector<PaletteItem> {
         if self.get_input() == "" {
-            &self.items
+            &self.total_items
         } else {
-            &self.filtered_items
+            &self.list_data.items
         }
     }
 
     pub fn preview(&self, ctx: &mut EventCtx) {
-        if let Some(item) = self.get_item() {
+        if let Some(item) = self.list_data.current_selected_item() {
             item.content.select(ctx, true, self.preview_editor);
         }
     }
 
-    pub fn get_item(&self) -> Option<&PaletteItem> {
-        let items = self.current_items();
-        if items.is_empty() {
-            return None;
-        }
-        Some(&items[self.index])
-    }
-
     pub fn get_input(&self) -> &str {
         match &self.palette_type {
-            PaletteType::File => &self.input,
-            PaletteType::Reference => &self.input,
-            PaletteType::Theme => &self.input,
-            PaletteType::SshHost => &self.input,
-            PaletteType::Line => &self.input[1..],
-            PaletteType::DocumentSymbol => &self.input[1..],
-            PaletteType::Workspace => &self.input[1..],
-            PaletteType::Command => &self.input[1..],
-            PaletteType::GlobalSearch => &self.input[1..],
+            PaletteType::File
+            | PaletteType::Reference
+            | PaletteType::ColorTheme
+            | PaletteType::IconTheme
+            | PaletteType::Language
+            | PaletteType::SshHost => &self.input,
+            PaletteType::Line
+            | PaletteType::DocumentSymbol
+            | PaletteType::WorkspaceSymbol
+            | PaletteType::Workspace
+            | PaletteType::Command
+            | PaletteType::GlobalSearch => &self.input[1..],
         }
     }
 }
 
 impl PaletteViewData {
     pub fn cancel(&mut self, ctx: &mut EventCtx) {
+        match self.palette.palette_type {
+            PaletteType::ColorTheme | PaletteType::IconTheme => {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::ReloadConfig,
+                    Target::Auto,
+                ));
+            }
+            _ => {}
+        }
         let palette = Arc::make_mut(&mut self.palette);
         palette.status = PaletteStatus::Inactive;
         palette.input = "".to_string();
         palette.cursor = 0;
-        palette.index = 0;
         palette.palette_type = PaletteType::File;
-        palette.items.clear();
-        palette.filtered_items.clear();
+        palette.total_items.clear();
+        palette.list_data.clear_items();
         if let Some(active) = *self.main_split.active_tab {
             ctx.submit_command(Command::new(
                 LAPCE_UI_COMMAND,
                 LapceUICommand::Focus,
                 Target::Widget(active),
             ));
+        } else {
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::Focus,
+                Target::Widget(*self.main_split.split_id),
+            ));
         }
     }
 
     pub fn run_references(
         &mut self,
         ctx: &mut EventCtx,
-        locations: &[EditorLocation],
+        locations: &[EditorLocation<Position>],
     ) {
-        self.run(ctx, Some(PaletteType::Reference));
-        let items: Vec<PaletteItem> = locations
+        self.run(ctx, Some(PaletteType::Reference), None, true);
+        let items = locations
             .iter()
             .map(|l| {
                 let full_path = l.path.clone();
@@ -483,25 +593,38 @@ impl PaletteViewData {
             })
             .collect();
         let palette = Arc::make_mut(&mut self.palette);
-        palette.items = items;
+        palette.total_items = items;
         palette.preview(ctx);
+        self.fill_list();
     }
 
-    pub fn run(&mut self, ctx: &mut EventCtx, palette_type: Option<PaletteType>) {
+    pub fn run(
+        &mut self,
+        ctx: &mut EventCtx,
+        palette_type: Option<PaletteType>,
+        input: Option<String>,
+        should_init_input: bool,
+    ) {
         let palette = Arc::make_mut(&mut self.palette);
         palette.status = PaletteStatus::Started;
         palette.palette_type = palette_type.unwrap_or(PaletteType::File);
-        palette.input = palette.palette_type.string();
-        ctx.submit_command(Command::new(
-            LAPCE_UI_COMMAND,
-            LapceUICommand::InitPaletteInput(palette.input.clone()),
-            Target::Widget(*self.main_split.tab_id),
-        ));
-        palette.items = Vec::new();
-        palette.filtered_items = Vec::new();
+        palette.input = input.unwrap_or_else(|| palette.palette_type.string());
+
+        // Most usages of `run` will want to initialize the input
+        // However, special types like workspace-symbol-search want to avoid it
+        // so that they do not cause loops, because they cause run when their
+        // input changes.
+        if should_init_input {
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::InitPaletteInput(palette.input.clone()),
+                Target::Widget(*self.main_split.tab_id),
+            ));
+        }
+        palette.total_items.clear();
+        palette.list_data.clear_items();
         palette.run_id = Uuid::new_v4().to_string();
         palette.cursor = palette.input.len();
-        palette.index = 0;
 
         if let Some(active_editor_content) =
             self.main_split.active_editor().map(|e| e.content.clone())
@@ -526,6 +649,9 @@ impl PaletteViewData {
             PaletteType::DocumentSymbol => {
                 self.get_document_symbols(ctx);
             }
+            PaletteType::WorkspaceSymbol => {
+                self.get_workspace_symbols(ctx);
+            }
             PaletteType::Workspace => {
                 self.get_workspaces(ctx);
             }
@@ -539,11 +665,37 @@ impl PaletteViewData {
             PaletteType::Command => {
                 self.get_commands(ctx);
             }
-            PaletteType::Theme => {
+            PaletteType::ColorTheme => {
+                let config = self.config.clone();
+                self.get_color_themes(ctx, &config);
+                self.preselect_matching(ctx, &config.color_theme.name);
+            }
+            PaletteType::IconTheme => {
                 let config = self.config.clone();
-                self.get_themes(ctx, &config);
+                self.get_icon_themes(ctx, &config);
+                self.preselect_matching(ctx, &config.icon_theme.name);
+            }
+            PaletteType::Language => {
+                self.get_languages(ctx);
+                if let Some(editor) = self.main_split.active_editor() {
+                    let doc = self.main_split.content_doc(&editor.content);
+                    if let Some(syntax) = doc.syntax() {
+                        let lang_name = format!("{}", syntax.language);
+                        self.preselect_matching(ctx, &lang_name);
+                    }
+                }
             }
         }
+
+        self.fill_list();
+    }
+
+    /// Fill the list with the stored unfiltered total items
+    fn fill_list(&mut self) {
+        if self.palette.input.is_empty() {
+            Arc::make_mut(&mut self.palette).list_data.items =
+                self.palette.total_items.clone();
+        }
     }
 
     fn delete_backward(&mut self, ctx: &mut EventCtx) {
@@ -564,15 +716,18 @@ impl PaletteViewData {
         }
 
         let start = match palette.palette_type {
-            PaletteType::File => 0,
-            PaletteType::Reference => 0,
-            PaletteType::Theme => 0,
-            PaletteType::SshHost => 0,
-            PaletteType::Line => 1,
-            PaletteType::DocumentSymbol => 1,
-            PaletteType::Workspace => 1,
-            PaletteType::Command => 1,
-            PaletteType::GlobalSearch => 1,
+            PaletteType::File
+            | PaletteType::Reference
+            | PaletteType::ColorTheme
+            | PaletteType::IconTheme
+            | PaletteType::Language
+            | PaletteType::SshHost => 0,
+            PaletteType::Line
+            | PaletteType::DocumentSymbol
+            | PaletteType::WorkspaceSymbol
+            | PaletteType::Workspace
+            | PaletteType::Command
+            | PaletteType::GlobalSearch => 1,
         };
 
         if palette.cursor == start {
@@ -585,18 +740,37 @@ impl PaletteViewData {
         self.update_palette(ctx);
     }
 
-    pub fn next(&mut self, ctx: &mut EventCtx) {
+    pub fn delete_to_end_of_line(&mut self, ctx: &mut EventCtx) {
         let palette = Arc::make_mut(&mut self.palette);
-        palette.index =
-            Movement::Down.update_index(palette.index, palette.len(), 1, true);
-        palette.preview(ctx);
+        if palette.cursor == 0 {
+            return;
+        }
+
+        let end = palette.input.len();
+
+        if palette.cursor == end {
+            palette.input = "".to_string();
+            palette.cursor = 0;
+        } else {
+            palette.input.replace_range(palette.cursor..end, "");
+            palette.cursor = end;
+        }
+        self.update_palette(ctx);
     }
 
-    pub fn previous(&mut self, ctx: &mut EventCtx) {
+    // TODO: This is a bit weird, its wanting to iterate over items, but it could be called before we fill the list!
+    fn preselect_matching(&mut self, ctx: &mut EventCtx, matching: &str) {
         let palette = Arc::make_mut(&mut self.palette);
-        palette.index =
-            Movement::Up.update_index(palette.index, palette.len(), 1, true);
-        palette.preview(ctx);
+        if let Some((id, _)) = palette
+            .total_items
+            .iter()
+            .enumerate()
+            .find(|(_, item)| item.filter_text == matching)
+        {
+            palette.list_data.selected_index = id;
+            palette.has_nonzero_default_index = true;
+            palette.preview(ctx);
+        }
     }
 
     pub fn select(&mut self, ctx: &mut EventCtx) {
@@ -604,7 +778,7 @@ impl PaletteViewData {
             let pattern = self.palette.get_input().to_string();
             let find = Arc::make_mut(&mut self.find);
             find.visual = true;
-            find.set_find(&pattern, false, false, false);
+            find.set_find(&pattern, false, false);
             ctx.submit_command(Command::new(
                 LAPCE_UI_COMMAND,
                 LapceUICommand::UpdateSearchInput(pattern),
@@ -612,24 +786,24 @@ impl PaletteViewData {
             ));
         }
         let palette = Arc::make_mut(&mut self.palette);
-        if let Some(item) = palette.get_item() {
+        if let Some(item) = palette.list_data.current_selected_item() {
+            if let PaletteItemContent::Command(cmd) = &item.content {
+                palette
+                    .executed_commands
+                    .borrow_mut()
+                    .insert(cmd.kind.str().to_string(), Instant::now());
+            }
             if item.content.select(ctx, false, palette.preview_editor) {
                 self.cancel(ctx);
             }
         } else {
             if self.palette.palette_type == PaletteType::SshHost {
                 let input = self.palette.get_input();
-                let splits = input.split('@').collect::<Vec<&str>>();
-                let mut splits = splits.iter().rev();
-                let host = splits.next().unwrap().to_string();
-                let user = splits
-                    .next()
-                    .map(|s| s.to_string())
-                    .unwrap_or_else(|| "root".to_string());
+                let ssh = SshHost::from_string(input);
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
                     LapceUICommand::SetWorkspace(LapceWorkspace {
-                        kind: LapceWorkspaceType::RemoteSSH(user, host),
+                        kind: LapceWorkspaceType::RemoteSSH(ssh),
                         path: None,
                         last_open: 0,
                     }),
@@ -643,45 +817,49 @@ impl PaletteViewData {
 
     pub fn update_input(&mut self, ctx: &mut EventCtx, input: String) {
         let palette = Arc::make_mut(&mut self.palette);
+
+        // WorkspaceSymbol requires sending the query to the lsp, so we refresh it when the input changes
+        // If the input changed and the palette type is still/now workspace-symbol then we rerun it
+        let palette_type =
+            PaletteType::get_palette_type(&palette.palette_type, &input);
+        if input != palette.input && palette_type == PaletteType::WorkspaceSymbol {
+            self.run(ctx, Some(PaletteType::WorkspaceSymbol), Some(input), false);
+            return;
+        }
+
+        // Update the current input
         palette.input = input;
-        self.update_palette(ctx)
+
+        self.update_palette(ctx);
     }
 
     pub fn update_palette(&mut self, ctx: &mut EventCtx) {
         let palette = Arc::make_mut(&mut self.palette);
-        palette.index = 0;
-        let palette_type = self.get_palette_type();
+        if !palette.has_nonzero_default_index {
+            palette.list_data.selected_index = 0;
+        }
+        palette.has_nonzero_default_index = false;
+
+        let palette_type = PaletteType::get_palette_type(
+            &self.palette.palette_type,
+            &self.palette.input,
+        );
         if self.palette.palette_type != palette_type {
-            self.run(ctx, Some(palette_type));
+            self.run(ctx, Some(palette_type), None, true);
             return;
         }
-        if self.palette.get_input() != "" {
+
+        if self.palette.get_input() == "" {
+            self.palette.preview(ctx);
+            Arc::make_mut(&mut self.palette).list_data.items =
+                self.palette.total_items.clone();
+        } else {
+            // Update the filtering with the input
             let _ = self.palette.sender.send((
                 self.palette.run_id.clone(),
                 self.palette.get_input().to_string(),
-                self.palette.items.clone(),
+                self.palette.total_items.clone(),
             ));
-        } else {
-            self.palette.preview(ctx);
-        }
-    }
-
-    fn get_palette_type(&self) -> PaletteType {
-        match self.palette.palette_type {
-            PaletteType::Reference | PaletteType::SshHost | PaletteType::Theme => {
-                return self.palette.palette_type.clone();
-            }
-            _ => (),
-        }
-        if self.palette.input.is_empty() {
-            return PaletteType::File;
-        }
-        match self.palette.input {
-            _ if self.palette.input.starts_with('/') => PaletteType::Line,
-            _ if self.palette.input.starts_with('@') => PaletteType::DocumentSymbol,
-            _ if self.palette.input.starts_with('>') => PaletteType::Workspace,
-            _ if self.palette.input.starts_with(':') => PaletteType::Command,
-            _ => PaletteType::File,
         }
     }
 
@@ -690,62 +868,59 @@ impl PaletteViewData {
         let widget_id = self.palette.widget_id;
         let workspace = self.workspace.clone();
         let event_sink = ctx.get_external_handle();
-        self.palette.proxy.get_files(Box::new(move |result| {
-            if let Ok(res) = result {
-                let resp: Result<Vec<PathBuf>, serde_json::Error> =
-                    serde_json::from_value(res);
-                if let Ok(resp) = resp {
-                    let items: Vec<PaletteItem> = resp
-                        .iter()
-                        .enumerate()
-                        .map(|(_index, path)| {
-                            let full_path = path.clone();
-                            let mut path = path.clone();
-                            if let Some(workspace_path) = workspace.path.as_ref() {
-                                path = path
-                                    .strip_prefix(workspace_path)
-                                    .unwrap_or(&full_path)
-                                    .to_path_buf();
-                            }
-                            let filter_text =
-                                path.to_str().unwrap_or("").to_string();
-                            PaletteItem {
-                                content: PaletteItemContent::File(path, full_path),
-                                filter_text,
-                                score: 0,
-                                indices: Vec::new(),
-                            }
-                        })
-                        .collect();
-
-                    let _ = event_sink.submit_command(
-                        LAPCE_UI_COMMAND,
-                        LapceUICommand::UpdatePaletteItems(run_id, items),
-                        Target::Widget(widget_id),
-                    );
-                }
+        let file_diffs = self.source_control.file_diffs.clone();
+        self.palette.proxy.proxy_rpc.get_files(move |result| {
+            if let Ok(ProxyResponse::GetFilesResponse { items }) = result {
+                let items: im::Vector<PaletteItem> = items
+                    .iter()
+                    .enumerate()
+                    .map(|(_index, path)| {
+                        let full_path = path.clone();
+                        let mut path = path.clone();
+                        if let Some(workspace_path) = workspace.path.as_ref() {
+                            path = path
+                                .strip_prefix(workspace_path)
+                                .unwrap_or(&full_path)
+                                .to_path_buf();
+                        }
+                        let file_diff =
+                            file_diffs.get(&full_path).cloned().map(|t| t.0);
+                        let filter_text = path.to_str().unwrap_or("").to_string();
+                        PaletteItem {
+                            content: PaletteItemContent::File(
+                                path, full_path, file_diff,
+                            ),
+                            filter_text,
+                            score: 0,
+                            indices: Vec::new(),
+                        }
+                    })
+                    .collect();
+
+                let _ = event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::UpdatePaletteItems { run_id, items },
+                    Target::Widget(widget_id),
+                );
             }
-        }));
+        });
     }
 
     fn get_ssh_hosts(&mut self, _ctx: &mut EventCtx) {
-        let workspaces = Config::recent_workspaces().unwrap_or_default();
+        let workspaces = self.db.recent_workspaces().unwrap_or_default();
         let mut hosts = HashSet::new();
         for workspace in workspaces.iter() {
-            if let LapceWorkspaceType::RemoteSSH(user, host) = &workspace.kind {
-                hosts.insert((user.to_string(), host.to_string()));
+            if let LapceWorkspaceType::RemoteSSH(ssh) = &workspace.kind {
+                hosts.insert(ssh.clone());
             }
         }
 
         let palette = Arc::make_mut(&mut self.palette);
-        palette.items = hosts
+        palette.total_items = hosts
             .iter()
-            .map(|(user, host)| PaletteItem {
-                content: PaletteItemContent::SshHost(
-                    user.to_string(),
-                    host.to_string(),
-                ),
-                filter_text: format!("{user}@{host}"),
+            .map(|ssh| PaletteItem {
+                content: PaletteItemContent::SshHost(ssh.clone()),
+                filter_text: ssh.to_string(),
                 score: 0,
                 indices: vec![],
             })
@@ -753,45 +928,40 @@ impl PaletteViewData {
     }
 
     fn get_workspaces(&mut self, _ctx: &mut EventCtx) {
-        let workspaces = Config::recent_workspaces().unwrap_or_default();
+        let workspaces = self.db.recent_workspaces().unwrap_or_default();
         let palette = Arc::make_mut(&mut self.palette);
-        palette.items = workspaces
+        palette.total_items = workspaces
             .into_iter()
-            .map(|w| {
-                let text = w
-                    .path
-                    .as_ref()
-                    .unwrap()
-                    .to_str()
-                    .map(|p| p.to_string())
-                    .unwrap();
+            .filter_map(|w| {
+                let text = w.path.as_ref()?.to_str()?.to_string();
                 let filter_text = match &w.kind {
                     LapceWorkspaceType::Local => text,
-                    LapceWorkspaceType::RemoteSSH(user, host) => {
-                        format!("[{}@{}] {}", user, host, text)
+                    LapceWorkspaceType::RemoteSSH(ssh) => {
+                        format!("[{ssh}] {text}")
                     }
+                    #[cfg(windows)]
                     LapceWorkspaceType::RemoteWSL => {
                         format!("[wsl] {text}")
                     }
                 };
-                PaletteItem {
+                Some(PaletteItem {
                     content: PaletteItemContent::Workspace(w),
                     filter_text,
                     score: 0,
                     indices: vec![],
-                }
+                })
             })
             .collect();
     }
 
-    fn get_themes(&mut self, _ctx: &mut EventCtx, config: &Config) {
+    fn get_color_themes(&mut self, _ctx: &mut EventCtx, config: &LapceConfig) {
         let palette = Arc::make_mut(&mut self.palette);
-        palette.items = config
-            .available_themes
+        palette.total_items = config
+            .available_color_themes
             .values()
             .sorted_by_key(|(n, _)| n)
             .map(|(n, _)| PaletteItem {
-                content: PaletteItemContent::Theme(n.to_string()),
+                content: PaletteItemContent::ColorTheme(n.to_string()),
                 filter_text: n.to_string(),
                 score: 0,
                 indices: vec![],
@@ -799,37 +969,90 @@ impl PaletteViewData {
             .collect();
     }
 
-    fn get_commands(&mut self, _ctx: &mut EventCtx) {
-        const EXCLUDED_ITEMS: &[&str] = &["palette.command"];
+    fn get_icon_themes(&mut self, _ctx: &mut EventCtx, config: &LapceConfig) {
+        let palette = Arc::make_mut(&mut self.palette);
+        palette.total_items = config
+            .available_icon_themes
+            .values()
+            .sorted_by_key(|(n, _, _)| n)
+            .map(|(n, _, _)| PaletteItem {
+                content: PaletteItemContent::IconTheme(n.to_string()),
+                filter_text: n.to_string(),
+                score: 0,
+                indices: vec![],
+            })
+            .collect();
+    }
 
+    fn get_languages(&mut self, _ctx: &mut EventCtx) {
         let palette = Arc::make_mut(&mut self.palette);
-        palette.items = self
-            .keypress
-            .commands
+        let mut langs = LapceLanguage::languages();
+        langs.push("Plain Text".to_string());
+        palette.total_items = langs
             .iter()
-            .filter_map(|(_, c)| {
-                if EXCLUDED_ITEMS.contains(&c.kind.str()) {
-                    return None;
-                }
+            .sorted()
+            .map(|n| PaletteItem {
+                content: PaletteItemContent::Language(n.to_string()),
+                filter_text: n.to_string(),
+                score: 0,
+                indices: vec![],
+            })
+            .collect();
+    }
 
-                c.kind.desc().as_ref().map(|m| PaletteItem {
-                    content: PaletteItemContent::Command(c.clone()),
-                    filter_text: m.to_string(),
-                    score: 0,
-                    indices: vec![],
+    fn get_commands(&mut self, _ctx: &mut EventCtx) {
+        const EXCLUDED_ITEMS: &[&str] = &["palette.command"];
+
+        let mut items: im::Vector<PaletteItem> = self
+            .palette
+            .executed_commands
+            .borrow()
+            .iter()
+            .sorted_by_key(|(_, i)| *i)
+            .rev()
+            .filter_map(|(key, _)| {
+                self.keypress.commands.get(key).and_then(|c| {
+                    c.kind.desc().as_ref().map(|m| PaletteItem {
+                        content: PaletteItemContent::Command(c.clone()),
+                        filter_text: m.to_string(),
+                        score: 0,
+                        indices: vec![],
+                    })
                 })
             })
             .collect();
+        items.extend(self.keypress.commands.iter().filter_map(|(_, c)| {
+            if EXCLUDED_ITEMS.contains(&c.kind.str()) {
+                return None;
+            }
+
+            if self
+                .palette
+                .executed_commands
+                .borrow()
+                .contains_key(c.kind.str())
+            {
+                return None;
+            }
+
+            c.kind.desc().as_ref().map(|m| PaletteItem {
+                content: PaletteItemContent::Command(c.clone()),
+                filter_text: m.to_string(),
+                score: 0,
+                indices: vec![],
+            })
+        }));
+
+        let palette = Arc::make_mut(&mut self.palette);
+        palette.total_items = items;
     }
 
     fn get_lines(&mut self, _ctx: &mut EventCtx) {
         if self.focus_area == FocusArea::Panel(PanelKind::Terminal) {
-            if let Some(terminal) =
-                self.terminal.terminals.get(&self.terminal.active_term_id)
-            {
+            if let Some(terminal) = self.terminal.active_terminal() {
                 let raw = terminal.raw.lock();
                 let term = &raw.term;
-                let mut items = Vec::new();
+                let mut items = im::Vector::new();
                 let mut last_row: Option<String> = None;
                 let mut current_line = term.topmost_line().0;
                 for line in term.topmost_line().0..term.bottommost_line().0 {
@@ -860,11 +1083,11 @@ impl PaletteViewData {
                             score: 0,
                             indices: vec![],
                         };
-                        items.push(item);
+                        items.push_back(item);
                     }
                 }
                 let palette = Arc::make_mut(&mut self.palette);
-                palette.items = items;
+                palette.total_items = items;
             }
             return;
         }
@@ -878,7 +1101,7 @@ impl PaletteViewData {
         let last_line_number = doc.buffer().last_line() + 1;
         let last_line_number_len = last_line_number.to_string().len();
         let palette = Arc::make_mut(&mut self.palette);
-        palette.items = doc
+        palette.total_items = doc
             .buffer()
             .text()
             .lines(0..doc.buffer().len())
@@ -887,9 +1110,9 @@ impl PaletteViewData {
                 let line_number = i + 1;
                 let text = format!(
                     "{}{} {}",
+                    line_number,
                     vec![" "; last_line_number_len - line_number.to_string().len()]
                         .join(""),
-                    line_number,
                     l
                 );
                 PaletteItem {
@@ -915,79 +1138,134 @@ impl PaletteViewData {
 
         if let BufferContent::File(path) = &editor.content {
             let path = path.clone();
-            let buffer_id = self.main_split.open_docs.get(&path).unwrap().id();
             let run_id = self.palette.run_id.clone();
             let event_sink = ctx.get_external_handle();
 
-            self.palette.proxy.get_document_symbols(
-                buffer_id,
-                Box::new(move |result| {
-                    if let Ok(res) = result {
-                        let resp: Result<DocumentSymbolResponse, serde_json::Error> =
-                            serde_json::from_value(res);
-                        if let Ok(resp) = resp {
-                            let items: Vec<PaletteItem> = match resp {
-                                DocumentSymbolResponse::Flat(symbols) => symbols
-                                    .iter()
-                                    .map(|s| {
-                                        let mut filter_text = s.name.clone();
-                                        if let Some(container_name) =
-                                            s.container_name.as_ref()
-                                        {
-                                            filter_text += container_name;
-                                        }
-                                        PaletteItem {
-                                            content:
-                                                PaletteItemContent::DocumentSymbol {
-                                                    kind: s.kind,
-                                                    name: s.name.clone(),
-                                                    range: s.location.range,
-                                                    container_name: s
-                                                        .container_name
-                                                        .clone(),
-                                                },
-                                            filter_text,
-                                            score: 0,
-                                            indices: Vec::new(),
-                                        }
-                                    })
-                                    .collect(),
-                                DocumentSymbolResponse::Nested(symbols) => symbols
-                                    .iter()
-                                    .map(|s| PaletteItem {
+            self.palette
+                .proxy
+                .proxy_rpc
+                .get_document_symbols(path, move |result| {
+                    if let Ok(ProxyResponse::GetDocumentSymbols { resp }) = result {
+                        let items: im::Vector<PaletteItem> = match resp {
+                            DocumentSymbolResponse::Flat(symbols) => symbols
+                                .iter()
+                                .map(|s| {
+                                    let mut filter_text = s.name.clone();
+                                    if let Some(container_name) =
+                                        s.container_name.as_ref()
+                                    {
+                                        filter_text += container_name;
+                                    }
+                                    PaletteItem {
                                         content:
                                             PaletteItemContent::DocumentSymbol {
                                                 kind: s.kind,
                                                 name: s.name.clone(),
-                                                range: s.range,
-                                                container_name: None,
+                                                range: s.location.range,
+                                                container_name: s
+                                                    .container_name
+                                                    .clone(),
                                             },
-                                        filter_text: s.name.clone(),
+                                        filter_text,
                                         score: 0,
                                         indices: Vec::new(),
-                                    })
-                                    .collect(),
-                            };
-                            let _ = event_sink.submit_command(
-                                LAPCE_UI_COMMAND,
-                                LapceUICommand::UpdatePaletteItems(run_id, items),
-                                Target::Widget(widget_id),
-                            );
-                        }
+                                    }
+                                })
+                                .collect(),
+                            DocumentSymbolResponse::Nested(symbols) => symbols
+                                .iter()
+                                .map(|s| PaletteItem {
+                                    content: PaletteItemContent::DocumentSymbol {
+                                        kind: s.kind,
+                                        name: s.name.clone(),
+                                        range: s.range,
+                                        container_name: None,
+                                    },
+                                    filter_text: s.name.clone(),
+                                    score: 0,
+                                    indices: Vec::new(),
+                                })
+                                .collect(),
+                        };
+                        let _ = event_sink.submit_command(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::UpdatePaletteItems { run_id, items },
+                            Target::Widget(widget_id),
+                        );
                     }
-                }),
+                });
+        }
+    }
+
+    fn get_workspace_symbols(&mut self, ctx: &mut EventCtx) {
+        let editor = self.main_split.active_editor();
+        let editor = match editor {
+            Some(editor) => editor,
+            None => return,
+        };
+
+        let widget_id = self.palette.widget_id;
+
+        // TODO: We'd like to be able to request symbols even when not in an editor.
+        if let BufferContent::File(_path) = &editor.content {
+            let run_id = self.palette.run_id.clone();
+            let event_sink = ctx.get_external_handle();
+
+            let query = self.palette.get_input().to_string();
+
+            self.palette.proxy.proxy_rpc.get_workspace_symbols(
+                query,
+                move |result| {
+                    if let Ok(ProxyResponse::GetWorkspaceSymbols { symbols }) =
+                        result
+                    {
+                        let items: im::Vector<PaletteItem> = symbols
+                            .iter()
+                            .map(|s| {
+                                // TODO: Should we be using filter text?
+                                let mut filter_text = s.name.clone();
+                                if let Some(container_name) =
+                                    s.container_name.as_ref()
+                                {
+                                    filter_text += container_name;
+                                }
+                                PaletteItem {
+                                    content: PaletteItemContent::WorkspaceSymbol {
+                                        kind: s.kind,
+                                        name: s.name.clone(),
+                                        location: EditorLocation {
+                                            path: path_from_url(&s.location.uri),
+                                            position: Some(s.location.range.start),
+                                            scroll_offset: None,
+                                            history: None,
+                                        },
+                                        container_name: s.container_name.clone(),
+                                    },
+                                    filter_text,
+                                    score: 0,
+                                    indices: Vec::new(),
+                                }
+                            })
+                            .collect();
+                        let _ = event_sink.submit_command(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::UpdatePaletteItems { run_id, items },
+                            Target::Widget(widget_id),
+                        );
+                    }
+                },
             );
         }
     }
 
     pub fn update_process(
-        receiver: Receiver<(String, String, Vec<PaletteItem>)>,
+        receiver: Receiver<(String, String, im::Vector<PaletteItem>)>,
         widget_id: WidgetId,
         event_sink: ExtEventSink,
     ) {
         fn receive_batch(
-            receiver: &Receiver<(String, String, Vec<PaletteItem>)>,
-        ) -> Result<(String, String, Vec<PaletteItem>)> {
+            receiver: &Receiver<(String, String, im::Vector<PaletteItem>)>,
+        ) -> Result<(String, String, im::Vector<PaletteItem>)> {
             let (mut run_id, mut input, mut items) = receiver.recv()?;
             loop {
                 match receiver.try_recv() {
@@ -1011,11 +1289,11 @@ impl PaletteViewData {
 
                 let _ = event_sink.submit_command(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::FilterPaletteItems(
+                    LapceUICommand::FilterPaletteItems {
                         run_id,
                         input,
                         filtered_items,
-                    ),
+                    },
                     Target::Widget(widget_id),
                 );
             } else {
@@ -1027,9 +1305,11 @@ impl PaletteViewData {
     fn filter_items(
         _run_id: &str,
         input: &str,
-        items: Vec<PaletteItem>,
+        items: im::Vector<PaletteItem>,
         matcher: &SkimMatcherV2,
-    ) -> Vec<PaletteItem> {
+    ) -> im::Vector<PaletteItem> {
+        // Collecting into a Vec to sort we as are hitting a worst case in
+        // `im::Vector` that leads to a stack overflow
         let mut items: Vec<PaletteItem> = items
             .iter()
             .filter_map(|i| {
@@ -1047,6 +1327,30 @@ impl PaletteViewData {
             .collect();
         items
             .sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(Ordering::Less));
-        items
+        items.into()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn filter_items_can_handle_large_number_of_items() {
+        let items: im::Vector<PaletteItem> = (0..100_000)
+            .map(|score| PaletteItem {
+                content: PaletteItemContent::ColorTheme("".to_string()),
+                filter_text: "s".to_string(),
+                score,
+                indices: vec![],
+            })
+            .collect();
+
+        let matcher = SkimMatcherV2::default().ignore_case();
+
+        // This should not trigger a stack overflow
+        // Previous implementation of this function would crash the program
+        let _view = PaletteViewData::filter_items("1", "s", items, &matcher);
     }
 }
diff --git a/lapce-data/src/panel.rs b/lapce-data/src/panel.rs
index 0850f06e84..03a90486ad 100644
--- a/lapce-data/src/panel.rs
+++ b/lapce-data/src/panel.rs
@@ -1,10 +1,280 @@
+use druid::Data;
+use serde::{Deserialize, Serialize};
+
+use crate::config::LapceIcons;
+
+pub type PanelOrder = im::HashMap<PanelPosition, im::Vector<PanelKind>>;
+
+#[derive(Clone, Copy, PartialEq, Data, Serialize, Deserialize, Hash, Eq, Debug)]
+pub enum PanelKind {
+    FileExplorer,
+    SourceControl,
+    Plugin,
+    Terminal,
+    Search,
+    Problem,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct PanelSize {
+    pub left: f64,
+    pub left_split: f64,
+    pub bottom: f64,
+    pub bottom_split: f64,
+    pub right: f64,
+    pub right_split: f64,
+}
+
+impl PanelKind {
+    pub fn svg_name(&self) -> &'static str {
+        match &self {
+            PanelKind::FileExplorer => LapceIcons::FILE_EXPLORER,
+            PanelKind::SourceControl => LapceIcons::SCM,
+            PanelKind::Plugin => LapceIcons::EXTENSIONS,
+            PanelKind::Terminal => LapceIcons::TERMINAL,
+            PanelKind::Search => LapceIcons::SEARCH,
+            PanelKind::Problem => LapceIcons::PROBLEM,
+        }
+    }
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct PanelStyle {
+    pub active: usize,
+    pub shown: bool,
+    pub maximized: bool,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct PanelData {
+    pub active: PanelPosition,
+    pub order: PanelOrder,
+    pub style: im::HashMap<PanelPosition, PanelStyle>,
+    pub size: PanelSize,
+}
+
+impl PanelData {
+    pub fn new(order: PanelOrder) -> Self {
+        let size = PanelSize {
+            left: 250.0,
+            left_split: 0.5,
+            bottom: 300.0,
+            bottom_split: 0.5,
+            right: 250.0,
+            right_split: 0.5,
+        };
+        let mut style = im::HashMap::new();
+        style.insert(
+            PanelPosition::LeftTop,
+            PanelStyle {
+                active: 0,
+                shown: true,
+                maximized: false,
+            },
+        );
+        style.insert(
+            PanelPosition::LeftBottom,
+            PanelStyle {
+                active: 0,
+                shown: false,
+                maximized: false,
+            },
+        );
+        style.insert(
+            PanelPosition::BottomLeft,
+            PanelStyle {
+                active: 0,
+                shown: true,
+                maximized: false,
+            },
+        );
+        style.insert(
+            PanelPosition::BottomRight,
+            PanelStyle {
+                active: 0,
+                shown: false,
+                maximized: false,
+            },
+        );
+        style.insert(
+            PanelPosition::RightTop,
+            PanelStyle {
+                active: 0,
+                shown: false,
+                maximized: false,
+            },
+        );
+        style.insert(
+            PanelPosition::RightBottom,
+            PanelStyle {
+                active: 0,
+                shown: false,
+                maximized: false,
+            },
+        );
+
+        Self {
+            active: PanelPosition::LeftTop,
+            order,
+            size,
+            style,
+        }
+    }
+
+    pub fn is_container_shown(&self, position: &PanelContainerPosition) -> bool {
+        self.is_position_shown(&position.first())
+            || self.is_position_shown(&position.second())
+    }
+
+    pub fn is_position_shown(&self, position: &PanelPosition) -> bool {
+        self.style.get(position).map(|s| s.shown).unwrap_or(false)
+    }
+
+    pub fn panel_bottom_maximized(&self) -> bool {
+        self.style
+            .get(&PanelPosition::BottomLeft)
+            .map(|p| p.maximized)
+            .unwrap_or(false)
+            || self
+                .style
+                .get(&PanelPosition::BottomRight)
+                .map(|p| p.maximized)
+                .unwrap_or(false)
+    }
+
+    pub fn panel_position(
+        &self,
+        kind: &PanelKind,
+    ) -> Option<(usize, PanelPosition)> {
+        for (pos, panels) in self.order.iter() {
+            let index = panels.iter().position(|k| k == kind);
+            if let Some(index) = index {
+                return Some((index, *pos));
+            }
+        }
+        None
+    }
+
+    pub fn toggle_maximize(&mut self, kind: &PanelKind) {
+        if let Some((_, p)) = self.panel_position(kind) {
+            if p.is_bottom() {
+                self.toggle_bottom_maximize();
+            }
+        }
+    }
+
+    pub fn toggle_active_maximize(&mut self) {
+        if self.active.is_bottom() {
+            self.toggle_bottom_maximize();
+        }
+    }
+
+    pub fn toggle_bottom_maximize(&mut self) {
+        let maximized = !self.panel_bottom_maximized();
+        if let Some(style) = self.style.get_mut(&PanelPosition::BottomLeft) {
+            style.maximized = maximized;
+        }
+        if let Some(style) = self.style.get_mut(&PanelPosition::BottomRight) {
+            style.maximized = maximized;
+        }
+    }
+
+    pub fn set_shown(&mut self, position: &PanelPosition, shown: bool) {
+        if let Some(style) = self.style.get_mut(position) {
+            style.shown = shown;
+        }
+    }
+
+    pub fn toggle_container_visual(&mut self, position: &PanelContainerPosition) {
+        let shown = !self.is_container_shown(position);
+        if shown {
+            if let Some((kind, _)) =
+                self.active_panel_at_position(&position.second())
+            {
+                self.show_panel(&kind);
+            }
+            if let Some((kind, _)) = self.active_panel_at_position(&position.first())
+            {
+                self.show_panel(&kind);
+            }
+        } else {
+            if let Some((kind, _)) =
+                self.active_panel_at_position(&position.second())
+            {
+                self.hide_panel(&kind);
+            }
+            if let Some((kind, _)) = self.active_panel_at_position(&position.first())
+            {
+                self.hide_panel(&kind);
+            }
+        }
+    }
+
+    pub fn position_has_panels(&self, position: &PanelPosition) -> bool {
+        self.order
+            .get(position)
+            .map(|o| !o.is_empty())
+            .unwrap_or(false)
+    }
+
+    pub fn active_panel_at_position(
+        &self,
+        position: &PanelPosition,
+    ) -> Option<(PanelKind, bool)> {
+        let style = self.style.get(position)?;
+        let order = self.order.get(position)?;
+        order
+            .get(style.active)
+            .cloned()
+            .or_else(|| order.last().cloned())
+            .map(|p| (p, style.shown))
+    }
+
+    pub fn hide_panel(&mut self, kind: &PanelKind) {
+        if let Some((_, position)) = self.panel_position(kind) {
+            if let Some((active_panel, _)) = self.active_panel_at_position(&position)
+            {
+                if &active_panel == kind {
+                    self.set_shown(&position, false);
+                    let peer_position = position.peer();
+                    if let Some(order) = self.order.get(&peer_position) {
+                        if order.is_empty() {
+                            self.set_shown(&peer_position, false);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn show_panel(&mut self, kind: &PanelKind) {
+        if let Some((index, position)) = self.panel_position(kind) {
+            if let Some(style) = self.style.get_mut(&position) {
+                style.shown = true;
+                style.active = index;
+            }
+        }
+    }
+
+    pub fn is_panel_visible(&self, kind: &PanelKind) -> bool {
+        if let Some((index, position)) = self.panel_position(kind) {
+            if let Some(style) = self.style.get(&position) {
+                return style.active == index && style.shown;
+            }
+        }
+        false
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
 pub enum PanelResizePosition {
     Left,
     LeftSplit,
+    Right,
     Bottom,
 }
 
-#[derive(Eq, PartialEq, Hash, Clone, Copy)]
+#[derive(Eq, PartialEq, Hash, Clone, Copy, Debug, Serialize, Deserialize)]
 pub enum PanelPosition {
     LeftTop,
     LeftBottom,
@@ -13,3 +283,49 @@ pub enum PanelPosition {
     RightTop,
     RightBottom,
 }
+
+impl PanelPosition {
+    pub fn is_bottom(&self) -> bool {
+        matches!(self, PanelPosition::BottomLeft | PanelPosition::BottomRight)
+    }
+
+    pub fn peer(&self) -> PanelPosition {
+        match &self {
+            PanelPosition::LeftTop => PanelPosition::LeftBottom,
+            PanelPosition::LeftBottom => PanelPosition::LeftTop,
+            PanelPosition::BottomLeft => PanelPosition::BottomRight,
+            PanelPosition::BottomRight => PanelPosition::BottomLeft,
+            PanelPosition::RightTop => PanelPosition::RightBottom,
+            PanelPosition::RightBottom => PanelPosition::RightTop,
+        }
+    }
+}
+
+#[derive(Eq, PartialEq, Hash, Clone, Copy, Debug)]
+pub enum PanelContainerPosition {
+    Left,
+    Bottom,
+    Right,
+}
+
+impl PanelContainerPosition {
+    pub fn is_bottom(&self) -> bool {
+        matches!(self, PanelContainerPosition::Bottom)
+    }
+
+    pub fn first(&self) -> PanelPosition {
+        match self {
+            PanelContainerPosition::Left => PanelPosition::LeftTop,
+            PanelContainerPosition::Bottom => PanelPosition::BottomLeft,
+            PanelContainerPosition::Right => PanelPosition::RightTop,
+        }
+    }
+
+    pub fn second(&self) -> PanelPosition {
+        match self {
+            PanelContainerPosition::Left => PanelPosition::LeftBottom,
+            PanelContainerPosition::Bottom => PanelPosition::BottomRight,
+            PanelContainerPosition::Right => PanelPosition::RightBottom,
+        }
+    }
+}
diff --git a/lapce-data/src/picker.rs b/lapce-data/src/picker.rs
index 3a1b3620e9..2777f93a63 100644
--- a/lapce-data/src/picker.rs
+++ b/lapce-data/src/picker.rs
@@ -4,7 +4,7 @@ use std::{
 };
 
 use druid::{ExtEventSink, Target, WidgetId};
-use lapce_rpc::{file::FileNodeItem, proxy::ReadDirResponse};
+use lapce_rpc::{file::FileNodeItem, proxy::ProxyResponse};
 
 use crate::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
@@ -87,23 +87,16 @@ impl FilePickerData {
     ) {
         let path = PathBuf::from(path);
         let local_path = path.clone();
-        proxy.read_dir(
-            &local_path,
-            Box::new(move |result| {
-                if let Ok(res) = result {
-                    let path = path.clone();
-                    let resp: Result<ReadDirResponse, serde_json::Error> =
-                        serde_json::from_value(res);
-                    if let Ok(resp) = resp {
-                        let _ = event_sink.submit_command(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::UpdatePickerItems(path, resp.items),
-                            Target::Widget(tab_id),
-                        );
-                    }
-                }
-            }),
-        );
+        proxy.proxy_rpc.read_dir(local_path, move |result| {
+            if let Ok(ProxyResponse::ReadDirResponse { items }) = result {
+                let path = path.clone();
+                let _ = event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::UpdatePickerItems(path, items),
+                    Target::Widget(tab_id),
+                );
+            }
+        });
     }
 }
 
diff --git a/lapce-data/src/plugin.rs b/lapce-data/src/plugin.rs
index 2b732f03cf..f0fb187718 100644
--- a/lapce-data/src/plugin.rs
+++ b/lapce-data/src/plugin.rs
@@ -1,27 +1,459 @@
-use druid::WidgetId;
+pub mod plugin_install_status;
+
+use std::{collections::HashSet, str::FromStr, sync::Arc};
+
+use anyhow::Result;
+use druid::{
+    piet::{PietImage, Svg},
+    ExtEventSink, Target, WidgetId,
+};
+use indexmap::IndexMap;
+use lapce_core::directory::Directory;
+use lapce_proxy::plugin::{download_volt, volt_icon, wasi::find_all_volts};
+use lapce_rpc::plugin::{VoltID, VoltInfo, VoltMetadata};
+use parking_lot::Mutex;
+use plugin_install_status::PluginInstallStatus;
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
 use strum_macros::Display;
 
+use crate::{
+    command::{LapceUICommand, LAPCE_UI_COMMAND},
+    config::LapceConfig,
+    markdown::parse_markdown,
+    proxy::LapceProxy,
+};
+
+#[derive(Clone)]
+pub enum VoltIconKind {
+    Svg(Arc<Svg>),
+    Image(Arc<PietImage>),
+}
+
+impl VoltIconKind {
+    pub fn from_bytes(buf: &[u8]) -> Result<Self> {
+        if let Ok(s) = std::str::from_utf8(buf) {
+            let svg =
+                Svg::from_str(s).map_err(|_| anyhow::anyhow!("can't parse svg"))?;
+            Ok(VoltIconKind::Svg(Arc::new(svg)))
+        } else {
+            let image = PietImage::from_bytes(buf)
+                .map_err(|_| anyhow::anyhow!("can't resolve image"))?;
+            Ok(VoltIconKind::Image(Arc::new(image)))
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct VoltsList {
+    pub tab_id: WidgetId,
+    pub total: usize,
+    pub volts: IndexMap<VoltID, VoltInfo>,
+    pub icons: im::HashMap<VoltID, VoltIconKind>,
+    pub status: PluginLoadStatus,
+    pub loading: Arc<Mutex<bool>>,
+    pub event_sink: ExtEventSink,
+    pub query: String,
+}
+
+impl VoltsList {
+    pub fn new(tab_id: WidgetId, event_sink: ExtEventSink) -> Self {
+        Self {
+            tab_id,
+            volts: IndexMap::new(),
+            icons: im::HashMap::new(),
+            total: 0,
+            status: PluginLoadStatus::Loading,
+            loading: Arc::new(Mutex::new(false)),
+            query: "".to_string(),
+            event_sink,
+        }
+    }
+
+    pub fn update_query(&mut self, query: String) {
+        if self.query == query {
+            return;
+        }
+
+        self.query = query;
+        self.volts.clear();
+        self.total = 0;
+        self.status = PluginLoadStatus::Loading;
+
+        let event_sink = self.event_sink.clone();
+        let query = self.query.clone();
+        let tab_id = self.tab_id;
+        std::thread::spawn(move || {
+            let _ =
+                PluginData::load_volts(tab_id, true, &query, 0, None, event_sink);
+        });
+    }
+
+    pub fn load_more(&self) {
+        if self.all_loaded() {
+            return;
+        }
+
+        let mut loading = self.loading.lock();
+        if *loading {
+            return;
+        }
+        *loading = true;
+
+        let offset = self.volts.len();
+        let local_loading = self.loading.clone();
+        let event_sink = self.event_sink.clone();
+        let query = self.query.clone();
+        let tab_id = self.tab_id;
+        std::thread::spawn(move || {
+            let _ = PluginData::load_volts(
+                tab_id,
+                false,
+                &query,
+                offset,
+                Some(local_loading),
+                event_sink,
+            );
+        });
+    }
+
+    fn all_loaded(&self) -> bool {
+        self.volts.len() == self.total
+    }
+
+    pub fn update_volts(&mut self, info: &PluginsInfo) {
+        self.total = info.total;
+        for v in &info.plugins {
+            self.volts.insert(v.id(), v.clone());
+        }
+        self.status = PluginLoadStatus::Success;
+        *self.loading.lock() = false;
+    }
+
+    pub fn failed(&mut self) {
+        self.status = PluginLoadStatus::Failed;
+    }
+}
+
+#[derive(Clone)]
 pub struct PluginData {
     pub widget_id: WidgetId,
+    pub search_editor: WidgetId,
+    pub installed_id: WidgetId,
+    pub uninstalled_id: WidgetId,
+
+    pub volts: VoltsList,
+    pub installing: IndexMap<VoltID, PluginInstallStatus>,
+    pub installed: IndexMap<VoltID, VoltMetadata>,
+    pub installed_latest: IndexMap<VoltID, VoltInfo>,
+    pub installed_icons: im::HashMap<VoltID, VoltIconKind>,
+    pub disabled: HashSet<VoltID>,
+    pub workspace_disabled: HashSet<VoltID>,
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub enum PluginLoadStatus {
+    Loading,
+    Failed,
+    Success,
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct PluginsInfo {
+    pub plugins: Vec<VoltInfo>,
+    pub total: usize,
 }
 
 impl PluginData {
-    pub fn new() -> Self {
+    pub fn new(
+        tab_id: WidgetId,
+        disabled: Vec<VoltID>,
+        workspace_disabled: Vec<VoltID>,
+        event_sink: ExtEventSink,
+    ) -> Self {
+        {
+            let event_sink = event_sink.clone();
+            std::thread::spawn(move || {
+                Self::load(tab_id, event_sink);
+            });
+        }
+
         Self {
             widget_id: WidgetId::next(),
+            search_editor: WidgetId::next(),
+            installed_id: WidgetId::next(),
+            uninstalled_id: WidgetId::next(),
+            volts: VoltsList::new(tab_id, event_sink),
+            installing: IndexMap::new(),
+            installed: IndexMap::new(),
+            installed_latest: IndexMap::new(),
+            installed_icons: im::HashMap::new(),
+            disabled: HashSet::from_iter(disabled.into_iter()),
+            workspace_disabled: HashSet::from_iter(workspace_disabled.into_iter()),
         }
     }
-}
 
-impl Default for PluginData {
-    fn default() -> Self {
-        Self::new()
+    fn load(tab_id: WidgetId, event_sink: ExtEventSink) {
+        for meta in find_all_volts() {
+            if meta.wasm.is_none() {
+                let icon = volt_icon(&meta);
+                let _ = event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::VoltInstalled(meta, icon),
+                    Target::Widget(tab_id),
+                );
+            }
+        }
+
+        std::thread::spawn(move || {
+            let _ = PluginData::load_volts(tab_id, true, "", 0, None, event_sink);
+        });
+    }
+
+    pub fn plugin_disabled(&self, id: &VoltID) -> bool {
+        self.disabled.contains(id) || self.workspace_disabled.contains(id)
+    }
+
+    pub fn plugin_status(&self, id: &VoltID) -> PluginStatus {
+        if self.plugin_disabled(id) {
+            return PluginStatus::Disabled;
+        }
+
+        if let Some(meta) = self.installed.get(id) {
+            if let Some(volt) = self
+                .installed_latest
+                .get(id)
+                .or_else(|| self.volts.volts.get(id))
+            {
+                if meta.version == volt.version {
+                    PluginStatus::Installed
+                } else {
+                    PluginStatus::Upgrade(volt.version.clone())
+                }
+            } else {
+                PluginStatus::Installed
+            }
+        } else {
+            PluginStatus::Install
+        }
+    }
+
+    fn load_icon(volt: &VoltInfo) -> Result<VoltIconKind> {
+        let url = format!(
+            "https://plugins.lapce.dev/api/v1/plugins/{}/{}/{}/icon?id={}",
+            volt.author, volt.name, volt.version, volt.updated_at_ts
+        );
+
+        let cache_file_path = Directory::cache_directory().map(|cache_dir| {
+            let mut hasher = Sha256::new();
+            hasher.update(url.as_bytes());
+            let filename = format!("{:x}", hasher.finalize());
+            cache_dir.join(filename)
+        });
+
+        let cache_content =
+            cache_file_path.as_ref().and_then(|p| std::fs::read(p).ok());
+
+        let content = match cache_content {
+            Some(content) => content,
+            None => {
+                let resp = reqwest::blocking::get(&url)?;
+                if !resp.status().is_success() {
+                    return Err(anyhow::anyhow!("can't download icon"));
+                }
+                let buf = resp.bytes()?.to_vec();
+
+                if let Some(path) = cache_file_path.as_ref() {
+                    let _ = std::fs::write(path, &buf);
+                }
+
+                buf
+            }
+        };
+
+        VoltIconKind::from_bytes(&content)
+    }
+
+    fn load_volts(
+        tab_id: WidgetId,
+        inital: bool,
+        query: &str,
+        offset: usize,
+        loading: Option<Arc<Mutex<bool>>>,
+        event_sink: ExtEventSink,
+    ) -> Result<()> {
+        match PluginData::query_volts(query, offset) {
+            Ok(info) => {
+                for v in info.plugins.iter() {
+                    {
+                        let volt = v.clone();
+                        let event_sink = event_sink.clone();
+                        std::thread::spawn(move || -> Result<()> {
+                            let icon = Self::load_icon(&volt)?;
+                            let _ = event_sink.submit_command(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::LoadPluginIcon(volt.id(), icon),
+                                Target::Widget(tab_id),
+                            );
+                            Ok(())
+                        });
+                    }
+                }
+
+                let _ = event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::LoadPlugins(info),
+                    Target::Widget(tab_id),
+                );
+            }
+            Err(_) => {
+                if inital {
+                    let _ = event_sink.submit_command(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::LoadPluginsFailed,
+                        Target::Widget(tab_id),
+                    );
+                }
+                if let Some(loading) = loading.as_ref() {
+                    *loading.lock() = false;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn query_volts(query: &str, offset: usize) -> Result<PluginsInfo> {
+        let url = format!(
+            "https://plugins.lapce.dev/api/v1/plugins?q={query}&offset={offset}"
+        );
+        let plugins: PluginsInfo = reqwest::blocking::get(url)?.json()?;
+        Ok(plugins)
+    }
+
+    pub fn download_readme(
+        widget_id: WidgetId,
+        volt: &VoltInfo,
+        config: &LapceConfig,
+        event_sink: ExtEventSink,
+    ) -> Result<()> {
+        let url = format!(
+            "https://plugins.lapce.dev/api/v1/plugins/{}/{}/{}/readme",
+            volt.author, volt.name, volt.version
+        );
+        let resp = reqwest::blocking::get(url)?;
+        if resp.status() != 200 {
+            let text = parse_markdown("Plugin doesn't have a README", 2.0, config);
+            let _ = event_sink.submit_command(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::UpdateVoltReadme(Arc::new(text)),
+                Target::Widget(widget_id),
+            );
+            return Ok(());
+        }
+        let text = resp.text()?;
+        let text = parse_markdown(&text, 2.0, config);
+        let _ = event_sink.submit_command(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::UpdateVoltReadme(Arc::new(text)),
+            Target::Widget(widget_id),
+        );
+        Ok(())
+    }
+
+    pub fn install_volt(proxy: Arc<LapceProxy>, volt: VoltInfo) -> Result<()> {
+        proxy.core_rpc.volt_installing(volt.clone(), "".to_string());
+
+        if volt.wasm {
+            proxy.proxy_rpc.install_volt(volt);
+        } else {
+            std::thread::spawn(move || -> Result<()> {
+                let download_volt_result = download_volt(&volt);
+                if let Err(err) = download_volt_result {
+                    log::warn!("download_volt err: {err:?}");
+                    proxy.core_rpc.volt_installing(
+                        volt.clone(),
+                        "Could not download Plugin".to_string(),
+                    );
+                    return Ok(());
+                }
+
+                let meta = download_volt_result?;
+                let icon = volt_icon(&meta);
+                proxy.core_rpc.volt_installed(meta, icon);
+                Ok(())
+            });
+        }
+        Ok(())
+    }
+
+    pub fn remove_volt(proxy: Arc<LapceProxy>, meta: VoltMetadata) -> Result<()> {
+        proxy.core_rpc.volt_removing(meta.clone(), "".to_string());
+        if meta.wasm.is_some() {
+            proxy.proxy_rpc.remove_volt(meta);
+        } else {
+            std::thread::spawn(move || -> Result<()> {
+                let path = meta.dir.as_ref().ok_or_else(|| {
+                    proxy.core_rpc.volt_removing(
+                        meta.clone(),
+                        "Plugin Directory does not exist".to_string(),
+                    );
+                    anyhow::anyhow!("don't have dir")
+                })?;
+                if std::fs::remove_dir_all(path).is_err() {
+                    proxy.core_rpc.volt_removing(
+                        meta.clone(),
+                        "Could not remove Plugin Directory".to_string(),
+                    );
+                } else {
+                    proxy.core_rpc.volt_removed(meta.info(), false);
+                }
+                Ok(())
+            });
+        }
+        Ok(())
+    }
+
+    pub fn volt_installed(
+        &mut self,
+        tab_id: WidgetId,
+        volt: &VoltMetadata,
+        icon: &Option<Vec<u8>>,
+        event_sink: ExtEventSink,
+    ) {
+        let volt_id = volt.id();
+
+        self.installing.remove(&volt_id);
+        self.installed.insert(volt_id.clone(), volt.clone());
+
+        if let Some(icon) = icon
+            .as_ref()
+            .and_then(|icon| VoltIconKind::from_bytes(icon).ok())
+        {
+            self.installed_icons.insert(volt_id.clone(), icon);
+        }
+
+        if !self.volts.volts.contains_key(&volt_id) {
+            let url = format!(
+                "https://plugins.lapce.dev/api/v1/plugins/{}/{}/latest",
+                volt.author, volt.name
+            );
+            std::thread::spawn(move || -> Result<()> {
+                let info: VoltInfo = reqwest::blocking::get(url)?.json()?;
+                let _ = event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::LoadPluginLatest(info),
+                    Target::Widget(tab_id),
+                );
+                Ok(())
+            });
+        }
     }
 }
 
-#[derive(Display, PartialEq)]
+#[derive(Display, PartialEq, Eq, Clone)]
 pub enum PluginStatus {
     Installed,
     Install,
-    Upgrade,
+    Upgrade(String),
+    Disabled,
 }
diff --git a/lapce-data/src/plugin/plugin_install_status.rs b/lapce-data/src/plugin/plugin_install_status.rs
new file mode 100644
index 0000000000..5e0f1f25ab
--- /dev/null
+++ b/lapce-data/src/plugin/plugin_install_status.rs
@@ -0,0 +1,42 @@
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum PluginInstallType {
+    Installation,
+    Uninstallation,
+}
+
+#[derive(Clone, Debug)]
+pub struct PluginInstallStatus {
+    error: String,
+    plugin_name: String,
+    install_type: PluginInstallType,
+}
+
+impl PluginInstallStatus {
+    pub fn new(
+        install_type: PluginInstallType,
+        plugin_name: &str,
+        error: String,
+    ) -> Self {
+        Self {
+            error,
+            plugin_name: plugin_name.to_string(),
+            install_type,
+        }
+    }
+
+    pub fn set_error(&mut self, error_string: &str) {
+        self.error = error_string.to_string();
+    }
+
+    pub fn error_string(&self) -> &str {
+        &self.error
+    }
+
+    pub fn install_type(&self) -> &PluginInstallType {
+        &self.install_type
+    }
+
+    pub fn plugin_name(&self) -> &str {
+        &self.plugin_name
+    }
+}
diff --git a/lapce-data/src/problem.rs b/lapce-data/src/problem.rs
index 3f325a5aa4..64da8e9429 100644
--- a/lapce-data/src/problem.rs
+++ b/lapce-data/src/problem.rs
@@ -1,10 +1,14 @@
+use std::{collections::HashMap, path::PathBuf};
+
 use druid::WidgetId;
 
+#[derive(Clone)]
 pub struct ProblemData {
     pub widget_id: WidgetId,
     pub split_id: WidgetId,
     pub error_widget_id: WidgetId,
     pub warning_widget_id: WidgetId,
+    pub collapsed: HashMap<PathBuf, bool>,
 }
 
 impl ProblemData {
@@ -14,6 +18,7 @@ impl ProblemData {
             split_id: WidgetId::next(),
             error_widget_id: WidgetId::next(),
             warning_widget_id: WidgetId::next(),
+            collapsed: HashMap::new(),
         }
     }
 }
diff --git a/lapce-data/src/proxy.rs b/lapce-data/src/proxy.rs
index e1355a81bd..a7fc001a33 100644
--- a/lapce-data/src/proxy.rs
+++ b/lapce-data/src/proxy.rs
@@ -1,47 +1,47 @@
-use std::io::BufReader;
 #[cfg(target_os = "windows")]
 use std::os::windows::process::CommandExt;
-use std::path::Path;
-use std::process::{Command, Stdio};
-use std::thread;
-use std::{path::PathBuf, sync::Arc};
+use std::{
+    collections::HashMap,
+    io::{BufReader, Write},
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+    str::FromStr,
+    sync::Arc,
+    thread,
+};
 
 use anyhow::{anyhow, Result};
-use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
-use druid::Target;
-use druid::{ExtEventSink, WidgetId};
+use druid::{ExtEventSink, Target, WidgetId, WindowId};
 use flate2::read::GzDecoder;
+use lapce_core::{directory::Directory, meta};
 use lapce_proxy::dispatch::Dispatcher;
-use lapce_rpc::buffer::BufferId;
-use lapce_rpc::core::{CoreNotification, CoreRequest};
-use lapce_rpc::plugin::PluginDescription;
-use lapce_rpc::proxy::ProxyRequest;
-use lapce_rpc::source_control::FileDiff;
-use lapce_rpc::terminal::TermId;
-use lapce_rpc::RpcHandler;
-use lapce_rpc::{stdio_transport, Callback};
-use lapce_rpc::{ControlFlow, Handler};
-use lsp_types::CompletionItem;
-use lsp_types::Position;
-use lsp_types::Url;
+use lapce_rpc::{
+    core::{CoreHandler, CoreNotification, CoreRequest, CoreRpcHandler},
+    plugin::VoltID,
+    proxy::{ProxyRpc, ProxyRpcHandler},
+    stdio::stdio_transport,
+    terminal::TermId,
+    RequestId, RpcMessage,
+};
+use lapce_xi_rope::Rope;
+use lsp_types::{LogMessageParams, MessageType, Url};
 use parking_lot::Mutex;
-use serde_json::json;
 use serde_json::Value;
-use xi_rope::spans::SpansBuilder;
-use xi_rope::{Interval, Rope, RopeDelta};
+use thiserror::Error;
 
-use crate::command::LapceUICommand;
-use crate::command::LAPCE_UI_COMMAND;
-use crate::config::Config;
-use crate::data::{LapceWorkspace, LapceWorkspaceType};
-use crate::terminal::RawTerminal;
+use crate::{
+    command::{LapceUICommand, LAPCE_UI_COMMAND},
+    data::{LapceWorkspace, LapceWorkspaceType, SshHost},
+    terminal::RawTerminal,
+};
 
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+const UNIX_PROXY_SCRIPT: &[u8] = include_bytes!("../../extra/proxy.sh");
+const WINDOWS_PROXY_SCRIPT: &[u8] = include_bytes!("../../extra/proxy.ps1");
 
 pub enum TermEvent {
     NewTerminal(Arc<Mutex<RawTerminal>>),
-    UpdateContent(String),
+    UpdateContent(Vec<u8>),
     CloseTerminal,
 }
 
@@ -52,51 +52,86 @@ pub enum ProxyStatus {
     Disconnected,
 }
 
+#[derive(Error, Debug)]
+pub enum RequestError {
+    /// Error in deserializing to the expected value
+    #[error("failed to deserialize")]
+    Deser(serde_json::Error),
+    #[error("response failed")]
+    Rpc(Value),
+}
+
+#[derive(Clone, Copy, Error, Debug, PartialEq, Eq, strum_macros::Display)]
+#[strum(ascii_case_insensitive)]
+enum HostPlatform {
+    UnknownOS,
+    #[strum(serialize = "windows")]
+    Windows,
+    #[strum(serialize = "linux")]
+    Linux,
+    #[strum(serialize = "darwin")]
+    Darwin,
+    #[strum(serialize = "bsd")]
+    Bsd,
+}
+
+/// serialise via strum to arch name that is used
+/// in CI artefacts
+#[derive(Clone, Copy, Error, Debug, PartialEq, Eq, strum_macros::Display)]
+#[strum(ascii_case_insensitive)]
+enum HostArchitecture {
+    UnknownArch,
+    #[strum(serialize = "x86_64")]
+    AMD64,
+    #[strum(serialize = "x86")]
+    X86,
+    #[strum(serialize = "aarch64")]
+    ARM64,
+    #[strum(serialize = "armv7")]
+    ARM32v7,
+    #[strum(serialize = "armhf")]
+    ARM32v6,
+}
+
 #[derive(Clone)]
 pub struct LapceProxy {
     pub tab_id: WidgetId,
-    rpc: RpcHandler,
-    proxy_receiver: Arc<Receiver<Value>>,
+    pub proxy_rpc: ProxyRpcHandler,
+    pub core_rpc: CoreRpcHandler,
     term_tx: Sender<(TermId, TermEvent)>,
     event_sink: ExtEventSink,
 }
 
-impl Handler for LapceProxy {
-    type Notification = CoreNotification;
-    type Request = CoreRequest;
-
-    fn handle_notification(&mut self, rpc: Self::Notification) -> ControlFlow {
-        use lapce_rpc::core::CoreNotification::*;
+impl CoreHandler for LapceProxy {
+    fn handle_notification(&mut self, rpc: CoreNotification) {
+        use CoreNotification::*;
         match rpc {
-            SemanticStyles {
-                rev,
-                buffer_id,
-                path,
-                styles,
-                len,
+            OpenPaths {
+                window_tab_id,
+                folders,
+                files,
             } => {
-                let event_sink = self.event_sink.clone();
-                let tab_id = self.tab_id;
-                rayon::spawn(move || {
-                    let mut styles_span = SpansBuilder::new(len);
-                    for style in styles {
-                        styles_span.add_span(
-                            Interval::new(style.start, style.end),
-                            style.style,
-                        );
-                    }
-                    let styles_span = Arc::new(styles_span.build());
-                    let _ = event_sink.submit_command(
-                        LAPCE_UI_COMMAND,
-                        LapceUICommand::UpdateSemanticStyles(
-                            buffer_id,
-                            path,
-                            rev,
-                            styles_span,
-                        ),
-                        Target::Widget(tab_id),
-                    );
-                });
+                let _ = self.event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::OpenPaths {
+                        window_tab_id: window_tab_id.map(|(window_id, tab_id)| {
+                            (
+                                WindowId::from_usize(window_id),
+                                WidgetId::from_usize(tab_id),
+                            )
+                        }),
+                        folders,
+                        files,
+                    },
+                    Target::Global,
+                );
+            }
+            ProxyConnected {} => {
+                let _ = self.event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::ProxyUpdateStatus(ProxyStatus::Connected),
+                    Target::Widget(self.tab_id),
+                );
             }
             OpenFileChanged { path, content } => {
                 let _ = self.event_sink.submit_command(
@@ -119,6 +154,13 @@ impl Handler for LapceProxy {
                     Target::Widget(self.tab_id),
                 );
             }
+            WorkspaceFileChange {} => {
+                let _ = self.event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::WorkspaceFileChange,
+                    Target::Widget(self.tab_id),
+                );
+            }
             PublishDiagnostics { diagnostics } => {
                 let _ = self.event_sink.submit_command(
                     LAPCE_UI_COMMAND,
@@ -133,13 +175,73 @@ impl Handler for LapceProxy {
                     Target::Widget(self.tab_id),
                 );
             }
-            InstalledPlugins { plugins } => {
+            LogMessage {
+                message: LogMessageParams { message, typ },
+            } => match typ {
+                MessageType::ERROR => {
+                    log::error!("{message}")
+                }
+                MessageType::WARNING => {
+                    log::warn!("{message}")
+                }
+                MessageType::INFO => {
+                    log::info!("{message}")
+                }
+                MessageType::LOG => {
+                    log::debug!("{message}")
+                }
+                _ => {}
+            },
+            ShowMessage { title, message } => {
+                let _ = self.event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::NewMessage {
+                        kind: message.typ,
+                        title,
+                        message: message.message,
+                    },
+                    Target::Widget(self.tab_id),
+                );
+            }
+            HomeDir { path } => {
+                let _ = self.event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::HomeDir(path),
+                    Target::Widget(self.tab_id),
+                );
+            }
+            VoltInstalled { volt, icon } => {
+                let _ = self.event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::VoltInstalled(volt, icon),
+                    Target::Widget(self.tab_id),
+                );
+            }
+            VoltInstalling { volt, error } => {
+                let _ = self.event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::VoltInstalling(volt, error),
+                    Target::Widget(self.tab_id),
+                );
+            }
+            VoltRemoving { volt, error } => {
                 let _ = self.event_sink.submit_command(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::UpdateInstalledPlugins(plugins),
+                    LapceUICommand::VoltRemoving(volt, error),
                     Target::Widget(self.tab_id),
                 );
             }
+            VoltRemoved {
+                volt,
+                only_installing,
+            } => {
+                let _ = self.event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::VoltRemoved(volt, only_installing),
+                    Target::Widget(self.tab_id),
+                );
+            }
+            ListDir { .. } | DiffFiles { .. } => {}
             DiffInfo { diff } => {
                 let _ = self.event_sink.submit_command(
                     LAPCE_UI_COMMAND,
@@ -160,50 +262,66 @@ impl Handler for LapceProxy {
                     Target::Widget(self.tab_id),
                 );
             }
-            ProxyConnected {} => {
+            CompletionResponse {
+                request_id,
+                input,
+                resp,
+                plugin_id,
+            } => {
                 let _ = self.event_sink.submit_command(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::ProxyUpdateStatus(ProxyStatus::Connected),
+                    LapceUICommand::UpdateCompletion {
+                        request_id,
+                        input,
+                        resp,
+                        plugin_id,
+                    },
                     Target::Widget(self.tab_id),
                 );
             }
-            HomeDir { path } => {
+            SignatureHelpResponse {
+                request_id,
+                resp,
+                plugin_id,
+            } => {
                 let _ = self.event_sink.submit_command(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::HomeDir(path),
+                    LapceUICommand::UpdateSignature {
+                        request_id,
+                        resp,
+                        plugin_id,
+                    },
                     Target::Widget(self.tab_id),
                 );
             }
-            ListDir { .. } | DiffFiles { .. } => {}
-            FileChange { event } => {
-                let _ = self.event_sink.submit_command(
-                    LAPCE_UI_COMMAND,
-                    LapceUICommand::FileChange(event),
-                    Target::Widget(self.tab_id),
-                );
+            Log { level, message } => {
+                if let Ok(level) = log::Level::from_str(&level) {
+                    log::log!(level, "{}", message);
+                }
             }
         }
-        ControlFlow::Continue
     }
 
-    fn handle_request(&mut self, _rpc: Self::Request) -> Result<Value, Value> {
-        Err(json!("unimplemented"))
-    }
+    fn handle_request(&mut self, _id: RequestId, _rpc: CoreRequest) {}
 }
 
 impl LapceProxy {
     pub fn new(
+        window_id: WindowId,
         tab_id: WidgetId,
         workspace: LapceWorkspace,
+        disabled_volts: Vec<VoltID>,
+        plugin_configurations: HashMap<String, HashMap<String, serde_json::Value>>,
         term_tx: Sender<(TermId, TermEvent)>,
         event_sink: ExtEventSink,
     ) -> Self {
-        let (proxy_sender, proxy_receiver) = crossbeam_channel::unbounded();
-        let rpc = RpcHandler::new(proxy_sender);
+        let proxy_rpc = ProxyRpcHandler::new();
+        let core_rpc = CoreRpcHandler::new();
+
         let proxy = Self {
             tab_id,
-            rpc,
-            proxy_receiver: Arc::new(proxy_receiver),
+            proxy_rpc,
+            core_rpc,
             term_tx,
             event_sink: event_sink.clone(),
         };
@@ -215,7 +333,13 @@ impl LapceProxy {
                 LapceUICommand::ProxyUpdateStatus(ProxyStatus::Connecting),
                 Target::Widget(tab_id),
             );
-            let _ = local_proxy.start(workspace.clone());
+            let _ = local_proxy.start(
+                workspace.clone(),
+                disabled_volts,
+                plugin_configurations,
+                window_id.to_usize(),
+                tab_id.to_usize(),
+            );
             let _ = event_sink.submit_command(
                 LAPCE_UI_COMMAND,
                 LapceUICommand::ProxyUpdateStatus(ProxyStatus::Disconnected),
@@ -226,88 +350,259 @@ impl LapceProxy {
         proxy
     }
 
-    fn start(&self, workspace: LapceWorkspace) -> Result<()> {
-        if let Some(path) = workspace.path.as_ref() {
-            self.initialize(path.clone());
-        }
-        let (core_sender, core_receiver) = crossbeam_channel::unbounded();
+    fn start(
+        &self,
+        workspace: LapceWorkspace,
+        disabled_volts: Vec<VoltID>,
+        plugin_configurations: HashMap<String, HashMap<String, serde_json::Value>>,
+        window_id: usize,
+        tab_id: usize,
+    ) -> Result<()> {
+        self.proxy_rpc.initialize(
+            workspace.path.clone(),
+            disabled_volts,
+            plugin_configurations,
+            window_id,
+            tab_id,
+        );
         match workspace.kind {
             LapceWorkspaceType::Local => {
-                let proxy_receiver = (*self.proxy_receiver).clone();
+                let proxy_rpc = self.proxy_rpc.clone();
+                let core_rpc = self.core_rpc.clone();
+
                 thread::spawn(move || {
-                    let dispatcher = Dispatcher::new(core_sender);
-                    let _ = dispatcher.mainloop(proxy_receiver);
+                    let mut dispatcher = Dispatcher::new(core_rpc, proxy_rpc);
+                    let proxy_rpc = dispatcher.proxy_rpc.clone();
+                    proxy_rpc.mainloop(&mut dispatcher);
                 });
             }
-            LapceWorkspaceType::RemoteSSH(user, host) => {
-                self.start_remote(SshRemote { user, host }, core_sender)?;
+            LapceWorkspaceType::RemoteSSH(ssh) => {
+                self.start_remote(SshRemote { ssh })?;
             }
+            #[cfg(windows)]
             LapceWorkspaceType::RemoteWSL => {
                 let distro = WslDistro::all()?
                     .into_iter()
                     .find(|distro| distro.default)
                     .ok_or_else(|| anyhow!("no default distro found"))?
                     .name;
-                self.start_remote(WslRemote { distro }, core_sender)?;
+                self.start_remote(WslRemote { distro })?;
             }
         }
 
-        let mut proxy = self.clone();
         let mut handler = self.clone();
-        proxy.rpc.mainloop(core_receiver, &mut handler);
+        self.core_rpc.mainloop(&mut handler);
 
         Ok(())
     }
 
-    fn start_remote(
-        &self,
-        remote: impl Remote,
-        core_sender: Sender<Value>,
-    ) -> Result<()> {
-        let proxy_filename = format!("lapce-proxy-{VERSION}");
-        let remote_proxy_file = format!("~/.lapce/{}", proxy_filename);
+    fn start_remote(&self, remote: impl Remote) -> Result<()> {
+        let proxy_version = match *meta::RELEASE {
+            "Debug" | "Nightly" => "nightly".to_string(),
+            _ => format!("v{}", *meta::VERSION),
+        };
 
-        let cmd = remote
-            .command_builder()
-            .arg("test")
-            .arg("-e")
-            .arg(&remote_proxy_file)
-            .status()?;
-        if !cmd.success() {
-            let local_proxy_file = Config::dir()
-                .ok_or_else(|| anyhow!("can't find config dir"))?
-                .join(&proxy_filename);
-            if !local_proxy_file.exists() {
-                let url = format!("https://github.com/lapce/lapce/releases/download/v{VERSION}/lapce-proxy-linux.gz");
-                let mut resp = reqwest::blocking::get(url).expect("request failed");
-                let mut out = std::fs::File::create(&local_proxy_file)
-                    .expect("failed to create file");
-                let mut gz = GzDecoder::new(&mut resp);
-                std::io::copy(&mut gz, &mut out).expect("failed to copy content");
+        // start ssh CM connection in case where it doesn't handle
+        // executing command properly on remote host
+        // also print ssh debug output when used with LAPCE_DEBUG env
+        match remote.command_builder().arg("lapce-no-command").output() {
+            Ok(cmd) => {
+                log::debug!(target: "lapce_data::proxy::start_remote::first_try", "{}", String::from_utf8_lossy(&cmd.stderr));
+                log::debug!(target: "lapce_data::proxy::start_remote::first_try", "{}", String::from_utf8_lossy(&cmd.stdout));
             }
+            Err(err) => {
+                log::error!(target: "lapce_data::proxy::start_remote::first_try", "{err}");
+                return Err(anyhow!(err));
+            }
+        }
 
-            remote
-                .command_builder()
-                .arg("mkdir")
-                .arg("~/.lapce/")
-                .status()?;
+        // Note about platforms:
+        // Windows can use either cmd.exe, powershell.exe or pwsh.exe as
+        // SSH shell, syntax logic varies significantly that's why we bet on
+        // cmd.exe as it doesn't add unwanted newlines and use powershell only
+        // for proxy install
+        //
+        // Unix-like systems due to POSIX, always have /bin/sh which should not
+        // be necessary to use explicitly most of the time, as many wide-spread
+        // shells retain similar syntax, although shells like Nushell might not
+        // work (hopefully no one uses it as login shell)
+        use HostPlatform::*;
+        let (platform, architecture) = self.host_specification(&remote).unwrap();
+
+        if platform == UnknownOS || architecture == HostArchitecture::UnknownArch {
+            log::error!(target: "lapce_data::proxy::start_remote", "detected remote host: {platform}/{architecture}");
+            return Err(anyhow!("Unknown OS and/or architecture"));
+        }
 
-            remote.upload_file(&local_proxy_file, &remote_proxy_file)?;
+        // ! Below paths have to be synced with what is
+        // ! returned by Config::proxy_directory()
+        let remote_proxy_path = match platform {
+            Windows => format!(
+                "%HOMEDRIVE%%HOMEPATH%\\AppData\\Local\\lapce\\{}\\data\\proxy",
+                *meta::NAME
+            ),
+            Darwin => format!(
+                "~/Library/Application\\ Support/dev.lapce.{}/proxy",
+                *meta::NAME
+            ),
+            _ => {
+                format!("~/.local/share/{}/proxy", (*meta::NAME).to_lowercase())
+            }
+        };
 
-            remote
-                .command_builder()
-                .arg("chmod")
-                .arg("+x")
-                .arg(&remote_proxy_file)
-                .status()?;
+        let script_install = match platform {
+            Windows => {
+                let local_proxy_script =
+                    Directory::proxy_directory().unwrap().join("proxy.ps1");
+
+                let mut proxy_script = std::fs::OpenOptions::new()
+                    .create(true)
+                    .write(true)
+                    .open(&local_proxy_script)?;
+                proxy_script.write_all(WINDOWS_PROXY_SCRIPT)?;
+
+                let remote_proxy_script = "${env:TEMP}\\lapce-proxy.ps1";
+                remote.upload_file(local_proxy_script, remote_proxy_script)?;
+
+                let cmd = remote
+                    .command_builder()
+                    .args([
+                        "powershell",
+                        "-c",
+                        remote_proxy_script,
+                        "-version",
+                        &proxy_version,
+                        "-directory",
+                        &remote_proxy_path,
+                    ])
+                    .output()?;
+                log::debug!(target: "lapce_data::proxy::upload_file", "{}", String::from_utf8_lossy(&cmd.stderr));
+                log::debug!(target: "lapce_data::proxy::upload_file", "{}", String::from_utf8_lossy(&cmd.stdout));
+
+                cmd.status
+            }
+            _ => {
+                let local_proxy_script =
+                    Directory::proxy_directory().unwrap().join("proxy.sh");
+
+                let mut proxy_script = std::fs::OpenOptions::new()
+                    .create(true)
+                    .write(true)
+                    .open(&local_proxy_script)?;
+                proxy_script.write_all(UNIX_PROXY_SCRIPT)?;
+
+                let remote_proxy_script = "/tmp/lapce-proxy.sh";
+                remote.upload_file(local_proxy_script, remote_proxy_script)?;
+
+                let cmd = remote
+                    .command_builder()
+                    .args(["chmod", "+x", remote_proxy_script])
+                    .output()?;
+                log::debug!(target: "lapce_data::proxy::upload_file", "{}", String::from_utf8_lossy(&cmd.stderr));
+                log::debug!(target: "lapce_data::proxy::upload_file", "{}", String::from_utf8_lossy(&cmd.stdout));
+
+                let cmd = remote
+                    .command_builder()
+                    .args([remote_proxy_script, &proxy_version, &remote_proxy_path])
+                    .output()?;
+                log::debug!(target: "lapce_data::proxy::upload_file", "{}", String::from_utf8_lossy(&cmd.stderr));
+                log::debug!(target: "lapce_data::proxy::upload_file", "{}", String::from_utf8_lossy(&cmd.stdout));
+
+                cmd.status
+            }
+        };
+
+        let remote_proxy_file = match platform {
+            Windows => format!("{remote_proxy_path}\\lapce.exe"),
+            _ => format!("{remote_proxy_path}/lapce"),
+        };
+
+        let proxy_filename = format!("lapce-proxy-{platform}-{architecture}");
+
+        log::debug!(target: "lapce_data::proxy::start_remote", "remote proxy path: {remote_proxy_path}");
+
+        if !script_install.success() {
+            let cmd = match platform {
+                Windows => remote
+                    .command_builder()
+                    .args(["dir", &remote_proxy_file])
+                    .status()?,
+                _ => remote
+                    .command_builder()
+                    .arg("test")
+                    .arg("-e")
+                    .arg(&remote_proxy_file)
+                    .status()?,
+            };
+            if !cmd.success() {
+                let local_proxy_file = Directory::proxy_directory()
+                    .ok_or_else(|| anyhow!("can't find proxy directory"))?
+                    .join(&proxy_filename);
+                // remove possibly outdated proxy
+                if local_proxy_file.exists() {
+                    // TODO: add proper proxy version detection and update proxy
+                    // when needed
+                    std::fs::remove_file(&local_proxy_file)?;
+                }
+                let url = format!("https://github.com/lapce/lapce/releases/download/{proxy_version}/{proxy_filename}.gz");
+                log::debug!(target: "lapce_data::proxy::start_remote", "proxy download URI: {url}");
+                let mut resp = reqwest::blocking::get(url).expect("request failed");
+                if resp.status().is_success() {
+                    let mut out = std::fs::File::create(&local_proxy_file)
+                        .expect("failed to create file");
+                    let mut gz = GzDecoder::new(&mut resp);
+                    std::io::copy(&mut gz, &mut out)
+                        .expect("failed to copy content");
+                } else {
+                    log::error!(target: "lapce_data::proxy::start_remote", "proxy download failed with: {}", resp.status());
+                }
+
+                match platform {
+                    // Windows creates all dirs in provided path
+                    Windows => remote
+                        .command_builder()
+                        .arg("mkdir")
+                        .arg(remote_proxy_path)
+                        .status()?,
+                    // Unix needs -p to do same
+                    _ => remote
+                        .command_builder()
+                        .arg("mkdir")
+                        .arg("-p")
+                        .arg(remote_proxy_path)
+                        .status()?,
+                };
+
+                remote.upload_file(&local_proxy_file, &remote_proxy_file)?;
+                if platform != Windows {
+                    remote
+                        .command_builder()
+                        .arg("chmod")
+                        .arg("+x")
+                        .arg(&remote_proxy_file)
+                        .status()?;
+                }
+            }
         }
 
-        let mut child = remote
-            .command_builder()
-            .arg(&remote_proxy_file)
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .spawn()?;
+        let mut child = match platform {
+            // Force cmd.exe usage to resolve %envvar% variables
+            Windows => remote
+                .command_builder()
+                .args(["cmd", "/c"])
+                .arg(&remote_proxy_file)
+                .arg("--proxy")
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .spawn()?,
+            _ => remote
+                .command_builder()
+                .arg(&remote_proxy_file)
+                .arg("--proxy")
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .spawn()?,
+        };
         let stdin = child
             .stdin
             .take()
@@ -318,50 +613,155 @@ impl LapceProxy {
                 .take()
                 .ok_or_else(|| anyhow!("can't find stdout"))?,
         );
+        log::debug!(target: "lapce_data::proxy::start_remote", "process id: {}", child.id());
 
-        let proxy_receiver = (*self.proxy_receiver).clone();
-        stdio_transport(stdin, proxy_receiver, stdout, core_sender);
-
-        Ok(())
-    }
+        let (writer_tx, writer_rx) = crossbeam_channel::unbounded();
+        let (reader_tx, reader_rx) = crossbeam_channel::unbounded();
+        stdio_transport(stdin, writer_rx, stdout, reader_tx);
 
-    pub fn initialize(&self, workspace: PathBuf) {
-        self.rpc.send_rpc_notification(
-            "initialize",
-            &json!({
-                "workspace": workspace,
-            }),
-        )
-    }
+        let local_proxy_rpc = self.proxy_rpc.clone();
+        let local_writer_tx = writer_tx.clone();
+        thread::spawn(move || {
+            for msg in local_proxy_rpc.rx() {
+                match msg {
+                    ProxyRpc::Request(id, rpc) => {
+                        let _ = local_writer_tx.send(RpcMessage::Request(id, rpc));
+                    }
+                    ProxyRpc::Notification(rpc) => {
+                        let _ = local_writer_tx.send(RpcMessage::Notification(rpc));
+                    }
+                    ProxyRpc::Shutdown => {
+                        let _ = child.kill();
+                        let _ = child.wait();
+                        return;
+                    }
+                }
+            }
+        });
 
-    pub fn terminal_close(&self, term_id: TermId) {
-        self.rpc.send_rpc_notification(
-            "terminal_close",
-            &json!({
-                "term_id": term_id,
-            }),
-        )
-    }
+        let core_rpc = self.core_rpc.clone();
+        let proxy_rpc = self.proxy_rpc.clone();
+        thread::spawn(move || {
+            for msg in reader_rx {
+                match msg {
+                    RpcMessage::Request(id, req) => {
+                        let writer_tx = writer_tx.clone();
+                        let core_rpc = core_rpc.clone();
+                        thread::spawn(move || match core_rpc.request(req) {
+                            Ok(resp) => {
+                                let _ =
+                                    writer_tx.send(RpcMessage::Response(id, resp));
+                            }
+                            Err(e) => {
+                                let _ = writer_tx.send(RpcMessage::Error(id, e));
+                            }
+                        });
+                    }
+                    RpcMessage::Notification(n) => {
+                        core_rpc.notification(n);
+                    }
+                    RpcMessage::Response(id, resp) => {
+                        proxy_rpc.handle_response(id, Ok(resp));
+                    }
+                    RpcMessage::Error(id, err) => {
+                        proxy_rpc.handle_response(id, Err(err));
+                    }
+                }
+            }
+        });
 
-    pub fn terminal_resize(&self, term_id: TermId, width: usize, height: usize) {
-        self.rpc.send_rpc_notification(
-            "terminal_resize",
-            &json!({
-                "term_id": term_id,
-                "width": width,
-                "height": height,
-            }),
-        )
+        Ok(())
     }
 
-    pub fn terminal_write(&self, term_id: TermId, content: &str) {
-        self.rpc.send_rpc_notification(
-            "terminal_write",
-            &json!({
-                "term_id": term_id,
-                "content": content,
-            }),
-        )
+    fn host_specification(
+        &self,
+        remote: &impl Remote,
+    ) -> Result<(HostPlatform, HostArchitecture)> {
+        use HostArchitecture::*;
+        use HostPlatform::*;
+
+        let cmd = remote.command_builder().args(["uname", "-sm"]).output();
+
+        let spec = match cmd {
+            Ok(cmd) => {
+                let stdout = String::from_utf8_lossy(&cmd.stdout).to_lowercase();
+                let stdout = stdout.trim();
+                log::debug!(target: "lapce_data::proxy::host_specification", "{}", &stdout);
+                match stdout {
+                    // If empty, then we probably deal with Windows and not Unix
+                    // or something went wrong with command output
+                    "" => {
+                        // Try cmd explicitly
+                        let cmd = remote
+                            .command_builder()
+                            .args([
+                                "cmd",
+                                "/c",
+                                "echo %OS% %PROCESSOR_ARCHITECTURE%",
+                            ])
+                            .output();
+                        match cmd {
+                            Ok(cmd) => {
+                                let stdout = String::from_utf8_lossy(&cmd.stdout)
+                                    .to_lowercase();
+                                let stdout = stdout.trim();
+                                log::debug!(target: "lapce_data::proxy::host_specification", "{}", &stdout);
+                                match stdout.split_once(' ') {
+                                    Some((os, arch)) => {
+                                        (parse_os(os), parse_arch(arch))
+                                    }
+                                    None => {
+                                        // PowerShell fallback
+                                        let cmd = remote
+                                            .command_builder()
+                                            .args(["echo", "\"${env:OS} ${env:PROCESSOR_ARCHITECTURE}\""])
+                                            .output();
+                                        match cmd {
+                                            Ok(cmd) => {
+                                                let stdout =
+                                                    String::from_utf8_lossy(
+                                                        &cmd.stdout,
+                                                    )
+                                                    .to_lowercase();
+                                                let stdout = stdout.trim();
+                                                log::debug!(target: "lapce_data::proxy::host_specification", "{}", &stdout);
+                                                match stdout.split_once(' ') {
+                                                    Some((os, arch)) => (
+                                                        parse_os(os),
+                                                        parse_arch(arch),
+                                                    ),
+                                                    None => (UnknownOS, UnknownArch),
+                                                }
+                                            }
+                                            Err(e) => {
+                                                log::error!(target: "lapce_data::proxy::host_specification", "{e}");
+                                                (UnknownOS, UnknownArch)
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            Err(e) => {
+                                log::error!(target: "lapce_data::proxy::host_specification", "{e}");
+                                (UnknownOS, UnknownArch)
+                            }
+                        }
+                    }
+                    v => {
+                        if let Some((os, arch)) = v.split_once(' ') {
+                            (parse_os(os), parse_arch(arch))
+                        } else {
+                            (UnknownOS, UnknownArch)
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                log::error!(target: "lapce_data::proxy::host_specification", "{e}");
+                (UnknownOS, UnknownArch)
+            }
+        };
+        Ok(spec)
     }
 
     pub fn new_terminal(
@@ -372,281 +772,12 @@ impl LapceProxy {
         raw: Arc<Mutex<RawTerminal>>,
     ) {
         let _ = self.term_tx.send((term_id, TermEvent::NewTerminal(raw)));
-        self.rpc.send_rpc_notification(
-            "new_terminal",
-            &json!({
-                "term_id": term_id,
-                "cwd": cwd,
-                "shell": shell,
-            }),
-        )
-    }
-
-    pub fn git_commit(&self, message: &str, diffs: Vec<FileDiff>) {
-        self.rpc.send_rpc_notification(
-            "git_commit",
-            &json!({
-                "message": message,
-                "diffs": diffs,
-            }),
-        )
-    }
-
-    pub fn git_checkout(&self, branch: &str) {
-        self.rpc.send_rpc_notification(
-            "git_checkout",
-            &json!({
-                "branch": branch,
-            }),
-        )
-    }
-
-    pub fn install_plugin(&self, plugin: &PluginDescription) {
-        self.rpc
-            .send_rpc_notification("install_plugin", &json!({ "plugin": plugin }));
-    }
-
-    pub fn get_buffer_head(
-        &self,
-        buffer_id: BufferId,
-        path: PathBuf,
-        f: Box<dyn Callback>,
-    ) {
-        self.rpc.send_rpc_request_async(
-            "buffer_head",
-            &json!({ "buffer_id": buffer_id, "path": path, }),
-            f,
-        );
-    }
-
-    pub fn global_search(&self, pattern: String, f: Box<dyn Callback>) {
-        self.rpc.send_rpc_request_async(
-            "global_search",
-            &json!({ "pattern": pattern }),
-            f,
-        );
-    }
-
-    pub fn new_buffer(
-        &self,
-        buffer_id: BufferId,
-        path: PathBuf,
-        f: Box<dyn Callback>,
-    ) {
-        self.rpc.send_rpc_request_async(
-            "new_buffer",
-            &json!({ "buffer_id": buffer_id, "path": path }),
-            f,
-        );
-    }
-
-    pub fn save_buffer_as(
-        &self,
-        buffer_id: BufferId,
-        path: PathBuf,
-        rev: u64,
-        content: String,
-        f: Box<dyn Callback>,
-    ) {
-        let request = ProxyRequest::SaveBufferAs {
-            buffer_id,
-            path,
-            rev,
-            content,
-        };
-        self.rpc.send_rpc_request_value_async(request, f);
-    }
-
-    pub fn update(&self, buffer_id: BufferId, delta: &RopeDelta, rev: u64) {
-        self.rpc.send_rpc_notification(
-            "update",
-            &json!({
-                "buffer_id": buffer_id,
-                "delta": delta,
-                "rev": rev,
-            }),
-        )
-    }
-
-    pub fn save(&self, rev: u64, buffer_id: BufferId, f: Box<dyn Callback>) {
-        self.rpc.send_rpc_request_async(
-            "save",
-            &json!({
-                "rev": rev,
-                "buffer_id": buffer_id,
-            }),
-            f,
-        );
-    }
-
-    pub fn get_completion(
-        &self,
-        request_id: usize,
-        buffer_id: BufferId,
-        position: Position,
-        f: Box<dyn Callback>,
-    ) {
-        self.rpc.send_rpc_request_async(
-            "get_completion",
-            &json!({
-                "request_id": request_id,
-                "buffer_id": buffer_id,
-                "position": position,
-            }),
-            f,
-        );
-    }
-
-    pub fn completion_resolve(
-        &self,
-        buffer_id: BufferId,
-        completion_item: CompletionItem,
-        f: Box<dyn Callback>,
-    ) {
-        self.rpc.send_rpc_request_async(
-            "completion_resolve",
-            &json!({
-                "buffer_id": buffer_id,
-                "completion_item": completion_item,
-            }),
-            f,
-        );
-    }
-
-    pub fn get_hover(
-        &self,
-        request_id: usize,
-        buffer_id: BufferId,
-        position: Position,
-        f: Box<dyn Callback>,
-    ) {
-        self.rpc.send_rpc_request_async(
-            "get_hover",
-            &json!({
-                "request_id": request_id,
-                "buffer_id": buffer_id,
-                "position": position,
-            }),
-            f,
-        );
-    }
-
-    pub fn get_signature(
-        &self,
-        buffer_id: BufferId,
-        position: Position,
-        f: Box<dyn Callback>,
-    ) {
-        self.rpc.send_rpc_request_async(
-            "get_signature",
-            &json!({
-                "buffer_id": buffer_id,
-                "position": position,
-            }),
-            f,
-        );
-    }
-
-    pub fn get_references(
-        &self,
-        buffer_id: BufferId,
-        position: Position,
-        f: Box<dyn Callback>,
-    ) {
-        self.rpc.send_rpc_request_async(
-            "get_references",
-            &json!({
-                "buffer_id": buffer_id,
-                "position": position,
-            }),
-            f,
-        );
-    }
-
-    pub fn get_files(&self, f: Box<dyn Callback>) {
-        self.rpc.send_rpc_request_async(
-            "get_files",
-            &json!({
-                "path": "path",
-            }),
-            f,
-        );
-    }
-
-    pub fn read_dir(&self, path: &Path, f: Box<dyn Callback>) {
-        self.rpc.send_rpc_request_async(
-            "read_dir",
-            &json!({
-                "path": path,
-            }),
-            f,
-        );
-    }
-
-    pub fn get_definition(
-        &self,
-        request_id: usize,
-        buffer_id: BufferId,
-        position: Position,
-        f: Box<dyn Callback>,
-    ) {
-        self.rpc.send_rpc_request_async(
-            "get_definition",
-            &json!({
-                "request_id": request_id,
-                "buffer_id": buffer_id,
-                "position": position,
-            }),
-            f,
-        );
-    }
-
-    pub fn get_document_symbols(&self, buffer_id: BufferId, f: Box<dyn Callback>) {
-        self.rpc.send_rpc_request_async(
-            "get_document_symbols",
-            &json!({
-                "buffer_id": buffer_id,
-            }),
-            f,
-        );
-    }
-
-    pub fn get_code_actions(
-        &self,
-        buffer_id: BufferId,
-        position: Position,
-        f: Box<dyn Callback>,
-    ) {
-        self.rpc.send_rpc_request_async(
-            "get_code_actions",
-            &json!({
-                "buffer_id": buffer_id,
-                "position": position,
-            }),
-            f,
-        );
-    }
-
-    pub fn get_document_formatting(
-        &self,
-        buffer_id: BufferId,
-        f: Box<dyn Callback>,
-    ) {
-        self.rpc.send_rpc_request_async(
-            "get_document_formatting",
-            &json!({
-                "buffer_id": buffer_id,
-            }),
-            f,
-        );
+        self.proxy_rpc.new_terminal(term_id, cwd, shell);
     }
 
     pub fn stop(&self) {
-        self.rpc.send_rpc_notification("shutdown", &json!({}));
-        // self.core_sender.send(json!({
-        //     "method": "shutdown",
-        //     "params": {},
-        // }));
+        self.proxy_rpc.shutdown();
+        self.core_rpc.shutdown();
     }
 }
 
@@ -677,54 +808,73 @@ trait Remote: Sized {
 }
 
 struct SshRemote {
-    user: String,
-    host: String,
+    ssh: SshHost,
 }
 
 impl SshRemote {
-    #[cfg(target_os = "windows")]
-    const SSH_ARGS: &'static [&'static str] = &["-o", "ConnectTimeout=15"];
+    #[cfg(windows)]
+    const SSH_ARGS: &'static [&'static str] = &[];
 
-    #[cfg(not(target_os = "windows"))]
+    #[cfg(unix)]
     const SSH_ARGS: &'static [&'static str] = &[
         "-o",
         "ControlMaster=auto",
         "-o",
-        "ControlPath=~/.ssh/cm-%r@%h:%p",
+        "ControlPath=~/.ssh/cm_%C",
         "-o",
         "ControlPersist=30m",
         "-o",
         "ConnectTimeout=15",
     ];
-
-    fn command_builder(user: &str, host: &str) -> Command {
-        let mut cmd = new_command("ssh");
-        cmd.arg(format!("{}@{}", user, host)).args(Self::SSH_ARGS);
-        cmd
-    }
 }
 
 impl Remote for SshRemote {
     fn upload_file(&self, local: impl AsRef<Path>, remote: &str) -> Result<()> {
-        new_command("scp")
-            .args(Self::SSH_ARGS)
+        let mut cmd = new_command("scp");
+
+        cmd.args(Self::SSH_ARGS);
+
+        if let Some(port) = self.ssh.port {
+            cmd.arg("-P").arg(port.to_string());
+        }
+
+        let output = cmd
             .arg(local.as_ref())
-            .arg(dbg!(format!("{}@{}:{remote}", self.user, self.host)))
-            .status()?;
+            .arg(dbg!(format!("{}:{remote}", self.ssh.user_host())))
+            .output()?;
+
+        log::debug!(target: "lapce_data::proxy::upload_file", "{}", String::from_utf8_lossy(&output.stderr));
+        log::debug!(target: "lapce_data::proxy::upload_file", "{}", String::from_utf8_lossy(&output.stdout));
+
         Ok(())
     }
 
     fn command_builder(&self) -> Command {
-        Self::command_builder(&self.user, &self.host)
+        let mut cmd = new_command("ssh");
+        cmd.args(Self::SSH_ARGS);
+
+        if let Some(port) = self.ssh.port {
+            cmd.arg("-p").arg(port.to_string());
+        }
+
+        cmd.arg(self.ssh.user_host());
+
+        if !std::env::var("LAPCE_DEBUG").unwrap_or_default().is_empty() {
+            cmd.arg("-v");
+        }
+
+        cmd
     }
 }
 
+#[cfg(windows)]
 #[derive(Debug)]
 struct WslDistro {
     pub name: String,
     pub default: bool,
 }
 
+#[cfg(windows)]
 impl WslDistro {
     fn all() -> Result<Vec<WslDistro>> {
         let cmd = new_command("wsl")
@@ -759,13 +909,18 @@ impl WslDistro {
     }
 }
 
+#[cfg(windows)]
 struct WslRemote {
     distro: String,
 }
 
+#[cfg(windows)]
 impl Remote for WslRemote {
     fn upload_file(&self, local: impl AsRef<Path>, remote: &str) -> Result<()> {
         let mut wsl_path = Path::new(r"\\wsl.localhost\").join(&self.distro);
+        if !wsl_path.exists() {
+            wsl_path = Path::new(r#"\\wsl$"#).join(&self.distro);
+        }
         wsl_path = if remote.starts_with('~') {
             let home_dir = self.home_dir()?;
             wsl_path.join(remote.replacen('~', &home_dir, 1))
@@ -790,15 +945,9 @@ impl Remote for WslRemote {
 pub fn path_from_url(url: &Url) -> PathBuf {
     let path = url.path();
     if let Some(path) = path.strip_prefix('/') {
-        if let Some((maybe_drive_letter, _)) = path.split_once(&['/', '\\']) {
+        if let Some((maybe_drive_letter, _)) = path.split_once(['/', '\\']) {
             let b = maybe_drive_letter.as_bytes();
-            if b.len() == 2
-                && matches!(
-                    b[0],
-                    b'a'..=b'z' | b'A'..=b'Z'
-                )
-                && b[1] == b':'
-            {
+            if b.len() == 2 && b[0].is_ascii_alphabetic() && b[1] == b':' {
                 return PathBuf::from(path);
             }
         }
@@ -808,5 +957,30 @@ pub fn path_from_url(url: &Url) -> PathBuf {
 
 #[cfg(not(windows))]
 pub fn path_from_url(url: &Url) -> PathBuf {
-    PathBuf::from(url.path())
+    url.to_file_path()
+        .unwrap_or_else(|_| PathBuf::from(url.path()))
+}
+
+fn parse_arch(arch: &str) -> HostArchitecture {
+    use HostArchitecture::*;
+    // processor architectures be like that
+    match arch {
+        "amd64" | "x64" | "x86_64" => AMD64,
+        "x86" | "i386" | "i586" | "i686" => X86,
+        "arm" | "armhf" | "armv6" => ARM32v6,
+        "armv7" | "armv7l" => ARM32v7,
+        "arm64" | "armv8" | "aarch64" => ARM64,
+        _ => UnknownArch,
+    }
+}
+
+fn parse_os(os: &str) -> HostPlatform {
+    use HostPlatform::*;
+    match os {
+        "linux" => Linux,
+        "darwin" => Darwin,
+        "windows_nt" => Windows,
+        v if v.ends_with("bsd") => Bsd,
+        _ => UnknownOS,
+    }
 }
diff --git a/lapce-data/src/rename.rs b/lapce-data/src/rename.rs
new file mode 100644
index 0000000000..5119d835d1
--- /dev/null
+++ b/lapce-data/src/rename.rs
@@ -0,0 +1,161 @@
+use std::{path::PathBuf, sync::Arc};
+
+use druid::{Command, EventCtx, ExtEventSink, Target, WidgetId};
+use lapce_core::buffer::Buffer;
+use lapce_xi_rope::Rope;
+use lsp_types::{Position, PrepareRenameResponse};
+
+use crate::{
+    command::{LapceUICommand, LAPCE_UI_COMMAND},
+    data::LapceMainSplitData,
+    document::LocalBufferKind,
+};
+
+#[derive(Clone)]
+pub struct RenameData {
+    pub view_id: WidgetId,
+    pub editor_id: WidgetId,
+    pub active: bool,
+    pub rev: u64,
+    /// The path of the file in which the symbol is currently being renamed
+    pub path: PathBuf,
+    /// The offset that is currently being handled
+    pub offset: usize,
+    pub position: Position,
+    pub from_editor: WidgetId,
+
+    pub start: usize,
+    pub end: usize,
+    pub placeholder: String,
+    pub mouse_within: bool,
+}
+
+impl RenameData {
+    pub fn new() -> Self {
+        Self {
+            view_id: WidgetId::next(),
+            editor_id: WidgetId::next(),
+            active: false,
+            rev: 0,
+            path: PathBuf::new(),
+            offset: 0,
+            position: Position::new(0, 0),
+            from_editor: WidgetId::next(),
+            start: 0,
+            end: 0,
+            placeholder: "".to_string(),
+            mouse_within: false,
+        }
+    }
+
+    pub fn update(
+        &mut self,
+        path: PathBuf,
+        rev: u64,
+        offset: usize,
+        position: Position,
+        from_editor: WidgetId,
+    ) {
+        self.active = false;
+        self.path = path;
+        self.rev = rev;
+        self.offset = offset;
+        self.from_editor = from_editor;
+        self.position = position;
+        self.mouse_within = false;
+    }
+
+    pub fn cancel(&mut self) {
+        self.active = false;
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn handle_prepare_rename(
+        &mut self,
+        ctx: &mut EventCtx,
+        main_split: &mut LapceMainSplitData,
+        path: PathBuf,
+        rev: u64,
+        offset: usize,
+        start: usize,
+        end: usize,
+        placeholder: String,
+    ) {
+        if self.path != path || self.rev != rev || self.offset != offset {
+            return;
+        }
+        self.active = true;
+        self.start = start;
+        self.end = end;
+        self.placeholder = placeholder.clone();
+
+        let doc = main_split
+            .local_docs
+            .get_mut(&LocalBufferKind::Rename)
+            .unwrap();
+        Arc::make_mut(doc).reload(Rope::from(placeholder), true);
+        let editor = main_split.editors.get_mut(&self.view_id).unwrap();
+        let offset = doc.buffer().line_end_offset(0, true);
+        Arc::make_mut(editor).cursor.mode = lapce_core::cursor::CursorMode::Insert(
+            lapce_core::selection::Selection::region(0, offset),
+        );
+        ctx.submit_command(Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::Focus,
+            Target::Widget(self.view_id),
+        ));
+    }
+
+    pub fn prepare_rename(
+        tab_id: WidgetId,
+        path: PathBuf,
+        offset: usize,
+        rev: u64,
+        buffer: Buffer,
+        resp: PrepareRenameResponse,
+        event_sink: ExtEventSink,
+    ) {
+        let (start, end, placeholder) = match resp {
+            lsp_types::PrepareRenameResponse::Range(range) => (
+                buffer.offset_of_position(&range.start),
+                buffer.offset_of_position(&range.end),
+                None,
+            ),
+            lsp_types::PrepareRenameResponse::RangeWithPlaceholder {
+                range,
+                placeholder,
+            } => (
+                buffer.offset_of_position(&range.start),
+                buffer.offset_of_position(&range.end),
+                Some(placeholder),
+            ),
+            lsp_types::PrepareRenameResponse::DefaultBehavior { .. } => (
+                buffer.prev_code_boundary(offset),
+                buffer.next_code_boundary(offset),
+                None,
+            ),
+        };
+        let placeholder = placeholder.unwrap_or_else(|| {
+            let (start, end) = buffer.select_word(offset);
+            buffer.slice_to_cow(start..end).to_string()
+        });
+        let _ = event_sink.submit_command(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::PrepareRename {
+                path,
+                rev,
+                offset,
+                start,
+                end,
+                placeholder,
+            },
+            Target::Widget(tab_id),
+        );
+    }
+}
+
+impl Default for RenameData {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/lapce-data/src/rich_text.rs b/lapce-data/src/rich_text.rs
index ab0fa80c2b..27b3196f49 100644
--- a/lapce-data/src/rich_text.rs
+++ b/lapce-data/src/rich_text.rs
@@ -4,10 +4,10 @@ use std::{
 };
 
 use druid::{
-    piet::TextStorage as PietTextStorage,
-    piet::{PietTextLayoutBuilder, TextLayoutBuilder},
-    text::{Attribute, AttributeSpans, Link},
-    text::{EnvUpdateCtx, TextStorage},
+    piet::{
+        PietTextLayoutBuilder, TextLayoutBuilder, TextStorage as PietTextStorage,
+    },
+    text::{Attribute, AttributeSpans, EnvUpdateCtx, Link, TextStorage},
     ArcStr, Color, Command, Data, Env, FontDescriptor, FontFamily, FontStyle,
     FontWeight, KeyOrValue,
 };
diff --git a/lapce-data/src/search.rs b/lapce-data/src/search.rs
index 12e6723728..3c4247d638 100644
--- a/lapce-data/src/search.rs
+++ b/lapce-data/src/search.rs
@@ -1,6 +1,7 @@
-use std::{collections::HashMap, path::PathBuf, sync::Arc};
+use std::{path::PathBuf, sync::Arc};
 
 use druid::WidgetId;
+use indexmap::IndexMap;
 
 pub type Match = (usize, (usize, usize), String);
 #[derive(Clone)]
@@ -9,7 +10,7 @@ pub struct SearchData {
     pub widget_id: WidgetId,
     pub split_id: WidgetId,
     pub editor_view_id: WidgetId,
-    pub matches: Arc<HashMap<PathBuf, Vec<Match>>>,
+    pub matches: Arc<IndexMap<PathBuf, Vec<Match>>>,
 }
 
 impl SearchData {
@@ -20,7 +21,7 @@ impl SearchData {
             widget_id: WidgetId::next(),
             split_id: WidgetId::next(),
             editor_view_id,
-            matches: Arc::new(HashMap::new()),
+            matches: Arc::new(IndexMap::new()),
         }
     }
 }
diff --git a/lapce-data/src/selection_range.rs b/lapce-data/src/selection_range.rs
new file mode 100644
index 0000000000..84d92efc86
--- /dev/null
+++ b/lapce-data/src/selection_range.rs
@@ -0,0 +1,182 @@
+use lapce_rpc::buffer::BufferId;
+use lsp_types::{Range, SelectionRange};
+
+/// Lsp [selectionRange](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#selectionRange)
+/// are used to do "smart" syntax selection. A buffer id, buffer revision and cursor position are
+/// stored along side [`lsp_type::SelectionRange`] data to ensure the current selection still apply
+/// to the current buffer.
+#[derive(Clone, Debug)]
+pub struct SyntaxSelectionRanges {
+    pub buffer_id: BufferId,
+    pub rev: u64,
+    pub last_known_selection: Option<(usize, usize)>,
+    pub ranges: SelectionRange,
+    pub current_selection: Option<usize>,
+}
+
+/// Helper to request either the next or previous [`SyntaxSelectionRanges`],
+/// see: [`crate::editor::LapceUiCommand::ApplySelectionRange`]
+#[derive(Clone, Copy, Debug)]
+pub enum SelectionRangeDirection {
+    Next,
+    Previous,
+}
+
+impl SyntaxSelectionRanges {
+    /// Ensure the editor state match this selection range, if not
+    /// a new SelectionRanges should be requested
+    pub fn match_request(
+        &self,
+        buffer_id: BufferId,
+        rev: u64,
+        current_selection: Option<(usize, usize)>,
+    ) -> bool {
+        if self.last_known_selection.is_some() {
+            buffer_id == self.buffer_id
+                && rev == self.rev
+                && current_selection == self.last_known_selection
+        } else {
+            buffer_id == self.buffer_id && rev == self.rev
+        }
+    }
+
+    /// Get the next [`lsp_types::Range'] at `current_selection` depth
+    pub fn next_range(&mut self) -> Option<Range> {
+        match self.current_selection {
+            None => self.current_selection = Some(0),
+            Some(index) => {
+                if index < self.count() - 1 {
+                    self.current_selection = Some(index + 1)
+                }
+            }
+        };
+        self.get()
+    }
+
+    /// Get the previous [`lsp_types::Range'] at `current_selection` depth
+    pub fn previous_range(&mut self) -> Option<Range> {
+        if let Some(index) = self.current_selection {
+            if index > 0 {
+                self.current_selection = Some(index - 1)
+            }
+        }
+        self.get()
+    }
+
+    fn get(&self) -> Option<Range> {
+        self.current_selection.and_then(|index| {
+            if index == 0 {
+                Some(self.ranges.range)
+            } else {
+                let mut current = self.ranges.parent.as_ref();
+
+                for _ in 1..index {
+                    current = current.and_then(|c| c.parent.as_ref());
+                }
+
+                current.map(|c| c.range)
+            }
+        })
+    }
+
+    fn count(&self) -> usize {
+        let mut count = 1;
+        let mut range = &self.ranges;
+        while let Some(parent) = &range.parent {
+            count += 1;
+            range = parent;
+        }
+
+        count
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use lapce_rpc::buffer::BufferId;
+    use lsp_types::{Position, Range, SelectionRange};
+
+    use crate::selection_range::SyntaxSelectionRanges;
+
+    #[test]
+    fn should_get_next_selection_range() {
+        let range_zero = Range {
+            start: Position {
+                line: 0,
+                character: 0,
+            },
+            end: Position {
+                line: 0,
+                character: 0,
+            },
+        };
+        let range_one = Range {
+            start: Position {
+                line: 0,
+                character: 0,
+            },
+            end: Position {
+                line: 0,
+                character: 2,
+            },
+        };
+        let range_two = Range {
+            start: Position {
+                line: 0,
+                character: 0,
+            },
+            end: Position {
+                line: 0,
+                character: 4,
+            },
+        };
+
+        let mut syntax_selection = SyntaxSelectionRanges {
+            buffer_id: BufferId(0),
+            rev: 0,
+            last_known_selection: None,
+            ranges: SelectionRange {
+                range: range_zero,
+                parent: Some(Box::new(SelectionRange {
+                    range: range_one,
+                    parent: Some(Box::new(SelectionRange {
+                        range: range_two,
+                        parent: None,
+                    })),
+                })),
+            },
+            current_selection: None,
+        };
+
+        let range = syntax_selection.next_range();
+        assert_eq!(range, Some(range_zero));
+        assert_eq!(syntax_selection.current_selection, Some(0));
+
+        let range = syntax_selection.next_range();
+        assert_eq!(range, Some(range_one));
+        assert_eq!(syntax_selection.current_selection, Some(1));
+
+        let range = syntax_selection.next_range();
+        assert_eq!(range, Some(range_two));
+        assert_eq!(syntax_selection.current_selection, Some(2));
+
+        // Ensure we are not going out of bound
+        let range = syntax_selection.next_range();
+        assert_eq!(range, Some(range_two));
+        assert_eq!(syntax_selection.current_selection, Some(2));
+
+        // Going backward now
+        let range = syntax_selection.previous_range();
+        assert_eq!(range, Some(range_one));
+        assert_eq!(syntax_selection.current_selection, Some(1));
+
+        let range = syntax_selection.previous_range();
+        assert_eq!(range, Some(range_zero));
+        assert_eq!(syntax_selection.current_selection, Some(0));
+
+        // Ensure we are not going below zero
+        let range = syntax_selection.previous_range();
+        assert_eq!(range, Some(range_zero));
+        assert_eq!(syntax_selection.current_selection, Some(0));
+    }
+}
diff --git a/lapce-data/src/settings.rs b/lapce-data/src/settings.rs
index c00f1e9ec6..40c6f2bebf 100644
--- a/lapce-data/src/settings.rs
+++ b/lapce-data/src/settings.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use druid::{Command, Env, EventCtx, Modifiers, Target, WidgetId};
 use lapce_core::{
     command::{EditCommand, FocusCommand, MoveCommand},
@@ -7,21 +9,31 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     command::{CommandExecuted, CommandKind, LapceUICommand, LAPCE_UI_COMMAND},
+    config::LapceConfig,
     data::LapceMainSplitData,
+    dropdown::DropdownData,
     keypress::KeyPressFocus,
     split::SplitDirection,
 };
+use lapce_rpc::plugin::VoltID;
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum SettingsValueKind {
     String,
-    Number,
+    Integer,
+    Float,
     Bool,
 }
 
+#[derive(Hash, Eq, PartialEq, Clone)]
 pub enum LapceSettingsKind {
     Core,
+    UI,
     Editor,
+    Terminal,
+    Theme,
+    Keymap,
+    Plugin(VoltID),
 }
 
 #[derive(Clone)]
@@ -35,6 +47,10 @@ pub struct LapceSettingsPanelData {
     pub settings_widget_id: WidgetId,
     pub settings_view_id: WidgetId,
     pub settings_split_id: WidgetId,
+
+    /// Mapping of setting key to dropdown data for that key
+    pub dropdown_data:
+        im::HashMap<String, im::HashMap<String, DropdownData<String, ()>>>,
 }
 
 impl KeyPressFocus for LapceSettingsPanelData {
@@ -83,6 +99,8 @@ impl LapceSettingsPanelData {
             settings_widget_id: WidgetId::next(),
             settings_view_id: WidgetId::next(),
             settings_split_id: WidgetId::next(),
+
+            dropdown_data: im::HashMap::new(),
         }
     }
 }
@@ -98,6 +116,7 @@ pub struct LapceSettingsFocusData {
     pub widget_id: WidgetId,
     pub editor_tab_id: WidgetId,
     pub main_split: LapceMainSplitData,
+    pub config: Arc<LapceConfig>,
 }
 
 impl KeyPressFocus for LapceSettingsFocusData {
@@ -124,10 +143,11 @@ impl KeyPressFocus for LapceSettingsFocusData {
                         ctx,
                         self.editor_tab_id,
                         SplitDirection::Vertical,
+                        &self.config,
                     );
                 }
                 FocusCommand::SplitClose => {
-                    self.main_split.settings_close(
+                    self.main_split.widget_close(
                         ctx,
                         self.widget_id,
                         self.editor_tab_id,
diff --git a/lapce-data/src/signature.rs b/lapce-data/src/signature.rs
index 5ccec7279a..371e54ca89 100644
--- a/lapce-data/src/signature.rs
+++ b/lapce-data/src/signature.rs
@@ -1,64 +1,122 @@
-use lsp_types::ParameterLabel;
-use lsp_types::SignatureHelp;
+use std::{path::PathBuf, sync::Arc};
 
-#[derive(Clone)]
-pub struct SignatureState {
-    pub offset: Option<usize>,
-    pub signature: Option<SignatureHelp>,
-    pub active: Option<(usize, usize)>,
+use druid::{Size, WidgetId};
+use lapce_rpc::{buffer::BufferId, plugin::PluginId};
+use lsp_types::{Position, SignatureHelp, SignatureInformation};
+
+use crate::proxy::LapceProxy;
+
+#[derive(Clone, PartialEq, Eq)]
+pub enum SignatureStatus {
+    Inactive,
+    Started,
 }
 
-impl SignatureState {
+/// Data for the LSP Signature Help command, which displays information about the signature
+/// of the function that that the user is calling.
+#[derive(Clone)]
+pub struct SignatureData {
+    /// Id of the signature view widget
+    pub id: WidgetId,
+    /// Id of the scroll widget within the signature view widget
+    pub scroll_id: WidgetId,
+    pub request_id: usize,
+    pub status: SignatureStatus,
+    pub buffer_id: BufferId,
+    /// The offset into the current buffer that the signature was being used at
+    /// This is for positionng the signature information
+    pub offset: usize,
+    /// Size of the signature view
+    pub size: Size,
+
+    // TODO: Allow switching between the signatures.
+    // (Since we request an update for the signature often, the LSP should swap
+    // the active parameter if it gets a better idea of the type, which will cover most cases)
+    pub signatures: Vec<SignatureInformation>,
+    pub current_signature: usize,
+    /// The currently parameter the user is editing
+    pub active_parameter: Option<usize>,
+}
+impl SignatureData {
     pub fn new() -> Self {
         Self {
-            offset: None,
-            signature: None,
-            active: None,
+            id: WidgetId::next(),
+            scroll_id: WidgetId::next(),
+            request_id: 0,
+            status: SignatureStatus::Inactive,
+            buffer_id: BufferId(0),
+            offset: 0,
+            // TODO: Let the user customize this
+            size: Size::new(400.0, 100.0),
+
+            signatures: Vec::new(),
+            current_signature: 0,
+            active_parameter: None,
         }
     }
 
-    pub fn update(&mut self, offset: usize, commas: Vec<usize>) -> Option<bool> {
-        let signature = self.signature.as_ref()?;
-        let params = signature.signatures[0].parameters.as_ref()?;
-        if params.is_empty() {
-            return None;
-        }
-        let mut index = commas.len();
-        for (i, c) in commas.iter().enumerate() {
-            if offset <= *c {
-                index = i;
-                break;
-            }
+    /// Check if there are any signatures available
+    pub fn is_empty(&self) -> bool {
+        self.signatures.is_empty()
+    }
+
+    /// Get the currently active signature entry, if one exists
+    pub fn current(&self) -> Option<&SignatureInformation> {
+        self.signatures.get(self.current_signature)
+    }
+
+    pub fn request(
+        &self,
+        proxy: Arc<LapceProxy>,
+        request_id: usize,
+        path: PathBuf,
+        position: Position,
+    ) {
+        proxy.proxy_rpc.signature_help(request_id, path, position);
+    }
+
+    pub fn cancel(&mut self) {
+        if self.status == SignatureStatus::Inactive {
+            return;
         }
 
-        let label = signature.signatures[0].label.clone();
-        let active = if index >= params.len() {
-            None
-        } else {
-            match &params[index].label {
-                ParameterLabel::Simple(s) => {
-                    let start = label.find(s)?;
-                    Some((start, start + s.len()))
-                }
-                ParameterLabel::LabelOffsets(offsets) => {
-                    Some((offsets[0] as usize, offsets[1] as usize))
-                }
-            }
-        };
-
-        let changed = self.active != active;
-        self.active = active;
-        Some(changed)
+        self.signatures.clear();
+        self.current_signature = 0;
+        self.active_parameter = None;
+        self.status = SignatureStatus::Inactive;
     }
 
-    pub fn clear(&mut self) {
-        self.offset = None;
-        self.signature = None;
-        self.active = None;
+    pub fn receive(
+        &mut self,
+        request_id: usize,
+        resp: SignatureHelp,
+        _plugin_id: PluginId,
+    ) {
+        if self.status == SignatureStatus::Inactive || self.request_id != request_id
+        {
+            return;
+        }
+
+        let signatures = resp.signatures;
+        let active_sig_idx = resp.active_signature.unwrap_or(0) as usize;
+        let active_sig_idx = signatures
+            .get(active_sig_idx)
+            .map(|_| active_sig_idx)
+            .unwrap_or(0);
+        // TODO: If the active sig idx isn't defined then we can make a somewhat better than 0
+        // guess by using the current active parameter to trim out any signatures with too
+        // few parameters
+        let active_parameter = resp.active_parameter.map(|idx| idx as usize);
+
+        self.signatures = signatures;
+        self.current_signature = active_sig_idx;
+        self.active_parameter = active_parameter;
+
+        // Updating of the text layouts for the UI is done in `SignatureContainer::update_signature`
     }
 }
 
-impl Default for SignatureState {
+impl Default for SignatureData {
     fn default() -> Self {
         Self::new()
     }
diff --git a/lapce-data/src/source_control.rs b/lapce-data/src/source_control.rs
index ec978722ba..ebf04e2ebc 100644
--- a/lapce-data/src/source_control.rs
+++ b/lapce-data/src/source_control.rs
@@ -1,4 +1,7 @@
+use std::path::PathBuf;
+
 use druid::{Command, Env, EventCtx, Modifiers, Target, WidgetId};
+use indexmap::IndexMap;
 use lapce_core::{
     command::{FocusCommand, MoveCommand},
     mode::Mode,
@@ -24,9 +27,11 @@ pub struct SourceControlData {
     pub file_list_id: WidgetId,
     pub file_list_index: usize,
     pub editor_view_id: WidgetId,
-    pub file_diffs: Vec<(FileDiff, bool)>,
+    pub commit_button_id: WidgetId,
+    // VCS modified files & whether they should be included in the next commit
+    pub file_diffs: IndexMap<PathBuf, (FileDiff, bool)>,
     pub branch: String,
-    pub branches: Vec<String>,
+    pub branches: im::Vector<String>,
 }
 
 impl SourceControlData {
@@ -39,11 +44,12 @@ impl SourceControlData {
             editor_view_id,
             file_list_id,
             file_list_index: 0,
+            commit_button_id: WidgetId::next(),
             split_id: WidgetId::next(),
             split_direction: SplitDirection::Horizontal,
-            file_diffs: Vec::new(),
+            file_diffs: IndexMap::new(),
             branch: "".to_string(),
-            branches: Vec::new(),
+            branches: im::Vector::new(),
         }
     }
 }
@@ -180,13 +186,15 @@ impl KeyPressFocus for SourceControlData {
                     if !self.file_diffs.is_empty() {
                         ctx.submit_command(Command::new(
                             LAPCE_UI_COMMAND,
-                            LapceUICommand::OpenFileDiff(
-                                self.file_diffs[self.file_list_index]
+                            LapceUICommand::OpenFileDiff {
+                                path: self
+                                    .file_diffs
+                                    .get_index(self.file_list_index)
+                                    .unwrap()
                                     .0
-                                    .path()
                                     .clone(),
-                                "head".to_string(),
-                            ),
+                                history: "head".to_string(),
+                            },
                             Target::Auto,
                         ));
                     }
diff --git a/lapce-data/src/split.rs b/lapce-data/src/split.rs
index 8c6ffc4a98..a96b723024 100644
--- a/lapce-data/src/split.rs
+++ b/lapce-data/src/split.rs
@@ -1,4 +1,4 @@
-use druid::Size;
+use druid::{Rect, Size};
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug)]
@@ -9,7 +9,7 @@ pub enum SplitMoveDirection {
     Left,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum SplitDirection {
     Vertical,
     Horizontal,
@@ -29,4 +29,11 @@ impl SplitDirection {
             SplitDirection::Horizontal => size.width,
         }
     }
+
+    pub fn start(self, rect: Rect) -> f64 {
+        match self {
+            SplitDirection::Vertical => rect.x0,
+            SplitDirection::Horizontal => rect.y0,
+        }
+    }
 }
diff --git a/lapce-data/src/svg.rs b/lapce-data/src/svg.rs
new file mode 100644
index 0000000000..62a616b8e8
--- /dev/null
+++ b/lapce-data/src/svg.rs
@@ -0,0 +1,68 @@
+use std::{
+    collections::HashMap,
+    fs,
+    path::{Path, PathBuf},
+    str::FromStr,
+};
+
+use druid::piet::Svg;
+use include_dir::{include_dir, Dir};
+
+use crate::config::LOGO;
+
+const CODICONS_ICONS_DIR: Dir = include_dir!("../icons/codicons");
+const LAPCE_ICONS_DIR: Dir = include_dir!("../icons/lapce");
+
+pub struct SvgStore {
+    svgs: HashMap<String, Svg>,
+    svgs_on_disk: HashMap<PathBuf, Option<Svg>>,
+}
+
+impl Default for SvgStore {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SvgStore {
+    fn new() -> Self {
+        let mut svgs = HashMap::new();
+        svgs.insert("lapce_logo".to_string(), Svg::from_str(LOGO).unwrap());
+
+        Self {
+            svgs,
+            svgs_on_disk: HashMap::new(),
+        }
+    }
+
+    pub fn logo_svg(&self) -> Svg {
+        self.svgs.get("lapce_logo").unwrap().clone()
+    }
+
+    pub fn get_default_svg(&mut self, name: &str) -> Svg {
+        if !self.svgs.contains_key(name) {
+            let file = if name == "lapce_remote.svg" {
+                LAPCE_ICONS_DIR.get_file(name).unwrap()
+            } else {
+                CODICONS_ICONS_DIR
+                    .get_file(name)
+                    .unwrap_or_else(|| panic!("Failed to unwrap {name}"))
+            };
+            let content = file.contents_utf8().unwrap();
+            let svg = Svg::from_str(content).unwrap();
+            self.svgs.insert(name.to_string(), svg);
+        }
+        self.svgs.get(name).unwrap().clone()
+    }
+
+    pub fn get_svg_on_disk(&mut self, path: &Path) -> Option<Svg> {
+        if !self.svgs_on_disk.contains_key(path) {
+            let svg = fs::read_to_string(path)
+                .ok()
+                .and_then(|content| Svg::from_str(&content).ok());
+            self.svgs_on_disk.insert(path.to_path_buf(), svg);
+        }
+
+        self.svgs_on_disk.get(path).unwrap().clone()
+    }
+}
diff --git a/lapce-data/src/terminal.rs b/lapce-data/src/terminal.rs
index 678b92db3e..b13e42cce2 100644
--- a/lapce-data/src/terminal.rs
+++ b/lapce-data/src/terminal.rs
@@ -6,19 +6,20 @@ use alacritty_terminal::{
     grid::{Dimensions, Scroll},
     index::{Direction, Side},
     selection::{Selection, SelectionType},
-    term::{search::RegexSearch, SizeInfo, TermMode},
+    term::{search::RegexSearch, test::TermSize, TermMode},
     vi_mode::ViMotion,
     Term,
 };
 use druid::{
-    keyboard_types::Key, Application, Color, Command, Env, EventCtx, ExtEventSink,
-    KeyEvent, Modifiers, Target, WidgetId,
+    keyboard_types::Key, Color, Command, Env, EventCtx, ExtEventSink, KeyEvent,
+    Modifiers, Target, WidgetId,
 };
 use hashbrown::HashMap;
 use lapce_core::{
     command::{EditCommand, FocusCommand},
     mode::{Mode, VisualMode},
     movement::{LinePosition, Movement},
+    register::Clipboard,
 };
 use lapce_rpc::terminal::TermId;
 use parking_lot::Mutex;
@@ -27,8 +28,9 @@ use crate::{
     command::{
         CommandExecuted, CommandKind, LapceCommand, LapceUICommand, LAPCE_UI_COMMAND,
     },
-    config::{Config, LapceTheme},
+    config::{LapceConfig, LapceTheme},
     data::LapceWorkspace,
+    document::SystemClipboard,
     find::Find,
     keypress::KeyPressFocus,
     proxy::LapceProxy,
@@ -37,31 +39,114 @@ use crate::{
 
 pub type TermConfig = alacritty_terminal::config::Config;
 
+#[derive(Clone)]
+pub struct TerminalPanelData {
+    pub widget_id: WidgetId,
+    pub tabs: im::HashMap<WidgetId, TerminalSplitData>,
+    pub tabs_order: Arc<Vec<WidgetId>>,
+    pub active: usize,
+}
+
+impl TerminalPanelData {
+    pub fn new(
+        worksapce: Arc<LapceWorkspace>,
+        proxy: Arc<LapceProxy>,
+        config: &LapceConfig,
+        event_sink: ExtEventSink,
+    ) -> Self {
+        let split = TerminalSplitData::new(worksapce, proxy, config, event_sink);
+        let tabs_order = Arc::new(vec![split.split_id]);
+        let mut tabs = im::HashMap::new();
+        tabs.insert(split.split_id, split);
+        Self {
+            widget_id: WidgetId::next(),
+            tabs,
+            tabs_order,
+            active: 0,
+        }
+    }
+
+    pub fn active_terminal(&self) -> Option<Arc<LapceTerminalData>> {
+        self.active_terminal_split()
+            .and_then(|t| t.terminals.get(&t.active_term_id))
+            .cloned()
+    }
+
+    pub fn active_terminal_mut(&mut self) -> Option<&mut LapceTerminalData> {
+        self.active_terminal_split_mut()
+            .and_then(|t| t.terminals.get_mut(&t.active_term_id))
+            .map(Arc::make_mut)
+    }
+
+    pub fn active_terminal_split(&self) -> Option<&TerminalSplitData> {
+        self.tabs_order
+            .get(self.active)
+            .or_else(|| self.tabs_order.last())
+            .and_then(|id| self.tabs.get(id))
+    }
+
+    pub fn active_terminal_split_mut(&mut self) -> Option<&mut TerminalSplitData> {
+        self.tabs_order
+            .get(self.active)
+            .or_else(|| self.tabs_order.last())
+            .and_then(|id| self.tabs.get_mut(id))
+    }
+
+    pub fn new_tab(
+        &mut self,
+        workspace: Arc<LapceWorkspace>,
+        proxy: Arc<LapceProxy>,
+        config: &LapceConfig,
+        event_sink: ExtEventSink,
+    ) {
+        let active_index = (self.active + 1).min(self.tabs_order.len());
+        let new_term_split =
+            TerminalSplitData::new(workspace, proxy, config, event_sink);
+        let new_term_tab_id = new_term_split.split_id;
+        Arc::make_mut(&mut self.tabs_order).insert(active_index, new_term_tab_id);
+        self.tabs.insert(new_term_tab_id, new_term_split);
+        self.active = active_index;
+    }
+}
+
 #[derive(Clone)]
 pub struct TerminalSplitData {
     pub active: WidgetId,
     pub active_term_id: TermId,
-    pub widget_id: WidgetId,
     pub split_id: WidgetId,
     pub terminals: im::HashMap<TermId, Arc<LapceTerminalData>>,
     pub indexed_colors: Arc<HashMap<u8, Color>>,
 }
 
 impl TerminalSplitData {
-    pub fn new(_proxy: Arc<LapceProxy>) -> Self {
+    pub fn new(
+        workspace: Arc<LapceWorkspace>,
+        proxy: Arc<LapceProxy>,
+        config: &LapceConfig,
+        event_sink: ExtEventSink,
+    ) -> Self {
         let split_id = WidgetId::next();
-        let terminals = im::HashMap::new();
+        let terminal_data = Arc::new(LapceTerminalData::new(
+            workspace, split_id, event_sink, proxy, config,
+        ));
+        let term_id = terminal_data.term_id;
+        let widget_id = terminal_data.widget_id;
+        let mut terminals = im::HashMap::new();
+        terminals.insert(term_id, terminal_data);
 
         Self {
-            active_term_id: TermId::next(),
-            active: WidgetId::next(),
-            widget_id: WidgetId::next(),
+            active_term_id: term_id,
+            active: widget_id,
             split_id,
             terminals,
             indexed_colors: Arc::new(Self::get_indexed_colors()),
         }
     }
 
+    pub fn active_terminal(&self) -> Option<&Arc<LapceTerminalData>> {
+        self.terminals.get(&self.active_term_id)
+    }
+
     pub fn get_indexed_colors() -> HashMap<u8, Color> {
         let mut indexed_colors = HashMap::new();
         // Build colors.
@@ -95,7 +180,7 @@ impl TerminalSplitData {
         &self,
         color: &ansi::Color,
         colors: &alacritty_terminal::term::color::Colors,
-        config: &Config,
+        config: &LapceConfig,
     ) -> Color {
         match color {
             ansi::Color::Named(color) => self.get_named_color(color, config),
@@ -131,7 +216,11 @@ impl TerminalSplitData {
         }
     }
 
-    fn get_named_color(&self, color: &ansi::NamedColor, config: &Config) -> Color {
+    fn get_named_color(
+        &self,
+        color: &ansi::NamedColor,
+        config: &LapceConfig,
+    ) -> Color {
         let (color, alpha) = match color {
             ansi::NamedColor::Cursor => (LapceTheme::TERMINAL_CURSOR, 1.0),
             ansi::NamedColor::Foreground => (LapceTheme::TERMINAL_FOREGROUND, 1.0),
@@ -183,7 +272,7 @@ impl TerminalSplitData {
 
 pub struct LapceTerminalViewData {
     pub terminal: Arc<LapceTerminalData>,
-    pub config: Arc<Config>,
+    pub config: Arc<LapceConfig>,
     pub find: Arc<Find>,
 }
 
@@ -193,7 +282,7 @@ impl LapceTerminalViewData {
     }
 
     fn toggle_visual(&mut self, visual_mode: VisualMode) {
-        if !self.config.lapce.modal {
+        if !self.config.core.modal {
             return;
         }
 
@@ -239,7 +328,9 @@ impl LapceTerminalViewData {
         if let Some(command) = LapceTerminalData::resolve_key_event(key) {
             self.terminal
                 .proxy
+                .proxy_rpc
                 .terminal_write(self.terminal.term_id, command.as_ref());
+            self.terminal.raw.lock().term.scroll_display(Scroll::Bottom);
         }
     }
 }
@@ -261,6 +352,7 @@ impl KeyPressFocus for LapceTerminalViewData {
         _mods: Modifiers,
         _env: &Env,
     ) -> CommandExecuted {
+        let mut clipboard = SystemClipboard {};
         ctx.request_paint();
         match &command.kind {
             CommandKind::Move(cmd) => {
@@ -317,7 +409,7 @@ impl KeyPressFocus for LapceTerminalViewData {
             }
             CommandKind::Edit(cmd) => match cmd {
                 EditCommand::NormalMode => {
-                    if !self.config.lapce.modal {
+                    if !self.config.core.modal {
                         return CommandExecuted::Yes;
                     }
                     self.terminal_mut().mode = Mode::Normal;
@@ -355,13 +447,30 @@ impl KeyPressFocus for LapceTerminalViewData {
                     let mut raw = self.terminal.raw.lock();
                     let term = &mut raw.term;
                     if let Some(content) = term.selection_to_string() {
-                        Application::global().clipboard().put_string(content);
+                        clipboard.put_string(content);
+                    }
+                    if self.terminal.mode != Mode::Terminal {
+                        self.terminal.clear_selection(term);
                     }
-                    self.terminal.clear_selection(term);
                 }
                 EditCommand::ClipboardPaste => {
-                    if let Some(s) = Application::global().clipboard().get_string() {
-                        self.receive_char(ctx, &s);
+                    let mut check_bracketed_paste: bool = false;
+                    if self.terminal.mode == Mode::Terminal {
+                        let mut raw = self.terminal.raw.lock();
+                        let term = &mut raw.term;
+                        self.terminal.clear_selection(term);
+                        if term.mode().contains(TermMode::BRACKETED_PASTE) {
+                            check_bracketed_paste = true;
+                        }
+                    }
+                    if let Some(s) = clipboard.get_string() {
+                        if check_bracketed_paste {
+                            self.receive_char(ctx, "\x1b[200~");
+                            self.receive_char(ctx, &s.replace('\x1b', ""));
+                            self.receive_char(ctx, "\x1b[201~");
+                        } else {
+                            self.receive_char(ctx, &s);
+                        }
                     }
                 }
                 _ => return CommandExecuted::No,
@@ -454,7 +563,11 @@ impl KeyPressFocus for LapceTerminalViewData {
 
     fn receive_char(&mut self, _ctx: &mut EventCtx, c: &str) {
         if self.terminal.mode == Mode::Terminal {
-            self.terminal.proxy.terminal_write(self.terminal.term_id, c);
+            self.terminal
+                .proxy
+                .proxy_rpc
+                .terminal_write(self.terminal.term_id, c);
+            self.terminal.raw.lock().term.scroll_display(Scroll::Bottom);
         }
     }
 }
@@ -466,11 +579,9 @@ pub struct RawTerminal {
 }
 
 impl RawTerminal {
-    pub fn update_content(&mut self, content: &str) {
-        if let Ok(content) = base64::decode(content) {
-            for byte in content {
-                self.parser.advance(&mut self.term, byte);
-            }
+    pub fn update_content(&mut self, content: Vec<u8>) {
+        for byte in content {
+            self.parser.advance(&mut self.term, byte);
         }
     }
 }
@@ -482,14 +593,14 @@ impl RawTerminal {
         event_sink: ExtEventSink,
     ) -> Self {
         let config = TermConfig::default();
-        let size = SizeInfo::new(50.0, 30.0, 1.0, 1.0, 0.0, 0.0, true);
         let event_proxy = EventProxy {
             proxy,
             event_sink,
             term_id,
         };
 
-        let term = Term::new(&config, size, event_proxy);
+        let size = TermSize::new(50, 30);
+        let term = Term::new(&config, &size, event_proxy);
         let parser = ansi::Processor::new();
 
         Self {
@@ -519,7 +630,7 @@ impl LapceTerminalData {
         split_id: WidgetId,
         event_sink: ExtEventSink,
         proxy: Arc<LapceProxy>,
-        config: &Config,
+        config: &LapceConfig,
     ) -> Self {
         let cwd = workspace.path.as_ref().cloned();
         let widget_id = WidgetId::next();
@@ -534,6 +645,14 @@ impl LapceTerminalData {
         let local_proxy = proxy.clone();
         let local_raw = raw.clone();
         let shell = config.terminal.shell.clone();
+
+        // TODO: replace with profile name, once we implement terminal profiles
+        let title = if !shell.is_empty() {
+            shell.clone()
+        } else {
+            String::from("(no title)")
+        };
+
         std::thread::spawn(move || {
             local_proxy.new_terminal(term_id, cwd, shell, local_raw);
         });
@@ -543,7 +662,7 @@ impl LapceTerminalData {
             widget_id,
             view_id,
             split_id,
-            title: "".to_string(),
+            title,
             mode: Mode::Terminal,
             visual_mode: VisualMode::Normal,
             raw,
@@ -552,15 +671,17 @@ impl LapceTerminalData {
     }
 
     pub fn resize(&self, width: usize, height: usize) {
-        let size =
-            SizeInfo::new(width as f32, height as f32, 1.0, 1.0, 0.0, 0.0, true);
+        let width = width.max(1);
+        let height = height.max(1);
+
+        let size = TermSize::new(width, height);
 
         let raw = self.raw.clone();
         let proxy = self.proxy.clone();
         let term_id = self.term_id;
         std::thread::spawn(move || {
             raw.lock().term.resize(size);
-            proxy.terminal_resize(term_id, width, height);
+            proxy.proxy_rpc.terminal_resize(term_id, width, height);
         });
     }
 
@@ -582,7 +703,7 @@ impl LapceTerminalData {
         search_string: &str,
         direction: Direction,
     ) {
-        if let Ok(dfas) = RegexSearch::new(search_string) {
+        if let Ok(dfas) = RegexSearch::new(&regex::escape(search_string)) {
             let mut point = term.renderable_content().cursor.point;
             if direction == Direction::Right {
                 if point.column.0 < term.last_column() {
@@ -777,8 +898,10 @@ impl LapceTerminalData {
             Key::Backspace => {
                 Some(if key.mods.ctrl() {
                     "\x08" // backspace
+                } else if key.mods.alt() {
+                    "\x1b\x7f"
                 } else {
-                    "\x7f" // DEL
+                    "\x7f"
                 })
             }
 
@@ -813,7 +936,7 @@ impl EventListener for EventProxy {
     fn send_event(&self, event: alacritty_terminal::event::Event) {
         match event {
             alacritty_terminal::event::Event::PtyWrite(s) => {
-                self.proxy.terminal_write(self.term_id, &s);
+                self.proxy.proxy_rpc.terminal_write(self.term_id, &s);
             }
             alacritty_terminal::event::Event::Title(title) => {
                 let _ = self.event_sink.submit_command(
diff --git a/lapce-data/src/title.rs b/lapce-data/src/title.rs
new file mode 100644
index 0000000000..75a62b81cc
--- /dev/null
+++ b/lapce-data/src/title.rs
@@ -0,0 +1,77 @@
+use std::sync::Arc;
+
+use druid::{Env, EventCtx, Point, WidgetId};
+use lapce_core::{command::FocusCommand, mode::Mode};
+
+use crate::{
+    command::{CommandExecuted, CommandKind, LapceCommand},
+    config::LapceConfig,
+    keypress::KeyPressFocus,
+    list::ListData,
+};
+
+#[derive(Clone)]
+pub struct TitleData {
+    pub widget_id: WidgetId,
+    pub branches: BranchListData,
+}
+
+impl TitleData {
+    pub fn new(config: Arc<LapceConfig>) -> TitleData {
+        let widget_id = WidgetId::next();
+        TitleData {
+            widget_id,
+            branches: BranchListData::new(config, widget_id),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct BranchListData {
+    pub filter_editor: WidgetId,
+    pub list: ListData<String, ()>,
+    pub active: bool,
+    /// The origin the list should appear at, this is updated whenever the
+    /// branch list is opened in the titlebar
+    pub origin: Point,
+}
+impl BranchListData {
+    fn new(config: Arc<LapceConfig>, parent: WidgetId) -> Self {
+        let list = ListData::new(config, parent, ());
+        BranchListData {
+            filter_editor: WidgetId::next(),
+            list,
+            active: false,
+            origin: Point::ZERO,
+        }
+    }
+}
+
+impl KeyPressFocus for BranchListData {
+    fn get_mode(&self) -> Mode {
+        Mode::Insert
+    }
+
+    fn check_condition(&self, condition: &str) -> bool {
+        matches!(condition, "list_focus" | "modal_focus")
+    }
+
+    fn run_command(
+        &mut self,
+        ctx: &mut EventCtx,
+        command: &LapceCommand,
+        _count: Option<usize>,
+        _mods: druid::Modifiers,
+        _env: &Env,
+    ) -> CommandExecuted {
+        if let CommandKind::Focus(FocusCommand::ModalClose) = command.kind {
+            self.active = false;
+            return CommandExecuted::Yes;
+        }
+        self.list.run_command(ctx, command)
+    }
+
+    fn receive_char(&mut self, _ctx: &mut EventCtx, _c: &str) {
+        // Currently, this does not have any sort of input (such as for filtering)
+    }
+}
diff --git a/lapce-data/src/update.rs b/lapce-data/src/update.rs
new file mode 100644
index 0000000000..b670e2ab50
--- /dev/null
+++ b/lapce-data/src/update.rs
@@ -0,0 +1,223 @@
+use std::path::{Path, PathBuf};
+
+use anyhow::{anyhow, Result};
+use lapce_core::{directory::Directory, meta};
+use serde::Deserialize;
+
+#[derive(Clone, Deserialize)]
+pub struct ReleaseInfo {
+    pub tag_name: String,
+    pub target_commitish: String,
+    pub assets: Vec<ReleaseAsset>,
+    #[serde(skip)]
+    pub version: String,
+}
+
+#[derive(Clone, Deserialize)]
+pub struct ReleaseAsset {
+    pub name: String,
+    pub browser_download_url: String,
+}
+
+pub fn get_latest_release() -> Result<ReleaseInfo> {
+    let url = match *meta::RELEASE {
+        "Debug" => {
+            return Err(anyhow!("no release for debug"));
+        }
+        "Nightly" => {
+            "https://api.github.com/repos/lapce/lapce/releases/tags/nightly"
+        }
+        _ => "https://api.github.com/repos/lapce/lapce/releases/latest",
+    };
+
+    let resp = reqwest::blocking::ClientBuilder::new()
+        .user_agent("Lapce")
+        .build()?
+        .get(url)
+        .send()?;
+    if !resp.status().is_success() {
+        return Err(anyhow!("get release info failed {}", resp.text()?));
+    }
+    let mut release: ReleaseInfo = serde_json::from_str(&resp.text()?)?;
+
+    release.version = match release.tag_name.as_str() {
+        "nightly" => format!("nightly-{}", &release.target_commitish[..7]),
+        _ => release.tag_name[1..].to_string(),
+    };
+
+    Ok(release)
+}
+
+pub fn download_release(release: &ReleaseInfo) -> Result<PathBuf> {
+    let dir =
+        Directory::updates_directory().ok_or_else(|| anyhow!("no directory"))?;
+    let name = match std::env::consts::OS {
+        "macos" => "Lapce-macos.dmg",
+        "linux" => "Lapce-linux.tar.gz",
+        #[cfg(feature = "portable")]
+        "windows" => "Lapce-windows-portable.zip",
+        #[cfg(not(feature = "portable"))]
+        "windows" => "Lapce-windows.msi",
+        _ => return Err(anyhow!("os not supported")),
+    };
+    let file_path = dir.join(name);
+
+    for asset in &release.assets {
+        if asset.name == name {
+            let mut resp = reqwest::blocking::get(&asset.browser_download_url)?;
+            if !resp.status().is_success() {
+                return Err(anyhow!("download file error {}", resp.text()?));
+            }
+            let mut out = std::fs::File::create(&file_path)?;
+            resp.copy_to(&mut out)?;
+            return Ok(file_path);
+        }
+    }
+
+    Err(anyhow!("can't download release"))
+}
+
+#[cfg(target_os = "macos")]
+pub fn extract(src: &Path, process_path: &Path) -> Result<PathBuf> {
+    let info = dmg::Attach::new(src).with()?;
+    let dest = process_path.parent().ok_or_else(|| anyhow!("no parent"))?;
+    let dest = if dest.file_name().and_then(|s| s.to_str()) == Some("MacOS") {
+        dest.parent().unwrap().parent().unwrap().parent().unwrap()
+    } else {
+        dest
+    };
+    let _ = std::fs::remove_dir_all(dest.join("Lapce.app"));
+    fs_extra::copy_items(
+        &[info.mount_point.join("Lapce.app")],
+        dest,
+        &fs_extra::dir::CopyOptions {
+            overwrite: true,
+            skip_exist: false,
+            buffer_size: 64000,
+            copy_inside: true,
+            content_only: false,
+            depth: 0,
+        },
+    )?;
+    Ok(dest.join("Lapce.app"))
+}
+
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
+pub fn extract(src: &Path, process_path: &Path) -> Result<PathBuf> {
+    let tar_gz = std::fs::File::open(src)?;
+    let tar = flate2::read::GzDecoder::new(tar_gz);
+    let mut archive = tar::Archive::new(tar);
+    let parent = src.parent().ok_or_else(|| anyhow::anyhow!("no parent"))?;
+    archive.unpack(parent)?;
+    std::fs::remove_file(process_path)?;
+    std::fs::copy(parent.join("Lapce").join("lapce"), process_path)?;
+    Ok(process_path.to_path_buf())
+}
+
+#[cfg(all(target_os = "windows", feature = "portable"))]
+pub fn extract(src: &Path, process_path: &Path) -> Result<PathBuf> {
+    let parent = src
+        .parent()
+        .ok_or_else(|| anyhow::anyhow!("src has no parent"))?;
+    let dst_parent = process_path
+        .parent()
+        .ok_or_else(|| anyhow::anyhow!("process_path has no parent"))?;
+
+    {
+        let mut archive = zip::ZipArchive::new(std::fs::File::open(src)?)?;
+        archive.extract(parent)?;
+    }
+
+    // TODO(dbuga): instead of replacing the exe, run the msi installer for non-portable
+    // TODO(dbuga): there's a very slight chance the user might end up with a backup file without a working .exe
+    std::fs::rename(process_path, dst_parent.join("lapce.exe.bak"))?;
+    std::fs::copy(parent.join("lapce.exe"), process_path)?;
+
+    Ok(process_path.to_path_buf())
+}
+
+#[cfg(all(target_os = "windows", not(feature = "portable")))]
+pub fn extract(src: &Path, _process_path: &Path) -> Result<PathBuf> {
+    // We downloaded an uncompressed msi installer, nothing to extract.
+    // On the other hand, we need to run this msi so pass its path back out.
+    Ok(src.to_path_buf())
+}
+
+#[cfg(target_os = "macos")]
+pub fn restart(path: &Path) -> Result<()> {
+    use std::os::unix::process::CommandExt;
+    std::process::Command::new("open")
+        .arg("-n")
+        .arg(path)
+        .arg("--args")
+        .arg("-n")
+        .exec();
+    Ok(())
+}
+
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
+pub fn restart(path: &Path) -> Result<()> {
+    use std::os::unix::process::CommandExt;
+    std::process::Command::new(path).arg("-n").exec();
+    Ok(())
+}
+
+#[cfg(all(target_os = "windows", feature = "portable"))]
+pub fn restart(path: &Path) -> Result<()> {
+    use std::os::windows::process::CommandExt;
+    const DETACHED_PROCESS: u32 = 0x00000008;
+    let process_id = std::process::id();
+    let path = path
+        .to_str()
+        .ok_or_else(|| anyhow!("can't get path to str"))?;
+    std::process::Command::new("cmd")
+        .raw_arg(format!(
+            r#"/C taskkill /PID {process_id} & start "" "{path}""#
+        ))
+        .creation_flags(DETACHED_PROCESS)
+        .spawn()?;
+    Ok(())
+}
+
+#[cfg(all(target_os = "windows", not(feature = "portable")))]
+
+pub fn restart(path: &Path) -> Result<()> {
+    use std::os::windows::process::CommandExt;
+    const DETACHED_PROCESS: u32 = 0x00000008;
+    let process_id = std::process::id();
+    let path = path
+        .to_str()
+        .ok_or_else(|| anyhow!("can't get path to str"))?;
+
+    let lapce_exe = std::env::current_exe()
+        .map_err(|err| anyhow!("can't get path to exe").context(err))?;
+    let lapce_exe = lapce_exe
+        .to_str()
+        .ok_or_else(|| anyhow!("can't convert exe path to str"))?;
+
+    std::process::Command::new("cmd")
+        .raw_arg(format!(
+            r#"/C taskkill /PID {process_id} & msiexec /i "{path}" /qb & start "" "{lapce_exe}""#,
+        ))
+        .creation_flags(DETACHED_PROCESS)
+        .spawn()?;
+    Ok(())
+}
+
+#[cfg(all(target_os = "windows", feature = "portable"))]
+pub fn cleanup() {
+    // Clean up backup exe after an update
+    if let Ok(process_path) = std::env::current_exe() {
+        if let Some(dst_parent) = process_path.parent() {
+            let _ = std::fs::remove_file(dst_parent.join("lapce.exe.bak"));
+        }
+    }
+}
+
+#[cfg(any(
+    not(target_os = "windows"),
+    all(target_os = "windows", not(feature = "portable"))
+))]
+pub fn cleanup() {
+    // Nothing to do yet
+}
diff --git a/lapce-proxy/Cargo.toml b/lapce-proxy/Cargo.toml
index 496aadc935..fe65578379 100644
--- a/lapce-proxy/Cargo.toml
+++ b/lapce-proxy/Cargo.toml
@@ -1,35 +1,75 @@
 [package]
 name = "lapce-proxy"
-version = "0.1.2"
-authors = ["Dongdong Zhou <dzhou121@gmail.com>"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
 
 [dependencies]
+alacritty_terminal.workspace = true
+anyhow.workspace = true
+clap.workspace = true
+crossbeam-channel.workspace = true
+directories.workspace = true
+flate2.workspace = true
+indexmap.workspace = true
+interprocess.workspace = true
+log.workspace = true
+notify.workspace = true
+once_cell.workspace = true
+parking_lot.workspace = true
+regex.workspace = true
+reqwest.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+strum.workspace = true
+strum_macros.workspace = true
+tar.workspace = true
+toml_edit.workspace = true
+
+lsp-types.workspace = true
+psp-types.workspace = true
+
+lapce-xi-rope.workspace = true
+
+lapce-core.workspace = true
+lapce-rpc.workspace = true
+
+# proxy specific dependencies
+
+url = "2.3.1"
+zstd = "0.11.2" # follow same version wasmtime-cache in lockfile
+dyn-clone = "1.0.10"
+walkdir = "2.3.2"
+globset = "0.4.9"
+locale_config = "0.3.0"
+mio = "0.6.20"
+jsonrpc-lite = "0.6.0"
+
+# finding terminal shell
 which = "4.2.5"
-regex = "1.5.6"
+
+# git
+git2 = { version = "0.16.1", features = ["vendored-openssl"] }
+
+# deleting files
+trash = "2.1.5"
+
+# search
+ignore = "0.4.18"
 grep-searcher = "0.1.8"
 grep-matcher = "0.1.5"
 grep-regex = "0.1.9"
-ignore = "0.4.18"
-reqwest = { version = "0.11", features = ["blocking", "json", "socks"] }
-wasmer = "2.1.1"
-wasmer-wasi = "2.1.1"
-directories = "4.0.1"
-locale_config = "0.3.0"
-base64 = "0.13.0"
-alacritty_terminal = "0.16"
-mio = "0.6.20"
-hotwatch = "0.4.6"
-notify = "5.0.0-pre.13"
-xi-rope = { git = "https://github.com/lapce/xi-editor", features = ["serde"] }
-serde = { version = "1.0", features = ["derive"] }
-lsp-types = { version = "0.89.2", features = ["proposed"] }
-parking_lot = { version = "0.11.0", features = ["deadlock_detection"] }
-crossbeam-channel = "0.5.0"
-jsonrpc-lite = "0.5.0"
-serde_json = "1.0.59"
-anyhow = "1.0.32"
-home = "0.5.3"
-toml = "0.5.6"
-git2 = { version = "0.14.4", features = ["vendored-openssl"] }
-lapce-rpc = { path = "../lapce-rpc" }
+
+# wasm
+wasmtime = "1.0.0"
+wasmtime-wasi = "1.0.0"
+wasi-common = "1.0.0"
+
+[dependencies.wasi-experimental-http-wasmtime]
+git = "https://github.com/lapce/wasi-experimental-http"
+# path = "../../wasi-experimental-http/crates/wasi-experimental-http-wasmtime"
+
+[target.'cfg(target_os = "macos")'.dependencies]
+cocoa = "0.24"
+objc = "0.2"
+libc = "0.2"
\ No newline at end of file
diff --git a/lapce-proxy/src/buffer.rs b/lapce-proxy/src/buffer.rs
index 580a11fe96..d86b5e8bb0 100644
--- a/lapce-proxy/src/buffer.rs
+++ b/lapce-proxy/src/buffer.rs
@@ -1,40 +1,36 @@
+use std::{
+    borrow::Cow,
+    ffi::OsString,
+    fs,
+    fs::File,
+    io::{Read, Write},
+    path::{Path, PathBuf},
+    time::SystemTime,
+};
+
 use anyhow::{anyhow, Result};
-use crossbeam_channel::Sender;
+use lapce_core::{
+    buffer::rope_text::CharIndicesJoin, encoding::offset_utf8_to_utf16,
+};
 use lapce_rpc::buffer::BufferId;
-use std::ffi::OsString;
-use std::fs;
-use std::fs::File;
-use std::io::Read;
-use std::io::Write;
-use std::path::PathBuf;
-use std::{borrow::Cow, path::Path, time::SystemTime};
-
+use lapce_xi_rope::{interval::IntervalBounds, rope::Rope, RopeDelta};
 use lsp_types::*;
-use xi_rope::{interval::IntervalBounds, rope::Rope, RopeDelta};
 
+#[derive(Clone)]
 pub struct Buffer {
-    pub language_id: String,
+    pub language_id: &'static str,
     pub id: BufferId,
     pub rope: Rope,
     pub path: PathBuf,
     pub rev: u64,
-    sender: Sender<(BufferId, u64)>,
     pub mod_time: Option<SystemTime>,
 }
 
 impl Buffer {
-    pub fn new(
-        id: BufferId,
-        path: PathBuf,
-        sender: Sender<(BufferId, u64)>,
-    ) -> Buffer {
-        let rope = if let Ok(rope) = load_rope(&path) {
-            rope
-        } else {
-            Rope::from("")
-        };
-        let rev = if rope.is_empty() { 0 } else { 1 };
-        let language_id = language_id_from_path(&path).unwrap_or("").to_string();
+    pub fn new(id: BufferId, path: PathBuf) -> Buffer {
+        let rope = Rope::from(load_file(&path).unwrap_or_default());
+        let rev = u64::from(!rope.is_empty());
+        let language_id = language_id_from_path(&path).unwrap_or("");
         let mod_time = get_mod_time(&path);
         Buffer {
             id,
@@ -42,7 +38,6 @@ impl Buffer {
             path,
             language_id,
             rev,
-            sender,
             mod_time,
         }
     }
@@ -59,20 +54,22 @@ impl Buffer {
                 ext
             },
         );
-        let tmp_path = &self.path.with_extension(tmp_extension);
+        let path = self.path.canonicalize()?;
+        let tmp_path = &path.with_extension(tmp_extension);
 
         let mut f = File::create(tmp_path)?;
         for chunk in self.rope.iter_chunks(..self.rope.len()) {
             f.write_all(chunk.as_bytes())?;
         }
 
-        if let Ok(metadata) = fs::metadata(&self.path) {
+        if let Ok(metadata) = fs::metadata(&path) {
             let perm = metadata.permissions();
             fs::set_permissions(tmp_path, perm)?;
         }
 
-        fs::rename(tmp_path, &self.path)?;
-        self.mod_time = get_mod_time(&self.path);
+        fs::rename(tmp_path, &path)?;
+        self.mod_time = get_mod_time(&path);
+
         Ok(())
     }
 
@@ -87,16 +84,13 @@ impl Buffer {
         self.rev += 1;
         let content_change = get_document_content_changes(delta, self);
         self.rope = delta.apply(&self.rope);
-        let content_change = match content_change {
-            Some(content_change) => content_change,
-            None => TextDocumentContentChangeEvent {
+        Some(
+            content_change.unwrap_or_else(|| TextDocumentContentChangeEvent {
                 range: None,
                 range_length: None,
                 text: self.get_document(),
-            },
-        };
-        let _ = self.sender.send((self.id, self.rev));
-        Some(content_change)
+            }),
+        )
     }
 
     pub fn get_document(&self) -> String {
@@ -116,11 +110,18 @@ impl Buffer {
         (line, offset - self.offset_of_line(line))
     }
 
+    /// Converts a UTF8 offset to a UTF16 LSP position  
     pub fn offset_to_position(&self, offset: usize) -> Position {
         let (line, col) = self.offset_to_line_col(offset);
+        // Get the offset of line to make the conversion cheaper, rather than working
+        // from the very start of the document to `offset`
+        let line_offset = self.offset_of_line(line);
+        let utf16_col =
+            offset_utf8_to_utf16(self.char_indices_iter(line_offset..), col);
+
         Position {
             line: line as u32,
-            character: col as u32,
+            character: utf16_col as u32,
         }
     }
 
@@ -128,6 +129,15 @@ impl Buffer {
         self.rope.slice_to_cow(range)
     }
 
+    /// Iterate over (utf8_offset, char) values in the given range  
+    /// This uses `iter_chunks` and so does not allocate, compared to `slice_to_cow` which can
+    pub fn char_indices_iter<T: IntervalBounds>(
+        &self,
+        range: T,
+    ) -> impl Iterator<Item = (usize, char)> + '_ {
+        CharIndicesJoin::new(self.rope.iter_chunks(range).map(str::char_indices))
+    }
+
     pub fn len(&self) -> usize {
         self.rope.len()
     }
@@ -138,24 +148,112 @@ impl Buffer {
 }
 
 pub fn load_file(path: &Path) -> Result<String> {
-    let mut f = File::open(path)?;
-    let mut bytes = Vec::new();
-    f.read_to_end(&mut bytes)?;
-    Ok(std::str::from_utf8(&bytes)?.to_string())
+    Ok(read_path_to_string_lossy(path)?)
 }
 
-fn load_rope(path: &Path) -> Result<Rope> {
-    let mut f = File::open(path)?;
-    let mut bytes = Vec::new();
-    f.read_to_end(&mut bytes)?;
-    Ok(Rope::from(std::str::from_utf8(&bytes)?))
+pub fn read_path_to_string_lossy<P: AsRef<Path>>(
+    path: P,
+) -> Result<String, std::io::Error> {
+    let path = path.as_ref();
+
+    let mut file = File::open(path)?;
+    // Read the file in as bytes
+    let mut buffer = Vec::new();
+    file.read_to_end(&mut buffer)?;
+
+    // Parse the file contents as utf8, replacing non-utf8 data with the
+    // replacement character
+    let contents = String::from_utf8_lossy(&buffer);
+
+    Ok(contents.to_string())
 }
 
-fn language_id_from_path(path: &Path) -> Option<&str> {
-    Some(match path.extension()?.to_str()? {
-        "rs" => "rust",
-        "go" => "go",
-        _ => return None,
+pub fn language_id_from_path(path: &Path) -> Option<&'static str> {
+    // recommended language_id values
+    // https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocumentItem
+    Some(match path.extension() {
+        Some(ext) => {
+            match ext.to_str()? {
+                "C" | "H" => "cpp",
+                "M" => "objective-c",
+                // stop case-sensitive matching
+                ext => match ext.to_lowercase().as_str() {
+                    "bat" => "bat",
+                    "clj" | "cljs" | "cljc" | "edn" => "clojure",
+                    "coffee" => "coffeescript",
+                    "c" | "h" => "c",
+                    "cpp" | "hpp" | "cxx" | "hxx" | "c++" | "h++" | "cc" | "hh" => {
+                        "cpp"
+                    }
+                    "cs" | "csx" => "csharp",
+                    "css" => "css",
+                    "d" | "di" | "dlang" => "dlang",
+                    "diff" | "patch" => "diff",
+                    "dart" => "dart",
+                    "dockerfile" => "dockerfile",
+                    "elm" => "elm",
+                    "ex" | "exs" => "elixir",
+                    "erl" | "hrl" => "erlang",
+                    "fs" | "fsi" | "fsx" | "fsscript" => "fsharp",
+                    "git-commit" | "git-rebase" => "git",
+                    "go" => "go",
+                    "groovy" | "gvy" | "gy" | "gsh" => "groovy",
+                    "hbs" => "handlebars",
+                    "htm" | "html" | "xhtml" => "html",
+                    "ini" => "ini",
+                    "java" | "class" => "java",
+                    "js" => "javascript",
+                    "jsx" => "javascriptreact",
+                    "json" => "json",
+                    "jl" => "julia",
+                    "kt" | "kts" => "kotlin",
+                    "less" => "less",
+                    "lua" => "lua",
+                    "makefile" | "gnumakefile" => "makefile",
+                    "md" | "markdown" => "markdown",
+                    "m" => "objective-c",
+                    "mm" => "objective-cpp",
+                    "plx" | "pl" | "pm" | "xs" | "t" | "pod" | "cgi" => "perl",
+                    "p6" | "pm6" | "pod6" | "t6" | "raku" | "rakumod"
+                    | "rakudoc" | "rakutest" => "perl6",
+                    "php" | "phtml" | "pht" | "phps" => "php",
+                    "proto" => "proto",
+                    "ps1" | "ps1xml" | "psc1" | "psm1" | "psd1" | "pssc"
+                    | "psrc" => "powershell",
+                    "py" | "pyi" | "pyc" | "pyd" | "pyw" => "python",
+                    "r" => "r",
+                    "rb" => "ruby",
+                    "rs" => "rust",
+                    "scss" | "sass" => "scss",
+                    "sc" | "scala" => "scala",
+                    "sh" | "bash" | "zsh" => "shellscript",
+                    "sql" => "sql",
+                    "swift" => "swift",
+                    "svelte" => "svelte",
+                    "toml" => "toml",
+                    "ts" => "typescript",
+                    "tsx" => "typescriptreact",
+                    "tex" => "tex",
+                    "vb" => "vb",
+                    "xml" => "xml",
+                    "xsl" => "xsl",
+                    "yml" | "yaml" => "yaml",
+                    "zig" => "zig",
+                    "vue" => "vue",
+                    _ => return None,
+                },
+            }
+        }
+        // Handle paths without extension
+        #[allow(clippy::match_single_binding)]
+        None => match path.file_name()?.to_str()? {
+            // case-insensitive matching
+            filename => match filename.to_lowercase().as_str() {
+                "dockerfile" => "dockerfile",
+                "makefile" | "gnumakefile" => "makefile",
+                _ => return None,
+            },
+        },
     })
 }
 
@@ -168,37 +266,34 @@ fn get_document_content_changes(
 
     // TODO: Handle more trivial cases like typing when there's a selection or transpose
     if let Some(node) = delta.as_simple_insert() {
-        let text = String::from(node);
-
         let (start, end) = interval.start_end();
-        let text_document_content_change_event = TextDocumentContentChangeEvent {
-            range: Some(Range {
-                start: buffer.offset_to_position(start),
-                end: buffer.offset_to_position(end),
-            }),
-            range_length: Some((end - start) as u32),
-            text,
-        };
+        let start = buffer.offset_to_position(start);
+
+        let end = buffer.offset_to_position(end);
 
-        return Some(text_document_content_change_event);
+        Some(TextDocumentContentChangeEvent {
+            range: Some(Range { start, end }),
+            range_length: None,
+            text: String::from(node),
+        })
     }
     // Or a simple delete
     else if delta.is_simple_delete() {
         let end_position = buffer.offset_to_position(end);
 
-        let text_document_content_change_event = TextDocumentContentChangeEvent {
+        let start = buffer.offset_to_position(start);
+
+        Some(TextDocumentContentChangeEvent {
             range: Some(Range {
-                start: buffer.offset_to_position(start),
+                start,
                 end: end_position,
             }),
-            range_length: Some((end - start) as u32),
+            range_length: None,
             text: String::new(),
-        };
-
-        return Some(text_document_content_change_event);
+        })
+    } else {
+        None
     }
-
-    None
 }
 
 /// Returns the modification timestamp for the file at a given path,
diff --git a/lapce-proxy/src/dispatch.rs b/lapce-proxy/src/dispatch.rs
index 2d0f0f3ed9..ffcb0ebd3c 100644
--- a/lapce-proxy/src/dispatch.rs
+++ b/lapce-proxy/src/dispatch.rs
@@ -1,355 +1,161 @@
-use crate::buffer::{get_mod_time, load_file, Buffer};
-use crate::lsp::LspCatalog;
-use crate::plugin::PluginCatalog;
-use crate::terminal::Terminal;
-use crate::watcher::{FileWatcher, Notify, WatchToken};
-use alacritty_terminal::event_loop::Msg;
-use alacritty_terminal::term::SizeInfo;
+use std::{
+    collections::{HashMap, HashSet},
+    fs,
+    path::{Path, PathBuf},
+    sync::{
+        atomic::{AtomicU64, Ordering},
+        Arc,
+    },
+    thread,
+    time::Duration,
+};
+
+use alacritty_terminal::{event::WindowSize, event_loop::Msg};
 use anyhow::{anyhow, Context, Result};
-use crossbeam_channel::{unbounded, Receiver, Sender};
-use directories::BaseDirs;
-use git2::{DiffOptions, Repository};
+use crossbeam_channel::Sender;
+use git2::{build::CheckoutBuilder, DiffOptions, Repository};
 use grep_matcher::Matcher;
 use grep_regex::RegexMatcherBuilder;
-use grep_searcher::sinks::UTF8;
-use grep_searcher::SearcherBuilder;
-use lapce_rpc::buffer::{BufferHeadResponse, BufferId, NewBufferResponse};
-use lapce_rpc::core::CoreNotification;
-use lapce_rpc::file::FileNodeItem;
-use lapce_rpc::proxy::{ProxyNotification, ProxyRequest, ReadDirResponse};
-use lapce_rpc::source_control::{DiffInfo, FileDiff};
-use lapce_rpc::terminal::TermId;
-use lapce_rpc::{self, Call, RequestId, RpcObject};
+use grep_searcher::{sinks::UTF8, SearcherBuilder};
+use indexmap::IndexMap;
+use lapce_rpc::{
+    core::{CoreNotification, CoreRpcHandler},
+    file::FileNodeItem,
+    proxy::{
+        ProxyHandler, ProxyNotification, ProxyRequest, ProxyResponse,
+        ProxyRpcHandler,
+    },
+    source_control::{DiffInfo, FileDiff},
+    style::{LineStyle, SemanticStyles},
+    terminal::TermId,
+    RequestId, RpcError,
+};
+use lapce_xi_rope::Rope;
+use lsp_types::{Position, Range, TextDocumentItem, Url};
 use parking_lot::Mutex;
-use serde_json::json;
-use serde_json::Value;
-use std::collections::HashMap;
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use std::thread;
-use std::{collections::HashSet, io::BufRead};
-use xi_rope::Rope;
+
+use crate::{
+    buffer::{get_mod_time, load_file, Buffer},
+    plugin::{catalog::PluginCatalog, remove_volt, PluginCatalogRpcHandler},
+    terminal::Terminal,
+    watcher::{FileWatcher, Notify, WatchToken},
+};
 
 const OPEN_FILE_EVENT_TOKEN: WatchToken = WatchToken(1);
 const WORKSPACE_EVENT_TOKEN: WatchToken = WatchToken(2);
 
-#[derive(Clone)]
 pub struct Dispatcher {
-    pub sender: Arc<Sender<Value>>,
-    pub git_sender: Sender<(BufferId, u64)>,
-    pub workspace: Arc<Mutex<Option<PathBuf>>>,
-    pub buffers: Arc<Mutex<HashMap<BufferId, Buffer>>>,
-
+    workspace: Option<PathBuf>,
+    pub proxy_rpc: ProxyRpcHandler,
+    core_rpc: CoreRpcHandler,
+    catalog_rpc: PluginCatalogRpcHandler,
+    buffers: HashMap<PathBuf, Buffer>,
     #[allow(deprecated)]
-    pub terminals: Arc<Mutex<HashMap<TermId, mio::channel::Sender<Msg>>>>,
-
-    open_files: Arc<Mutex<HashMap<String, BufferId>>>,
-    plugins: Arc<Mutex<PluginCatalog>>,
-    pub lsp: Arc<Mutex<LspCatalog>>,
-    pub file_watcher: Arc<Mutex<Option<FileWatcher>>>,
-    last_diff: Arc<Mutex<DiffInfo>>,
+    terminals: HashMap<TermId, mio::channel::Sender<Msg>>,
+    file_watcher: FileWatcher,
+    window_id: usize,
+    tab_id: usize,
 }
 
-impl Notify for Dispatcher {
-    fn notify(&self) {
-        self.handle_fs_events();
-    }
-}
-
-impl Dispatcher {
-    pub fn new(sender: Sender<Value>) -> Dispatcher {
-        let plugins = PluginCatalog::new();
-        let (git_sender, git_receiver) = unbounded();
-        let dispatcher = Dispatcher {
-            sender: Arc::new(sender),
-            git_sender,
-            workspace: Arc::new(Mutex::new(None)),
-            buffers: Arc::new(Mutex::new(HashMap::new())),
-            open_files: Arc::new(Mutex::new(HashMap::new())),
-            terminals: Arc::new(Mutex::new(HashMap::new())),
-            plugins: Arc::new(Mutex::new(plugins)),
-            lsp: Arc::new(Mutex::new(LspCatalog::new())),
-            file_watcher: Arc::new(Mutex::new(None)),
-            last_diff: Arc::new(Mutex::new(DiffInfo::default())),
-        };
-        *dispatcher.file_watcher.lock() = Some(FileWatcher::new(dispatcher.clone()));
-        dispatcher.lsp.lock().dispatcher = Some(dispatcher.clone());
-
-        let local_dispatcher = dispatcher.clone();
-        thread::spawn(move || {
-            local_dispatcher.plugins.lock().reload();
-            let plugins = { local_dispatcher.plugins.lock().items.clone() };
-            local_dispatcher.send_notification(
-                "installed_plugins",
-                json!({
-                    "plugins": plugins,
-                }),
-            );
-            local_dispatcher
-                .plugins
-                .lock()
-                .start_all(local_dispatcher.clone());
-        });
-
-        let local_dispatcher = dispatcher.clone();
-        thread::spawn(move || {
-            if let Some(path) = BaseDirs::new().map(|d| PathBuf::from(d.home_dir()))
-            {
-                local_dispatcher.send_notification(
-                    "home_dir",
-                    json!({
-                        "path": path,
-                    }),
-                );
-            }
-        });
-
-        dispatcher.start_update_process(git_receiver);
-        dispatcher.send_notification("proxy_connected", json!({}));
-
-        dispatcher
-    }
-
-    pub fn mainloop(&self, receiver: Receiver<Value>) -> Result<()> {
-        for msg in receiver {
-            let rpc: RpcObject = msg.into();
-            if rpc.is_response() {
-            } else {
-                match rpc.into_rpc::<ProxyNotification, ProxyRequest>() {
-                    Ok(Call::Request(id, request)) => {
-                        self.handle_request(id, request);
-                    }
-                    Ok(Call::Notification(notification)) => {
-                        if let ProxyNotification::Shutdown {} = &notification {
-                            for (_, sender) in self.terminals.lock().iter() {
-                                #[allow(deprecated)]
-                                let _ = sender.send(Msg::Shutdown);
-                            }
-                            self.open_files.lock().clear();
-                            self.buffers.lock().clear();
-                            self.plugins.lock().stop();
-                            self.lsp.lock().stop();
-                            self.file_watcher.lock().take();
-                            return Ok(());
-                        }
-                        self.handle_notification(notification);
-                    }
-                    Err(e) => {
-                        eprintln!("{e:?}")
-                    }
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub fn start_update_process(&self, receiver: Receiver<(BufferId, u64)>) {
-        let buffers = self.buffers.clone();
-        let lsp = self.lsp.clone();
-        thread::spawn(move || loop {
-            match receiver.recv() {
-                Ok((buffer_id, rev)) => {
-                    let buffers = buffers.lock();
-                    let buffer = buffers.get(&buffer_id).unwrap();
-                    let (_path, _content) = if buffer.rev != rev {
-                        continue;
-                    } else {
-                        (
-                            buffer.path.clone(),
-                            buffer.slice_to_cow(..buffer.len()).to_string(),
-                        )
-                    };
-
-                    lsp.lock().get_semantic_tokens(buffer);
-                }
-                Err(_) => {
-                    return;
+impl ProxyHandler for Dispatcher {
+    fn handle_notification(&mut self, rpc: ProxyNotification) {
+        use ProxyNotification::*;
+        match rpc {
+            Initialize {
+                workspace,
+                disabled_volts,
+                plugin_configurations,
+                window_id,
+                tab_id,
+            } => {
+                self.window_id = window_id;
+                self.tab_id = tab_id;
+                self.workspace = workspace;
+                self.file_watcher.notify(FileWatchNotifier::new(
+                    self.workspace.clone(),
+                    self.core_rpc.clone(),
+                    self.proxy_rpc.clone(),
+                ));
+                if let Some(workspace) = self.workspace.as_ref() {
+                    self.file_watcher
+                        .watch(workspace, true, WORKSPACE_EVENT_TOKEN);
                 }
-            }
-        });
-    }
-
-    pub fn next<R: BufRead>(
-        &self,
-        reader: &mut R,
-        s: &mut String,
-    ) -> Result<RpcObject> {
-        s.clear();
-        let _ = reader.read_line(s)?;
-        if s.is_empty() {
-            Err(anyhow!("empty line"))
-        } else {
-            self.parse(s)
-        }
-    }
 
-    fn parse(&self, s: &str) -> Result<RpcObject> {
-        let val = serde_json::from_str::<Value>(s)?;
-        if !val.is_object() {
-            Err(anyhow!("not json object"))
-        } else {
-            Ok(val.into())
-        }
-    }
-
-    pub fn respond(&self, id: RequestId, result: Result<Value>) {
-        let mut resp = json!({ "id": id });
-        match result {
-            Ok(v) => resp["result"] = v,
-            Err(e) => {
-                resp["error"] = json!({
-                    "code": 0,
-                    "message": format!("{}",e),
-                })
-            }
-        }
-        let _ = self.sender.send(resp);
-    }
-
-    pub fn respond_rpc<T: serde::Serialize>(
-        &self,
-        id: RequestId,
-        result: Result<T>,
-    ) {
-        let mut resp = json!({ "id": id });
-        match result {
-            Ok(v) => resp["result"] = serde_json::to_value(v).unwrap(),
-            Err(e) => {
-                resp["error"] = json!({
-                    "code": 0,
-                    "message": format!("{}",e),
-                })
-            }
-        }
-        let _ = self.sender.send(resp);
-    }
-
-    pub fn send_rpc_notification<T: serde::Serialize>(&self, notification: T) {
-        let _ = self
-            .sender
-            .send(serde_json::to_value(notification).unwrap());
-    }
-
-    pub fn send_notification(&self, method: &str, params: Value) {
-        let _ = self.sender.send(json!({
-            "method": method,
-            "params": params,
-        }));
-    }
+                let plugin_rpc = self.catalog_rpc.clone();
+                let workspace = self.workspace.clone();
+                thread::spawn(move || {
+                    let mut plugin = PluginCatalog::new(
+                        workspace,
+                        disabled_volts,
+                        plugin_configurations,
+                        plugin_rpc.clone(),
+                    );
+                    plugin_rpc.mainloop(&mut plugin);
+                });
+                self.core_rpc.proxy_connected();
 
-    fn handle_fs_events(&self) {
-        let mut events = {
-            self.file_watcher
-                .lock()
-                .as_mut()
-                .map(|w| w.take_events())
-                .unwrap_or_default()
-        };
+                // send home directory for initinal filepicker dir
+                let dirs = directories::UserDirs::new();
 
-        for (token, event) in events.drain(..) {
-            match token {
-                OPEN_FILE_EVENT_TOKEN => self.handle_open_file_fs_event(event),
-                WORKSPACE_EVENT_TOKEN => self.handle_workspace_fs_event(event),
-                _ => {}
+                if let Some(dirs) = dirs {
+                    self.core_rpc.home_dir(dirs.home_dir().into());
+                }
             }
-        }
-    }
-
-    fn handle_open_file_fs_event(&self, event: notify::Event) {
-        use notify::event::*;
-        let path = match event.kind {
-            EventKind::Modify(_) => &event.paths[0],
-            _ => {
-                return;
+            OpenPaths { folders, files } => {
+                self.core_rpc.notification(CoreNotification::OpenPaths {
+                    window_tab_id: Some((self.window_id, self.tab_id)),
+                    folders,
+                    files,
+                });
             }
-        };
-
-        if let Some(path) = path.to_str() {
-            if let Some(buffer_id) = self.open_files.lock().get(path) {
-                if let Some(buffer) = self.buffers.lock().get_mut(buffer_id) {
+            OpenFileChanged { path } => {
+                if let Some(buffer) = self.buffers.get(&path) {
                     if get_mod_time(&buffer.path) == buffer.mod_time {
                         return;
                     }
                     if let Ok(content) = load_file(&buffer.path) {
-                        self.send_rpc_notification(
-                            CoreNotification::OpenFileChanged {
-                                path: buffer.path.clone(),
-                                content,
-                            },
-                        );
+                        self.core_rpc.open_file_changed(path, content);
                     }
                 }
             }
-        }
-    }
-
-    fn handle_workspace_fs_event(&self, event: notify::Event) {
-        if let Some(workspace) = self.workspace.lock().clone() {
-            self.send_rpc_notification(CoreNotification::FileChange { event });
-            if let Some(diff) = git_diff_new(&workspace) {
-                if diff != *self.last_diff.lock() {
-                    self.send_notification(
-                        "diff_info",
-                        json!({
-                            "diff": diff,
-                        }),
-                    );
-                    *self.last_diff.lock() = diff;
-                }
-            }
-        }
-    }
-
-    fn handle_notification(&self, rpc: ProxyNotification) {
-        use ProxyNotification::*;
-        match rpc {
-            Initialize { workspace } => {
-                *self.workspace.lock() = Some(workspace.clone());
-                self.file_watcher.lock().as_mut().unwrap().watch(
-                    &workspace,
-                    true,
-                    WORKSPACE_EVENT_TOKEN,
-                );
-                if let Some(diff) = git_diff_new(&workspace) {
-                    self.send_notification(
-                        "diff_info",
-                        json!({
-                            "diff": diff,
-                        }),
-                    );
-                    *self.last_diff.lock() = diff;
-                }
+            Completion {
+                request_id,
+                path,
+                input,
+                position,
+            } => {
+                self.catalog_rpc
+                    .completion(request_id, &path, input, position);
             }
-            Shutdown {} => {}
-            Update {
-                buffer_id,
-                delta,
-                rev,
+            SignatureHelp {
+                request_id,
+                path,
+                position,
             } => {
-                let mut buffers = self.buffers.lock();
-                let buffer = buffers.get_mut(&buffer_id).unwrap();
-                if let Some(content_change) = buffer.update(&delta, rev) {
-                    self.lsp.lock().update(buffer, &content_change, buffer.rev);
+                self.catalog_rpc.signature_help(request_id, &path, position);
+            }
+            Shutdown {} => {
+                self.catalog_rpc.shutdown();
+                for (_, sender) in self.terminals.iter() {
+                    #[allow(deprecated)]
+                    let _ = sender.send(Msg::Shutdown);
                 }
+                self.proxy_rpc.shutdown();
             }
-            InstallPlugin { plugin } => {
-                let catalog = self.plugins.clone();
-                let dispatcher = self.clone();
-                std::thread::spawn(move || {
-                    if let Err(e) =
-                        catalog.lock().install_plugin(dispatcher.clone(), plugin)
-                    {
-                        eprintln!("install plugin error {e}");
-                    }
-                    let plugins = { dispatcher.plugins.lock().items.clone() };
-                    dispatcher.send_notification(
-                        "installed_plugins",
-                        json!({
-                            "plugins": plugins,
-                        }),
-                    );
-                });
+            Update { path, delta, rev } => {
+                let buffer = self.buffers.get_mut(&path).unwrap();
+                let old_text = buffer.rope.clone();
+                buffer.update(&delta, rev);
+                self.catalog_rpc.did_change_text_document(
+                    &path,
+                    rev,
+                    delta,
+                    old_text,
+                    buffer.rope.clone(),
+                );
+            }
+            UpdatePluginConfigs { configs } => {
+                let _ = self.catalog_rpc.update_plugin_configs(configs);
             }
             NewTerminal {
                 term_id,
@@ -358,22 +164,14 @@ impl Dispatcher {
             } => {
                 let mut terminal = Terminal::new(term_id, cwd, shell, 50, 10);
                 let tx = terminal.tx.clone();
-                self.terminals.lock().insert(term_id, tx);
-                let dispatcher = self.clone();
-                std::thread::spawn(move || {
-                    terminal.run(dispatcher);
+                self.terminals.insert(term_id, tx);
+                let rpc = self.core_rpc.clone();
+                thread::spawn(move || {
+                    terminal.run(rpc);
                 });
             }
-            TerminalClose { term_id } => {
-                let mut terminals = self.terminals.lock();
-                if let Some(tx) = terminals.remove(&term_id) {
-                    #[allow(deprecated)]
-                    let _ = tx.send(Msg::Shutdown);
-                }
-            }
             TerminalWrite { term_id, content } => {
-                let terminals = self.terminals.lock();
-                if let Some(tx) = terminals.get(&term_id) {
+                if let Some(tx) = self.terminals.get(&term_id) {
                     #[allow(deprecated)]
                     let _ = tx.send(Msg::Input(content.into_bytes().into()));
                 }
@@ -383,33 +181,82 @@ impl Dispatcher {
                 width,
                 height,
             } => {
-                let terminals = self.terminals.lock();
-                if let Some(tx) = terminals.get(&term_id) {
-                    let size = SizeInfo::new(
-                        width as f32,
-                        height as f32,
-                        1.0,
-                        1.0,
-                        0.0,
-                        0.0,
-                        true,
-                    );
+                if let Some(tx) = self.terminals.get(&term_id) {
+                    let size = WindowSize {
+                        num_lines: height as u16,
+                        num_cols: width as u16,
+                        cell_width: 1,
+                        cell_height: 1,
+                    };
 
                     #[allow(deprecated)]
                     let _ = tx.send(Msg::Resize(size));
                 }
             }
+            TerminalClose { term_id } => {
+                if let Some(tx) = self.terminals.remove(&term_id) {
+                    #[allow(deprecated)]
+                    let _ = tx.send(Msg::Shutdown);
+                }
+            }
+            InstallVolt { volt } => {
+                let catalog_rpc = self.catalog_rpc.clone();
+                let _ = catalog_rpc.install_volt(volt);
+            }
+            ReloadVolt { volt } => {
+                let _ = self.catalog_rpc.reload_volt(volt);
+            }
+            RemoveVolt { volt } => {
+                let catalog_rpc = self.catalog_rpc.clone();
+                let _ = catalog_rpc.stop_volt(volt.info());
+                thread::spawn(move || {
+                    let _ = remove_volt(catalog_rpc, volt);
+                });
+            }
+            DisableVolt { volt } => {
+                let _ = self.catalog_rpc.stop_volt(volt);
+            }
+            EnableVolt { volt } => {
+                let _ = self.catalog_rpc.enable_volt(volt);
+            }
             GitCommit { message, diffs } => {
-                if let Some(workspace) = self.workspace.lock().clone() {
-                    match git_commit(&workspace, &message, diffs) {
+                if let Some(workspace) = self.workspace.as_ref() {
+                    match git_commit(workspace, &message, diffs) {
                         Ok(()) => (),
                         Err(e) => eprintln!("{e:?}"),
                     }
                 }
             }
             GitCheckout { branch } => {
-                if let Some(workspace) = self.workspace.lock().clone() {
-                    match git_checkout(&workspace, &branch) {
+                if let Some(workspace) = self.workspace.as_ref() {
+                    match git_checkout(workspace, &branch) {
+                        Ok(()) => (),
+                        Err(e) => eprintln!("{e:?}"),
+                    }
+                }
+            }
+            GitDiscardFilesChanges { files } => {
+                if let Some(workspace) = self.workspace.as_ref() {
+                    match git_discard_files_changes(
+                        workspace,
+                        files.iter().map(AsRef::as_ref),
+                    ) {
+                        Ok(()) => (),
+                        Err(e) => eprintln!("{e:?}"),
+                    }
+                }
+            }
+            GitDiscardWorkspaceChanges {} => {
+                if let Some(workspace) = self.workspace.as_ref() {
+                    match git_discard_workspace_changes(workspace) {
+                        Ok(()) => (),
+                        Err(e) => eprintln!("{e:?}"),
+                    }
+                }
+            }
+            GitInit {} => {
+                if let Some(workspace) = self.workspace.as_ref() {
+                    match git_init(workspace) {
                         Ok(()) => (),
                         Err(e) => eprintln!("{e:?}"),
                     }
@@ -418,120 +265,378 @@ impl Dispatcher {
         }
     }
 
-    fn handle_request(&self, id: RequestId, rpc: ProxyRequest) {
+    fn handle_request(&mut self, id: RequestId, rpc: ProxyRequest) {
         use ProxyRequest::*;
         match rpc {
             NewBuffer { buffer_id, path } => {
-                self.file_watcher.lock().as_mut().unwrap().watch(
+                let buffer = Buffer::new(buffer_id, path.clone());
+                let content = buffer.rope.to_string();
+                self.catalog_rpc.did_open_document(
                     &path,
-                    false,
-                    OPEN_FILE_EVENT_TOKEN,
+                    buffer.language_id.to_string(),
+                    buffer.rev as i32,
+                    content.clone(),
                 );
-                self.open_files
-                    .lock()
-                    .insert(path.to_str().unwrap().to_string(), buffer_id);
-                let buffer = Buffer::new(buffer_id, path, self.git_sender.clone());
-                let content = buffer.rope.to_string();
-                self.buffers.lock().insert(buffer_id, buffer);
-                let _ = self.git_sender.send((buffer_id, 0));
-                let resp = NewBufferResponse { content };
-                let _ = self.sender.send(json!({
-                    "id": id,
-                    "result": resp,
-                }));
-            }
-            BufferHead { path, .. } => {
-                if let Some(workspace) = self.workspace.lock().clone() {
-                    let result = file_get_head(&workspace, &path);
+                self.file_watcher.watch(&path, false, OPEN_FILE_EVENT_TOKEN);
+                self.buffers.insert(path, buffer);
+                self.respond_rpc(
+                    id,
+                    Ok(ProxyResponse::NewBufferResponse { content }),
+                );
+            }
+            BufferHead { path } => {
+                let result = if let Some(workspace) = self.workspace.as_ref() {
+                    let result = file_get_head(workspace, &path);
                     if let Ok((_blob_id, content)) = result {
-                        let resp = BufferHeadResponse {
+                        Ok(ProxyResponse::BufferHeadResponse {
                             version: "head".to_string(),
                             content,
-                        };
-                        let _ = self.sender.send(json!({
-                            "id": id,
-                            "result": resp,
-                        }));
+                        })
+                    } else {
+                        Err(RpcError {
+                            code: 0,
+                            message: "can't get file head".to_string(),
+                        })
                     }
-                }
+                } else {
+                    Err(RpcError {
+                        code: 0,
+                        message: "no workspace set".to_string(),
+                    })
+                };
+                self.respond_rpc(id, result);
             }
-            GetCompletion {
-                buffer_id,
-                position,
-                request_id,
+            GlobalSearch {
+                pattern,
+                case_sensitive,
             } => {
-                let buffers = self.buffers.lock();
-                let buffer = buffers.get(&buffer_id).unwrap();
-                self.lsp
-                    .lock()
-                    .get_completion(id, request_id, buffer, position);
+                static WORKER_ID: AtomicU64 = AtomicU64::new(0);
+                let our_id = WORKER_ID.fetch_add(1, Ordering::SeqCst) + 1;
+
+                let workspace = self.workspace.clone();
+                let buffers = self
+                    .buffers
+                    .iter()
+                    .map(|p| p.0)
+                    .cloned()
+                    .collect::<Vec<PathBuf>>();
+                let proxy_rpc = self.proxy_rpc.clone();
+
+                // Perform the search on another thread to avoid blocking the proxy thread
+                thread::spawn(move || {
+                    proxy_rpc.handle_response(
+                        id,
+                        search_in_path(
+                            our_id,
+                            &WORKER_ID,
+                            workspace
+                                .iter()
+                                .flat_map(|w| ignore::Walk::new(w).flatten())
+                                .chain(
+                                    buffers.iter().flat_map(|p| {
+                                        ignore::Walk::new(p).flatten()
+                                    }),
+                                )
+                                .map(|p| p.into_path()),
+                            &pattern,
+                            case_sensitive,
+                        ),
+                    );
+                });
             }
             CompletionResolve {
-                buffer_id,
+                plugin_id,
                 completion_item,
             } => {
-                let buffers = self.buffers.lock();
-                let buffer = buffers.get(&buffer_id).unwrap();
-                self.lsp
-                    .lock()
-                    .completion_resolve(id, buffer, &completion_item);
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.completion_resolve(
+                    plugin_id,
+                    *completion_item,
+                    move |result| {
+                        let result = result.map(|item| {
+                            ProxyResponse::CompletionResolveResponse {
+                                item: Box::new(item),
+                            }
+                        });
+                        proxy_rpc.handle_response(id, result);
+                    },
+                );
             }
             GetHover {
-                buffer_id,
-                position,
                 request_id,
+                path,
+                position,
             } => {
-                let buffers = self.buffers.lock();
-                let buffer = buffers.get(&buffer_id).unwrap();
-                self.lsp.lock().get_hover(id, request_id, buffer, position);
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.hover(&path, position, move |_, result| {
+                    let result = result.map(|hover| ProxyResponse::HoverResponse {
+                        request_id,
+                        hover,
+                    });
+                    proxy_rpc.handle_response(id, result);
+                });
             }
-            GetSignature {
-                buffer_id,
+            GetSignature { .. } => {}
+            GetReferences { path, position } => {
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.get_references(
+                    &path,
+                    position,
+                    move |_, result| {
+                        let result = result.map(|references| {
+                            ProxyResponse::GetReferencesResponse { references }
+                        });
+                        proxy_rpc.handle_response(id, result);
+                    },
+                );
+            }
+            GitGetRemoteFileUrl { file } => {
+                if let Some(workspace) = self.workspace.as_ref() {
+                    match git_get_remote_file_url(workspace, &file) {
+                        Ok(s) => self.proxy_rpc.handle_response(
+                            id,
+                            Ok(ProxyResponse::GitGetRemoteFileUrl { file_url: s }),
+                        ),
+                        Err(e) => eprintln!("{e:?}"),
+                    }
+                }
+            }
+            GetDefinition {
+                request_id,
+                path,
                 position,
             } => {
-                let buffers = self.buffers.lock();
-                let buffer = buffers.get(&buffer_id).unwrap();
-                self.lsp.lock().get_signature(id, buffer, position);
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.get_definition(
+                    &path,
+                    position,
+                    move |_, result| {
+                        let result = result.map(|definition| {
+                            ProxyResponse::GetDefinitionResponse {
+                                request_id,
+                                definition,
+                            }
+                        });
+                        proxy_rpc.handle_response(id, result);
+                    },
+                );
             }
-            GetReferences {
-                buffer_id,
+            GetTypeDefinition {
+                request_id,
+                path,
                 position,
             } => {
-                let buffers = self.buffers.lock();
-                let buffer = buffers.get(&buffer_id).unwrap();
-                self.lsp.lock().get_references(id, buffer, position);
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.get_type_definition(
+                    &path,
+                    position,
+                    move |_, result| {
+                        let result = result.map(|definition| {
+                            ProxyResponse::GetTypeDefinition {
+                                request_id,
+                                definition,
+                            }
+                        });
+                        proxy_rpc.handle_response(id, result);
+                    },
+                );
             }
-            GetDefinition {
-                buffer_id,
+            GetInlayHints { path } => {
+                let proxy_rpc = self.proxy_rpc.clone();
+                let buffer = self.buffers.get(&path).unwrap();
+                let range = Range {
+                    start: Position::new(0, 0),
+                    end: buffer.offset_to_position(buffer.len()),
+                };
+                self.catalog_rpc
+                    .get_inlay_hints(&path, range, move |_, result| {
+                        let result = result
+                            .map(|hints| ProxyResponse::GetInlayHints { hints });
+                        proxy_rpc.handle_response(id, result);
+                    });
+            }
+            GetSemanticTokens { path } => {
+                let buffer = self.buffers.get(&path).unwrap();
+                let text = buffer.rope.clone();
+                let rev = buffer.rev;
+                let len = buffer.len();
+                let local_path = path.clone();
+                let proxy_rpc = self.proxy_rpc.clone();
+                let catalog_rpc = self.catalog_rpc.clone();
+
+                let handle_tokens =
+                    move |result: Result<Vec<LineStyle>, RpcError>| match result {
+                        Ok(styles) => {
+                            proxy_rpc.handle_response(
+                                id,
+                                Ok(ProxyResponse::GetSemanticTokens {
+                                    styles: SemanticStyles {
+                                        rev,
+                                        path: local_path,
+                                        styles,
+                                        len,
+                                    },
+                                }),
+                            );
+                        }
+                        Err(e) => {
+                            proxy_rpc.handle_response(id, Err(e));
+                        }
+                    };
+
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.get_semantic_tokens(
+                    &path,
+                    move |plugin_id, result| match result {
+                        Ok(result) => {
+                            catalog_rpc.format_semantic_tokens(
+                                plugin_id,
+                                result,
+                                text,
+                                Box::new(handle_tokens),
+                            );
+                        }
+                        Err(e) => {
+                            proxy_rpc.handle_response(id, Err(e));
+                        }
+                    },
+                );
+            }
+            GetCodeActions {
+                path,
                 position,
-                request_id,
+                diagnostics,
             } => {
-                let buffers = self.buffers.lock();
-                let buffer = buffers.get(&buffer_id).unwrap();
-                self.lsp
-                    .lock()
-                    .get_definition(id, request_id, buffer, position);
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.get_code_actions(
+                    &path,
+                    position,
+                    diagnostics,
+                    move |plugin_id, result| {
+                        let result = result.map(|resp| {
+                            ProxyResponse::GetCodeActionsResponse { plugin_id, resp }
+                        });
+                        proxy_rpc.handle_response(id, result);
+                    },
+                );
             }
-            GetCodeActions {
-                buffer_id,
+            GetDocumentSymbols { path } => {
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc
+                    .get_document_symbols(&path, move |_, result| {
+                        let result = result
+                            .map(|resp| ProxyResponse::GetDocumentSymbols { resp });
+                        proxy_rpc.handle_response(id, result);
+                    });
+            }
+            GetWorkspaceSymbols { query } => {
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc
+                    .get_workspace_symbols(query, move |_, result| {
+                        let result = result.map(|symbols| {
+                            ProxyResponse::GetWorkspaceSymbols { symbols }
+                        });
+                        proxy_rpc.handle_response(id, result);
+                    });
+            }
+            GetDocumentFormatting { path } => {
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc
+                    .get_document_formatting(&path, move |_, result| {
+                        let result = result.map(|edits| {
+                            ProxyResponse::GetDocumentFormatting { edits }
+                        });
+                        proxy_rpc.handle_response(id, result);
+                    });
+            }
+            PrepareRename { path, position } => {
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.prepare_rename(
+                    &path,
+                    position,
+                    move |_, result| {
+                        let result =
+                            result.map(|resp| ProxyResponse::PrepareRename { resp });
+                        proxy_rpc.handle_response(id, result);
+                    },
+                );
+            }
+            Rename {
+                path,
                 position,
+                new_name,
             } => {
-                let buffers = self.buffers.lock();
-                let buffer = buffers.get(&buffer_id).unwrap();
-                self.lsp.lock().get_code_actions(id, buffer, position);
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.rename(
+                    &path,
+                    position,
+                    new_name,
+                    move |_, result| {
+                        let result =
+                            result.map(|edit| ProxyResponse::Rename { edit });
+                        proxy_rpc.handle_response(id, result);
+                    },
+                );
             }
-            GetDocumentSymbols { buffer_id } => {
-                let buffers = self.buffers.lock();
-                let buffer = buffers.get(&buffer_id).unwrap();
-                self.lsp.lock().get_document_symbols(id, buffer);
+            GetFiles { .. } => {
+                let workspace = self.workspace.clone();
+                let proxy_rpc = self.proxy_rpc.clone();
+                thread::spawn(move || {
+                    let result = if let Some(workspace) = workspace {
+                        let git_folder =
+                            ignore::overrides::OverrideBuilder::new(&workspace)
+                                .add("!.git/")
+                                .map(|git_folder| git_folder.build());
+
+                        let walker = match git_folder {
+                            Ok(Ok(git_folder)) => {
+                                ignore::WalkBuilder::new(&workspace)
+                                    .hidden(false)
+                                    .parents(false)
+                                    .require_git(false)
+                                    .overrides(git_folder)
+                                    .build()
+                            }
+                            _ => ignore::WalkBuilder::new(&workspace)
+                                .parents(false)
+                                .require_git(false)
+                                .build(),
+                        };
+
+                        let mut items = Vec::new();
+                        for path in walker.flatten() {
+                            if let Some(file_type) = path.file_type() {
+                                if file_type.is_file() {
+                                    items.push(path.into_path());
+                                }
+                            }
+                        }
+                        Ok(ProxyResponse::GetFilesResponse { items })
+                    } else {
+                        Err(RpcError {
+                            code: 0,
+                            message: "no workspace set".to_string(),
+                        })
+                    };
+                    proxy_rpc.handle_response(id, result);
+                });
             }
-            GetDocumentFormatting { buffer_id } => {
-                let buffers = self.buffers.lock();
-                let buffer = buffers.get(&buffer_id).unwrap();
-                self.lsp.lock().get_document_formatting(id, buffer);
+            GetOpenFilesContent {} => {
+                let items = self
+                    .buffers
+                    .iter()
+                    .map(|(path, buffer)| TextDocumentItem {
+                        uri: Url::from_file_path(path).unwrap(),
+                        language_id: buffer.language_id.to_string(),
+                        version: buffer.rev as i32,
+                        text: buffer.get_document(),
+                    })
+                    .collect();
+                let resp = ProxyResponse::GetOpenFilesContentResponse { items };
+                self.proxy_rpc.handle_response(id, Ok(resp));
             }
             ReadDir { path } => {
-                let local_dispatcher = self.clone();
+                let proxy_rpc = self.proxy_rpc.clone();
                 thread::spawn(move || {
                     let result = fs::read_dir(path)
                         .map(|entries| {
@@ -556,35 +661,29 @@ impl Dispatcher {
                                 })
                                 .collect::<HashMap<PathBuf, FileNodeItem>>();
 
-                            ReadDirResponse { items }
+                            ProxyResponse::ReadDirResponse { items }
                         })
-                        .map_err(|e| anyhow!(e));
-                    local_dispatcher.respond_rpc(id, result);
+                        .map_err(|e| RpcError {
+                            code: 0,
+                            message: e.to_string(),
+                        });
+                    proxy_rpc.handle_response(id, result);
                 });
             }
-            GetFiles { .. } => {
-                if let Some(workspace) = self.workspace.lock().clone() {
-                    let local_dispatcher = self.clone();
-                    thread::spawn(move || {
-                        let mut items = Vec::new();
-                        for path in ignore::Walk::new(workspace).flatten() {
-                            if let Some(file_type) = path.file_type() {
-                                if file_type.is_file() {
-                                    items.push(path.into_path());
-                                }
-                            }
-                        }
-                        local_dispatcher
-                            .respond(id, Ok(serde_json::to_value(items).unwrap()));
+            Save { rev, path } => {
+                let buffer = self.buffers.get_mut(&path).unwrap();
+                let result = buffer
+                    .save(rev)
+                    .map(|_r| {
+                        self.catalog_rpc
+                            .did_save_text_document(&path, buffer.rope.clone());
+                        ProxyResponse::SaveResponse {}
+                    })
+                    .map_err(|e| RpcError {
+                        code: 0,
+                        message: e.to_string(),
                     });
-                }
-            }
-            Save { rev, buffer_id } => {
-                let mut buffers = self.buffers.lock();
-                let buffer = buffers.get_mut(&buffer_id).unwrap();
-                let resp = buffer.save(rev).map(|_r| json!({}));
-                self.lsp.lock().save_buffer(buffer);
-                self.respond(id, resp);
+                self.respond_rpc(id, result);
             }
             SaveBufferAs {
                 buffer_id,
@@ -592,66 +691,278 @@ impl Dispatcher {
                 rev,
                 content,
             } => {
-                let mut buffer =
-                    Buffer::new(buffer_id, path.clone(), self.git_sender.clone());
+                let mut buffer = Buffer::new(buffer_id, path.clone());
                 buffer.rope = Rope::from(content);
                 buffer.rev = rev;
-                let resp = buffer.save(rev).map(|_r| json!({}));
-                if resp.is_ok() {
-                    self.buffers.lock().insert(buffer_id, buffer);
-                    self.open_files
-                        .lock()
-                        .insert(path.to_str().unwrap().to_string(), buffer_id);
-                    let _ = self.git_sender.send((buffer_id, 0));
-                }
-                self.respond(id, resp);
-            }
-            GlobalSearch { pattern } => {
-                if let Some(workspace) = self.workspace.lock().clone() {
-                    let local_dispatcher = self.clone();
-                    thread::spawn(move || {
-                        let mut matches = HashMap::new();
-                        let pattern = regex::escape(&pattern);
-                        if let Ok(matcher) = RegexMatcherBuilder::new()
-                            .case_insensitive(true)
-                            .build_literals(&[&pattern])
-                        {
-                            let mut searcher = SearcherBuilder::new().build();
-                            for path in ignore::Walk::new(workspace).flatten() {
-                                if let Some(file_type) = path.file_type() {
-                                    if file_type.is_file() {
-                                        let path = path.into_path();
-                                        let mut line_matches = Vec::new();
-                                        let _ = searcher.search_path(
-                                            &matcher,
-                                            path.clone(),
-                                            UTF8(|lnum, line| {
-                                                let mymatch = matcher
-                                                    .find(line.as_bytes())?
-                                                    .unwrap();
-                                                line_matches.push((
-                                                    lnum,
-                                                    (mymatch.start(), mymatch.end()),
-                                                    line.to_string(),
-                                                ));
-                                                Ok(true)
-                                            }),
-                                        );
-                                        if !line_matches.is_empty() {
-                                            matches
-                                                .insert(path.clone(), line_matches);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        local_dispatcher
-                            .respond(id, Ok(serde_json::to_value(matches).unwrap()));
+                let result = buffer
+                    .save(rev)
+                    .map(|_| ProxyResponse::Success {})
+                    .map_err(|e| RpcError {
+                        code: 0,
+                        message: e.to_string(),
+                    });
+                self.buffers.insert(path, buffer);
+                self.respond_rpc(id, result);
+            }
+            CreateFile { path } => {
+                let result = path
+                    .parent()
+                    .map_or(Ok(()), std::fs::create_dir_all)
+                    .and_then(|()| {
+                        std::fs::OpenOptions::new()
+                            .write(true)
+                            .create_new(true)
+                            .open(path)
+                    })
+                    .map(|_| ProxyResponse::Success {})
+                    .map_err(|e| RpcError {
+                        code: 0,
+                        message: e.to_string(),
+                    });
+                self.respond_rpc(id, result);
+            }
+            CreateDirectory { path } => {
+                let result = std::fs::create_dir_all(path)
+                    .map(|_| ProxyResponse::Success {})
+                    .map_err(|e| RpcError {
+                        code: 0,
+                        message: e.to_string(),
+                    });
+                self.respond_rpc(id, result);
+            }
+            TrashPath { path } => {
+                let result = trash::delete(path)
+                    .map(|_| ProxyResponse::Success {})
+                    .map_err(|e| RpcError {
+                        code: 0,
+                        message: e.to_string(),
                     });
+                self.respond_rpc(id, result);
+            }
+            DuplicatePath {
+                existing_path,
+                new_path,
+            } => {
+                // We first check if the destination already exists, because copy can overwrite it
+                // and that's not the default behavior we want for when a user duplicates a document.
+                let result = if new_path.exists() {
+                    Err(RpcError {
+                        code: 0,
+                        message: format!("{new_path:?} already exists"),
+                    })
+                } else {
+                    if let Some(parent) = new_path.parent() {
+                        if let Err(error) = std::fs::create_dir_all(parent) {
+                            let result = Err(RpcError {
+                                code: 0,
+                                message: error.to_string(),
+                            });
+                            self.respond_rpc(id, result);
+                            return;
+                        }
+                    }
+                    std::fs::copy(existing_path, new_path)
+                        .map(|_| ProxyResponse::Success {})
+                        .map_err(|e| RpcError {
+                            code: 0,
+                            message: e.to_string(),
+                        })
+                };
+                self.respond_rpc(id, result);
+            }
+            RenamePath { from, to } => {
+                // We first check if the destination already exists, because rename can overwrite it
+                // and that's not the default behavior we want for when a user renames a document.
+                let result = if to.exists() {
+                    Err(RpcError {
+                        code: 0,
+                        message: format!("{to:?} already exists"),
+                    })
+                } else {
+                    std::fs::rename(from, to)
+                        .map(|_| ProxyResponse::Success {})
+                        .map_err(|e| RpcError {
+                            code: 0,
+                            message: e.to_string(),
+                        })
+                };
+                self.respond_rpc(id, result);
+            }
+            GetSelectionRange { positions, path } => {
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.get_selection_range(
+                    path.as_path(),
+                    positions,
+                    move |_, result| {
+                        let result = result.map(|ranges| {
+                            ProxyResponse::GetSelectionRange { ranges }
+                        });
+                        proxy_rpc.handle_response(id, result);
+                    },
+                );
+            }
+            CodeActionResolve {
+                action_item,
+                plugin_id,
+            } => {
+                let proxy_rpc = self.proxy_rpc.clone();
+                self.catalog_rpc.action_resolve(
+                    *action_item,
+                    plugin_id,
+                    move |result| {
+                        let result = result.map(|item| {
+                            ProxyResponse::CodeActionResolveResponse {
+                                item: Box::new(item),
+                            }
+                        });
+                        proxy_rpc.handle_response(id, result);
+                    },
+                );
+            }
+        }
+    }
+}
+
+impl Dispatcher {
+    pub fn new(core_rpc: CoreRpcHandler, proxy_rpc: ProxyRpcHandler) -> Self {
+        let plugin_rpc =
+            PluginCatalogRpcHandler::new(core_rpc.clone(), proxy_rpc.clone());
+
+        let file_watcher = FileWatcher::new();
+
+        Self {
+            workspace: None,
+            proxy_rpc,
+            core_rpc,
+            catalog_rpc: plugin_rpc,
+            buffers: HashMap::new(),
+            terminals: HashMap::new(),
+            file_watcher,
+            window_id: 1,
+            tab_id: 1,
+        }
+    }
+
+    fn respond_rpc(&self, id: RequestId, result: Result<ProxyResponse, RpcError>) {
+        self.proxy_rpc.handle_response(id, result);
+    }
+}
+
+struct FileWatchNotifier {
+    core_rpc: CoreRpcHandler,
+    proxy_rpc: ProxyRpcHandler,
+    workspace: Option<PathBuf>,
+    workspace_fs_change_handler: Arc<Mutex<Option<Sender<bool>>>>,
+    last_diff: Arc<Mutex<DiffInfo>>,
+}
+
+impl Notify for FileWatchNotifier {
+    fn notify(&self, events: Vec<(WatchToken, notify::Event)>) {
+        self.handle_fs_events(events);
+    }
+}
+
+impl FileWatchNotifier {
+    fn new(
+        workspace: Option<PathBuf>,
+        core_rpc: CoreRpcHandler,
+        proxy_rpc: ProxyRpcHandler,
+    ) -> Self {
+        let notifier = Self {
+            workspace,
+            core_rpc,
+            proxy_rpc,
+            workspace_fs_change_handler: Arc::new(Mutex::new(None)),
+            last_diff: Arc::new(Mutex::new(DiffInfo::default())),
+        };
+
+        if let Some(workspace) = notifier.workspace.clone() {
+            let core_rpc = notifier.core_rpc.clone();
+            let last_diff = notifier.last_diff.clone();
+            thread::spawn(move || {
+                if let Some(diff) = git_diff_new(&workspace) {
+                    core_rpc.diff_info(diff.clone());
+                    *last_diff.lock() = diff;
                 }
+            });
+        }
+
+        notifier
+    }
+
+    fn handle_fs_events(&self, events: Vec<(WatchToken, notify::Event)>) {
+        for (token, event) in events {
+            match token {
+                OPEN_FILE_EVENT_TOKEN => self.handle_open_file_fs_event(event),
+                WORKSPACE_EVENT_TOKEN => self.handle_workspace_fs_event(event),
+                _ => {}
+            }
+        }
+    }
+
+    fn handle_open_file_fs_event(&self, event: notify::Event) {
+        if event.kind.is_modify() {
+            for path in event.paths {
+                self.proxy_rpc
+                    .notification(ProxyNotification::OpenFileChanged { path });
             }
         }
     }
+
+    fn handle_workspace_fs_event(&self, event: notify::Event) {
+        let explorer_change = match &event.kind {
+            notify::EventKind::Create(_)
+            | notify::EventKind::Remove(_)
+            | notify::EventKind::Modify(notify::event::ModifyKind::Name(_)) => true,
+            notify::EventKind::Modify(_) => false,
+            _ => return,
+        };
+
+        let mut handler = self.workspace_fs_change_handler.lock();
+        if let Some(sender) = handler.as_mut() {
+            if explorer_change {
+                // only send the value if we need to update file explorer as well
+                let _ = sender.send(explorer_change);
+            }
+            return;
+        }
+        let (sender, receiver) = crossbeam_channel::unbounded();
+        if explorer_change {
+            // only send the value if we need to update file explorer as well
+            let _ = sender.send(explorer_change);
+        }
+
+        let local_handler = self.workspace_fs_change_handler.clone();
+        let core_rpc = self.core_rpc.clone();
+        let workspace = self.workspace.clone().unwrap();
+        let last_diff = self.last_diff.clone();
+        thread::spawn(move || {
+            thread::sleep(Duration::from_millis(500));
+
+            {
+                local_handler.lock().take();
+            }
+
+            let mut explorer_change = false;
+            for e in receiver {
+                if e {
+                    explorer_change = true;
+                    break;
+                }
+            }
+            if explorer_change {
+                core_rpc.workspace_file_change();
+            }
+            if let Some(diff) = git_diff_new(&workspace) {
+                let mut last_diff = last_diff.lock();
+                if diff != *last_diff {
+                    core_rpc.diff_info(diff.clone());
+                    *last_diff = diff;
+                }
+            }
+        });
+        *handler = Some(sender);
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -663,16 +974,19 @@ pub struct DiffHunk {
     pub header: String,
 }
 
+fn git_init(workspace_path: &Path) -> Result<()> {
+    if Repository::discover(workspace_path).is_err() {
+        Repository::init(workspace_path)?;
+    };
+    Ok(())
+}
+
 fn git_commit(
     workspace_path: &Path,
     message: &str,
     diffs: Vec<FileDiff>,
 ) -> Result<()> {
-    let repo = Repository::open(
-        workspace_path
-            .to_str()
-            .ok_or_else(|| anyhow!("workspace path can't changed to str"))?,
-    )?;
+    let repo = Repository::discover(workspace_path)?;
     let mut index = repo.index()?;
     for diff in diffs {
         match diff {
@@ -693,6 +1007,7 @@ fn git_commit(
     let tree = repo.find_tree(tree)?;
     let signature = repo.signature()?;
     let parent = repo.head()?.peel_to_commit()?;
+
     repo.commit(
         Some("HEAD"),
         &signature,
@@ -705,17 +1020,53 @@ fn git_commit(
 }
 
 fn git_checkout(workspace_path: &Path, branch: &str) -> Result<()> {
-    let repo = Repository::open(
-        workspace_path
-            .to_str()
-            .ok_or_else(|| anyhow!("workspace path can't changed to str"))?,
-    )?;
+    let repo = Repository::discover(workspace_path)?;
     let (object, reference) = repo.revparse_ext(branch)?;
     repo.checkout_tree(&object, None)?;
     repo.set_head(reference.unwrap().name().unwrap())?;
     Ok(())
 }
 
+fn git_discard_files_changes<'a>(
+    workspace_path: &Path,
+    files: impl Iterator<Item = &'a Path>,
+) -> Result<()> {
+    let repo = Repository::discover(workspace_path)?;
+
+    let mut checkout_b = CheckoutBuilder::new();
+    checkout_b.update_only(false).force();
+
+    let mut had_path = false;
+    for path in files {
+        // Remove the workspace path so it is relative to the folder
+        if let Ok(path) = path.strip_prefix(workspace_path) {
+            had_path = true;
+            checkout_b.path(path);
+        }
+    }
+
+    if !had_path {
+        // If there we no paths then we do nothing
+        // because the default behavior of checkout builder is to select all files
+        // if it is not given a path
+        return Ok(());
+    }
+
+    repo.checkout_index(None, Some(&mut checkout_b))?;
+
+    Ok(())
+}
+
+fn git_discard_workspace_changes(workspace_path: &Path) -> Result<()> {
+    let repo = Repository::discover(workspace_path)?;
+    let mut checkout_b = CheckoutBuilder::new();
+    checkout_b.force();
+
+    repo.checkout_index(None, Some(&mut checkout_b))?;
+
+    Ok(())
+}
+
 fn git_delta_format(
     workspace_path: &Path,
     delta: &git2::DiffDelta,
@@ -741,7 +1092,7 @@ fn git_delta_format(
 }
 
 fn git_diff_new(workspace_path: &Path) -> Option<DiffInfo> {
-    let repo = Repository::open(workspace_path.to_str()?).ok()?;
+    let repo = Repository::discover(workspace_path).ok()?;
     let head = repo.head().ok()?;
     let name = head.shorthand()?.to_string();
 
@@ -777,13 +1128,13 @@ fn git_diff_new(workspace_path: &Path) -> Option<DiffInfo> {
     let mut renames = Vec::new();
     let mut renamed_deltas = HashSet::new();
 
-    for (i, delta) in deltas.iter().enumerate() {
+    for (added_index, delta) in deltas.iter().enumerate() {
         if delta.0 == git2::Delta::Added {
-            for (j, d) in deltas.iter().enumerate() {
+            for (deleted_index, d) in deltas.iter().enumerate() {
                 if d.0 == git2::Delta::Deleted && d.1 == delta.1 {
-                    renames.push((i, j));
-                    renamed_deltas.insert(i);
-                    renamed_deltas.insert(j);
+                    renames.push((added_index, deleted_index));
+                    renamed_deltas.insert(added_index);
+                    renamed_deltas.insert(deleted_index);
                     break;
                 }
             }
@@ -791,10 +1142,10 @@ fn git_diff_new(workspace_path: &Path) -> Option<DiffInfo> {
     }
 
     let mut file_diffs = Vec::new();
-    for (i, j) in renames.iter() {
+    for (added_index, deleted_index) in renames.iter() {
         file_diffs.push(FileDiff::Renamed(
-            deltas[*i].2.clone(),
-            deltas[*j].2.clone(),
+            deltas[*added_index].2.clone(),
+            deltas[*deleted_index].2.clone(),
         ));
     }
     for (i, delta) in deltas.iter().enumerate() {
@@ -823,11 +1174,7 @@ fn git_diff_new(workspace_path: &Path) -> Option<DiffInfo> {
 }
 
 fn file_get_head(workspace_path: &Path, path: &Path) -> Result<(String, String)> {
-    let repo = Repository::open(
-        workspace_path
-            .to_str()
-            .ok_or_else(|| anyhow!("can't to str"))?,
-    )?;
+    let repo = Repository::discover(workspace_path)?;
     let head = repo.head()?;
     let tree = head.peel_to_tree()?;
     let tree_entry = tree.get_path(path.strip_prefix(workspace_path)?)?;
@@ -838,3 +1185,120 @@ fn file_get_head(workspace_path: &Path, path: &Path) -> Result<(String, String)>
         .to_string();
     Ok((id, content))
 }
+
+fn git_get_remote_file_url(workspace_path: &Path, file: &Path) -> Result<String> {
+    let repo = Repository::discover(workspace_path)?;
+    let head = repo.head()?;
+    let target_remote = repo.find_remote("origin")?;
+
+    // Grab URL part of remote
+    let remote = target_remote
+        .url()
+        .ok_or(anyhow!("Failed to convert remote to str"))?;
+
+    let remote_url = match Url::parse(remote) {
+        Ok(url) => url,
+        Err(_) => {
+            // Parse URL as ssh
+            Url::parse(&format!("ssh://{}", remote.replacen(':', "/", 1)))?
+        }
+    };
+
+    // Get host part
+    let host = remote_url
+        .host_str()
+        .ok_or(anyhow!("Couldn't find remote host"))?;
+    // Get namespace (e.g. organisation/project in case of GitHub, org/team/team/team/../project on GitLab)
+    let namespace = if let Some(stripped) = remote_url.path().strip_suffix(".git") {
+        stripped
+    } else {
+        remote_url.path()
+    };
+
+    let commit = head.peel_to_commit()?.id();
+
+    let file_path = file
+        .strip_prefix(workspace_path)?
+        .to_str()
+        .ok_or(anyhow!("Couldn't convert file path to str"))?;
+
+    let url = format!("https://{host}{namespace}/blob/{commit}/{file_path}",);
+
+    Ok(url)
+}
+
+fn search_in_path(
+    id: u64,
+    current_id: &AtomicU64,
+    paths: impl Iterator<Item = PathBuf>,
+    pattern: &str,
+    case_sensitive: bool,
+) -> Result<ProxyResponse, RpcError> {
+    let mut matches = IndexMap::new();
+    let pattern = regex::escape(pattern);
+    let matcher = RegexMatcherBuilder::new()
+        .case_insensitive(!case_sensitive)
+        .build_literals(&[&pattern])
+        .map_err(|_| RpcError {
+            code: 0,
+            message: "can't build matcher".to_string(),
+        })?;
+    let mut searcher = SearcherBuilder::new().build();
+
+    for path in paths {
+        if current_id.load(Ordering::SeqCst) != id {
+            return Err(RpcError {
+                code: 0,
+                message: "expired search job".to_string(),
+            });
+        }
+
+        if path.is_file() {
+            let mut line_matches = Vec::new();
+            let _ = searcher.search_path(
+                &matcher,
+                path.clone(),
+                UTF8(|lnum, line| {
+                    if current_id.load(Ordering::SeqCst) != id {
+                        return Ok(false);
+                    }
+
+                    let mymatch = matcher.find(line.as_bytes())?.unwrap();
+                    let line = if line.len() > 200 {
+                        // Shorten the line to avoid sending over absurdly long-lines
+                        // (such as in minified javascript)
+                        // Note that the start/end are column based, not absolute from the
+                        // start of the file.
+                        let left_keep = line[..mymatch.start()]
+                            .chars()
+                            .rev()
+                            .take(100)
+                            .map(|c| c.len_utf8())
+                            .sum::<usize>();
+                        let right_keep = line[mymatch.end()..]
+                            .chars()
+                            .take(100)
+                            .map(|c| c.len_utf8())
+                            .sum::<usize>();
+                        let display_range =
+                            mymatch.start() - left_keep..mymatch.end() + right_keep;
+                        line[display_range].to_string()
+                    } else {
+                        line.to_string()
+                    };
+                    line_matches.push((
+                        lnum as usize,
+                        (mymatch.start(), mymatch.end()),
+                        line,
+                    ));
+                    Ok(true)
+                }),
+            );
+            if !line_matches.is_empty() {
+                matches.insert(path.clone(), line_matches);
+            }
+        }
+    }
+
+    Ok(ProxyResponse::GlobalSearchResponse { matches })
+}
diff --git a/lapce-proxy/src/lib.rs b/lapce-proxy/src/lib.rs
index 646539389e..eb7f537c4e 100644
--- a/lapce-proxy/src/lib.rs
+++ b/lapce-proxy/src/lib.rs
@@ -1,14 +1,170 @@
+#![allow(clippy::manual_clamp)]
+
 pub mod buffer;
 pub mod dispatch;
-pub mod lsp;
 pub mod plugin;
 pub mod terminal;
 pub mod watcher;
 
+use std::{
+    io::{stdin, stdout, BufReader},
+    path::PathBuf,
+    sync::Arc,
+    thread,
+};
+
+use anyhow::{anyhow, Result};
+use clap::Parser;
 use dispatch::Dispatcher;
+use lapce_core::{directory::Directory, meta};
+use lapce_rpc::{
+    core::{CoreRpc, CoreRpcHandler},
+    proxy::{ProxyMessage, ProxyNotification, ProxyRpcHandler},
+    stdio::stdio_transport,
+    RpcMessage,
+};
+
+#[derive(Parser)]
+#[clap(name = "Lapce")]
+#[clap(version=*meta::VERSION)]
+struct Cli {
+    #[clap(short, long, action)]
+    proxy: bool,
+    paths: Vec<PathBuf>,
+}
 
 pub fn mainloop() {
-    let (sender, receiver) = lapce_rpc::stdio();
-    let dispatcher = Dispatcher::new(sender);
-    let _ = dispatcher.mainloop(receiver);
+    let cli = Cli::parse();
+    if !cli.proxy {
+        let pwd = std::env::current_dir().unwrap_or_default();
+        let paths: Vec<_> = cli
+            .paths
+            .iter()
+            .map(|p| pwd.join(p).canonicalize().unwrap_or_default())
+            .collect();
+        let _ = try_open_in_existing_process(&paths);
+        return;
+    }
+    let core_rpc = CoreRpcHandler::new();
+    let proxy_rpc = ProxyRpcHandler::new();
+    let mut dispatcher = Dispatcher::new(core_rpc.clone(), proxy_rpc.clone());
+
+    let (writer_tx, writer_rx) = crossbeam_channel::unbounded();
+    let (reader_tx, reader_rx) = crossbeam_channel::unbounded();
+    stdio_transport(stdout(), writer_rx, BufReader::new(stdin()), reader_tx);
+
+    let local_core_rpc = core_rpc.clone();
+    let local_writer_tx = writer_tx.clone();
+    thread::spawn(move || {
+        for msg in local_core_rpc.rx() {
+            match msg {
+                CoreRpc::Request(id, rpc) => {
+                    let _ = local_writer_tx.send(RpcMessage::Request(id, rpc));
+                }
+                CoreRpc::Notification(rpc) => {
+                    let _ = local_writer_tx.send(RpcMessage::Notification(rpc));
+                }
+                CoreRpc::Shutdown => {
+                    return;
+                }
+            }
+        }
+    });
+
+    let local_proxy_rpc = proxy_rpc.clone();
+    let writer_tx = Arc::new(writer_tx);
+    thread::spawn(move || {
+        for msg in reader_rx {
+            match msg {
+                RpcMessage::Request(id, req) => {
+                    let writer_tx = writer_tx.clone();
+                    local_proxy_rpc.request_async(req, move |result| match result {
+                        Ok(resp) => {
+                            let _ = writer_tx.send(RpcMessage::Response(id, resp));
+                        }
+                        Err(e) => {
+                            let _ = writer_tx.send(RpcMessage::Error(id, e));
+                        }
+                    });
+                }
+                RpcMessage::Notification(n) => {
+                    local_proxy_rpc.notification(n);
+                }
+                RpcMessage::Response(id, resp) => {
+                    core_rpc.handle_response(id, Ok(resp));
+                }
+                RpcMessage::Error(id, err) => {
+                    core_rpc.handle_response(id, Err(err));
+                }
+            }
+        }
+        local_proxy_rpc.shutdown();
+    });
+
+    let local_proxy_rpc = proxy_rpc.clone();
+    std::thread::spawn(move || {
+        let _ = listen_local_socket(local_proxy_rpc);
+    });
+    let _ = register_lapce_path();
+
+    proxy_rpc.mainloop(&mut dispatcher);
+}
+
+pub fn register_lapce_path() -> Result<()> {
+    let path = std::env::current_exe()?;
+
+    if let Some(path) = path.parent() {
+        if let Some(path) = path.to_str() {
+            if let Ok(current_path) = std::env::var("PATH") {
+                let mut paths = vec![PathBuf::from(path)];
+                paths.append(
+                    &mut std::env::split_paths(&current_path).collect::<Vec<_>>(),
+                );
+                std::env::set_var("PATH", std::env::join_paths(paths)?);
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn try_open_in_existing_process(paths: &[PathBuf]) -> Result<()> {
+    let local_socket = Directory::local_socket()
+        .ok_or_else(|| anyhow!("can't get local socket folder"))?;
+    let mut socket =
+        interprocess::local_socket::LocalSocketStream::connect(local_socket)?;
+    let folders: Vec<_> = paths.iter().filter(|p| p.is_dir()).cloned().collect();
+    let files: Vec<_> = paths.iter().filter(|p| p.is_file()).cloned().collect();
+    let msg: ProxyMessage =
+        RpcMessage::Notification(ProxyNotification::OpenPaths { folders, files });
+    lapce_rpc::stdio::write_msg(&mut socket, msg)?;
+    Ok(())
+}
+
+fn listen_local_socket(proxy_rpc: ProxyRpcHandler) -> Result<()> {
+    let local_socket = Directory::local_socket()
+        .ok_or_else(|| anyhow!("can't get local socket folder"))?;
+    let _ = std::fs::remove_file(&local_socket);
+    let socket =
+        interprocess::local_socket::LocalSocketListener::bind(local_socket)?;
+    for stream in socket.incoming().flatten() {
+        let mut reader = BufReader::new(stream);
+        let proxy_rpc = proxy_rpc.clone();
+        thread::spawn(move || -> Result<()> {
+            loop {
+                let msg: ProxyMessage = lapce_rpc::stdio::read_msg(&mut reader)?;
+                if let RpcMessage::Notification(ProxyNotification::OpenPaths {
+                    folders,
+                    files,
+                }) = msg
+                {
+                    proxy_rpc.notification(ProxyNotification::OpenPaths {
+                        folders,
+                        files,
+                    });
+                }
+            }
+        });
+    }
+    Ok(())
 }
diff --git a/lapce-proxy/src/lsp.rs b/lapce-proxy/src/lsp.rs
deleted file mode 100644
index 41f74f7a97..0000000000
--- a/lapce-proxy/src/lsp.rs
+++ /dev/null
@@ -1,1090 +0,0 @@
-use std::{
-    collections::HashMap,
-    io::BufRead,
-    io::{BufReader, BufWriter, Write},
-    process::{self, Child, ChildStdout, Command, Stdio},
-    sync::{mpsc::channel, Arc},
-    thread,
-    time::Duration,
-};
-
-#[cfg(target_os = "windows")]
-use std::os::windows::process::CommandExt;
-
-use anyhow::{anyhow, Result};
-use jsonrpc_lite::{Id, JsonRpc, Params};
-use lapce_rpc::{
-    buffer::BufferId,
-    style::{LineStyle, Style},
-    RequestId,
-};
-use lsp_types::*;
-use parking_lot::Mutex;
-use serde_json::{json, to_value, Value};
-
-use crate::buffer::Buffer;
-use crate::dispatch::Dispatcher;
-
-pub type Callback = Box<dyn Callable>;
-const HEADER_CONTENT_LENGTH: &str = "content-length";
-const HEADER_CONTENT_TYPE: &str = "content-type";
-
-pub trait Callable: Send {
-    fn call(self: Box<Self>, client: &LspClient, result: Result<Value>);
-}
-
-impl<F: Send + FnOnce(&LspClient, Result<Value>)> Callable for F {
-    fn call(self: Box<F>, client: &LspClient, result: Result<Value>) {
-        (*self)(client, result)
-    }
-}
-
-pub struct LspCatalog {
-    pub dispatcher: Option<Dispatcher>,
-    clients: HashMap<String, Arc<LspClient>>,
-}
-
-pub struct LspState {
-    next_id: u64,
-    writer: Box<dyn Write + Send>,
-    process: Child,
-    pending: HashMap<u64, Callback>,
-    pub server_capabilities: Option<ServerCapabilities>,
-    pub opened_documents: HashMap<BufferId, Url>,
-    pub is_initialized: bool,
-}
-
-#[derive(Clone)]
-pub struct LspClient {
-    exec_path: String,
-    options: Option<Value>,
-    state: Arc<Mutex<LspState>>,
-    dispatcher: Dispatcher,
-}
-
-impl LspCatalog {
-    pub fn new() -> LspCatalog {
-        LspCatalog {
-            dispatcher: None,
-            clients: HashMap::new(),
-        }
-    }
-
-    pub fn stop(&mut self) {
-        for (_, client) in self.clients.iter() {
-            client.stop();
-        }
-        self.clients.clear();
-        self.dispatcher.take();
-    }
-
-    pub fn start_server(
-        &mut self,
-        exec_path: &str,
-        language_id: &str,
-        options: Option<Value>,
-    ) {
-        let client = LspClient::new(
-            language_id.to_string(),
-            exec_path,
-            options,
-            self.dispatcher.clone().unwrap(),
-        );
-        self.clients.insert(language_id.to_string(), client);
-    }
-
-    pub fn new_buffer(
-        &self,
-        buffer_id: &BufferId,
-        path: &str,
-        language_id: &str,
-        text: String,
-    ) {
-        let document_uri = Url::from_file_path(path).unwrap();
-        if let Some(client) = self.clients.get(language_id) {
-            client.send_did_open(buffer_id, document_uri, language_id, text);
-        }
-    }
-
-    pub fn save_buffer(&self, buffer: &Buffer) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            let uri = client.get_uri(buffer);
-            client.send_did_save(uri);
-        }
-    }
-
-    pub fn get_semantic_tokens(&self, buffer: &Buffer) {
-        let buffer_id = buffer.id;
-        let path = buffer.path.clone();
-        let rev = buffer.rev;
-        let len = buffer.len();
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            let uri = client.get_uri(buffer);
-            let local_dispatcher = self.dispatcher.clone().unwrap();
-            client.request_semantic_tokens(uri, move |lsp_client, result| {
-                if let Ok(res) = result {
-                    let buffers = local_dispatcher.buffers.lock();
-                    let buffer = buffers.get(&buffer_id).unwrap();
-                    if buffer.rev != rev {
-                        return;
-                    }
-                    let lsp_state = lsp_client.state.lock();
-                    let semantic_tokens_provider = &lsp_state
-                        .server_capabilities
-                        .as_ref()
-                        .unwrap()
-                        .semantic_tokens_provider;
-                    if let Some(styles) =
-                        format_semantic_styles(buffer, semantic_tokens_provider, res)
-                    {
-                        local_dispatcher.send_notification(
-                            "semantic_styles",
-                            json!({
-                                "rev": rev,
-                                "buffer_id": buffer_id,
-                                "path": path,
-                                "styles": styles,
-                                "len": len,
-                            }),
-                        )
-                    }
-                }
-            });
-        }
-    }
-
-    pub fn get_document_symbols(&self, id: RequestId, buffer: &Buffer) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            let uri = client.get_uri(buffer);
-            client.request_document_symbols(uri, move |lsp_client, result| {
-                lsp_client.dispatcher.respond(id, result);
-            });
-        }
-    }
-
-    pub fn get_document_formatting(&self, id: RequestId, buffer: &Buffer) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            let uri = client.get_uri(buffer);
-            client.request_document_formatting(uri, move |lsp_client, result| {
-                lsp_client.dispatcher.respond(id, result);
-            });
-        } else {
-            self.dispatcher
-                .as_ref()
-                .unwrap()
-                .respond(id, Err(anyhow!("no document formatting")));
-        }
-    }
-
-    pub fn get_completion(
-        &self,
-        id: RequestId,
-        _request_id: usize,
-        buffer: &Buffer,
-        position: Position,
-    ) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            let uri = client.get_uri(buffer);
-            client.request_completion(uri, position, move |lsp_client, result| {
-                let mut resp = json!({ "id": id });
-                match result {
-                    Ok(v) => resp["result"] = v,
-                    Err(e) => {
-                        resp["error"] = json!({
-                            "code": 0,
-                            "message": format!("{}",e),
-                        })
-                    }
-                }
-                let _ = lsp_client.dispatcher.sender.send(resp);
-            });
-        }
-    }
-
-    pub fn completion_resolve(
-        &self,
-        id: RequestId,
-        buffer: &Buffer,
-        completion_item: &CompletionItem,
-    ) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            client.completion_resolve(completion_item, move |lsp_client, result| {
-                let mut resp = json!({ "id": id });
-                match result {
-                    Ok(v) => resp["result"] = v,
-                    Err(e) => {
-                        resp["error"] = json!({
-                            "code": 0,
-                            "message": format!("{}",e),
-                        })
-                    }
-                }
-                let _ = lsp_client.dispatcher.sender.send(resp);
-            });
-        }
-    }
-
-    pub fn get_hover(
-        &self,
-        id: RequestId,
-        _request_id: usize,
-        buffer: &Buffer,
-        position: Position,
-    ) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            let uri = client.get_uri(buffer);
-            client.request_hover(uri, position, move |lsp_client, result| {
-                let mut resp = json!({ "id": id });
-                match result {
-                    Ok(v) => resp["result"] = v,
-                    Err(e) => {
-                        resp["error"] = json!({
-                            "code": 0,
-                            "message": format!("{}", e),
-                        })
-                    }
-                }
-                let _ = lsp_client.dispatcher.sender.send(resp);
-            });
-        }
-    }
-
-    pub fn get_signature(&self, id: RequestId, buffer: &Buffer, position: Position) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            let uri = client.get_uri(buffer);
-            client.request_signature(uri, position, move |lsp_client, result| {
-                let mut resp = json!({ "id": id });
-                match result {
-                    Ok(v) => resp["result"] = v,
-                    Err(e) => {
-                        resp["error"] = json!({
-                            "code": 0,
-                            "message": format!("{}",e),
-                        })
-                    }
-                }
-                let _ = lsp_client.dispatcher.sender.send(resp);
-            });
-        }
-    }
-
-    pub fn get_references(
-        &self,
-        id: RequestId,
-        buffer: &Buffer,
-        position: Position,
-    ) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            let uri = client.get_uri(buffer);
-            client.request_references(uri, position, move |lsp_client, result| {
-                let mut resp = json!({ "id": id });
-                match result {
-                    Ok(v) => resp["result"] = v,
-                    Err(e) => {
-                        resp["error"] = json!({
-                            "code": 0,
-                            "message": format!("{}",e),
-                        })
-                    }
-                }
-                let _ = lsp_client.dispatcher.sender.send(resp);
-            });
-        }
-    }
-
-    pub fn get_code_actions(
-        &self,
-        id: RequestId,
-        buffer: &Buffer,
-        position: Position,
-    ) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            let uri = client.get_uri(buffer);
-            let range = Range {
-                start: position,
-                end: position,
-            };
-            client.request_code_actions(uri, range, move |lsp_client, result| {
-                let mut resp = json!({ "id": id });
-                match result {
-                    Ok(v) => resp["result"] = v,
-                    Err(e) => {
-                        resp["error"] = json!({
-                            "code": 0,
-                            "message": format!("{}",e),
-                        })
-                    }
-                }
-                let _ = lsp_client.dispatcher.sender.send(resp);
-            });
-        }
-    }
-
-    pub fn get_definition(
-        &self,
-        id: RequestId,
-        _request_id: usize,
-        buffer: &Buffer,
-        position: Position,
-    ) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            let uri = client.get_uri(buffer);
-            client.request_definition(uri, position, move |lsp_client, result| {
-                let mut resp = json!({ "id": id });
-                match result {
-                    Ok(v) => resp["result"] = v,
-                    Err(e) => {
-                        resp["error"] = json!({
-                            "code": 0,
-                            "message": format!("{}",e),
-                        })
-                    }
-                }
-                let _ = lsp_client.dispatcher.sender.send(resp);
-            });
-        }
-    }
-
-    pub fn update(
-        &self,
-        buffer: &Buffer,
-        content_change: &TextDocumentContentChangeEvent,
-        rev: u64,
-    ) {
-        if let Some(client) = self.clients.get(&buffer.language_id) {
-            client.update(buffer, content_change, rev);
-        }
-    }
-}
-
-impl Default for LspCatalog {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl LspClient {
-    pub fn new(
-        _language_id: String,
-        exec_path: &str,
-        options: Option<Value>,
-        dispatcher: Dispatcher,
-    ) -> Arc<LspClient> {
-        let mut process = Self::process(exec_path);
-        let writer = Box::new(BufWriter::new(process.stdin.take().unwrap()));
-        let stdout = process.stdout.take().unwrap();
-
-        let lsp_client = Arc::new(LspClient {
-            dispatcher,
-            exec_path: exec_path.to_string(),
-            options,
-            state: Arc::new(Mutex::new(LspState {
-                next_id: 0,
-                writer,
-                process,
-                pending: HashMap::new(),
-                server_capabilities: None,
-                opened_documents: HashMap::new(),
-                is_initialized: false,
-            })),
-        });
-
-        lsp_client.handle_stdout(stdout);
-        lsp_client.initialize();
-
-        lsp_client
-    }
-
-    fn handle_stdout(&self, stdout: ChildStdout) {
-        let local_lsp_client = self.clone();
-        thread::spawn(move || {
-            let mut reader = Box::new(BufReader::new(stdout));
-            loop {
-                match read_message(&mut reader) {
-                    Ok(message_str) => {
-                        local_lsp_client.handle_message(message_str.as_ref());
-                    }
-                    Err(_err) => {
-                        local_lsp_client.stop();
-                        local_lsp_client.reload();
-                        return;
-                    }
-                };
-            }
-        });
-    }
-
-    fn process(exec_path: &str) -> Child {
-        let mut process = Command::new(exec_path);
-        #[cfg(target_os = "windows")]
-        let process = process.creation_flags(0x08000000);
-        process
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .spawn()
-            .expect("Error Occurred")
-    }
-
-    fn reload(&self) {
-        let mut process = Self::process(&self.exec_path);
-        let writer = Box::new(BufWriter::new(process.stdin.take().unwrap()));
-        let stdout = process.stdout.take().unwrap();
-
-        let mut state = self.state.lock();
-        state.next_id = 0;
-        state.pending.clear();
-        state.opened_documents.clear();
-        state.server_capabilities = None;
-        state.is_initialized = false;
-        state.writer = writer;
-        state.process = process;
-
-        self.handle_stdout(stdout);
-        self.initialize();
-    }
-
-    fn stop(&self) {
-        let _ = self.state.lock().process.kill();
-    }
-
-    pub fn get_uri(&self, buffer: &Buffer) -> Url {
-        let exists = {
-            let state = self.state.lock();
-            state.opened_documents.contains_key(&buffer.id)
-        };
-        if !exists {
-            let document_uri =
-                Url::from_file_path(&buffer.path).unwrap_or_else(|_| {
-                    panic!("Failed to create URL from path {:?}", buffer.path)
-                });
-            self.send_did_open(
-                &buffer.id,
-                document_uri,
-                &buffer.language_id,
-                buffer.get_document(),
-            );
-        }
-        self.state
-            .lock()
-            .opened_documents
-            .get(&buffer.id)
-            .unwrap()
-            .clone()
-    }
-
-    pub fn handle_message(&self, message: &str) {
-        match JsonRpc::parse(message) {
-            Ok(JsonRpc::Request(_obj)) => {
-                // trace!("client received unexpected request: {:?}", obj)
-            }
-            Ok(value @ JsonRpc::Notification(_)) => {
-                self.handle_notification(
-                    value.get_method().unwrap(),
-                    value.get_params().unwrap(),
-                );
-            }
-            Ok(value @ JsonRpc::Success(_)) => {
-                let id = number_from_id(&value.get_id().unwrap());
-                let result = value.get_result().unwrap();
-                self.handle_response(id, Ok(result.clone()));
-            }
-            Ok(value @ JsonRpc::Error(_)) => {
-                let id = number_from_id(&value.get_id().unwrap());
-                let error = value.get_error().unwrap();
-                self.handle_response(id, Err(anyhow!("{}", error)));
-            }
-            Err(_err) => {}
-        }
-    }
-
-    pub fn handle_notification(&self, method: &str, params: Params) {
-        match method {
-            "textDocument/publishDiagnostics" => {
-                self.dispatcher.send_notification(
-                    "publish_diagnostics",
-                    json!({
-                        "diagnostics": params,
-                    }),
-                );
-            }
-            "$/progress" => {
-                self.dispatcher.send_notification(
-                    "work_done_progress",
-                    json!({
-                        "progress": params,
-                    }),
-                );
-            }
-            _ => (),
-        }
-    }
-
-    pub fn handle_response(&self, id: u64, result: Result<Value>) {
-        let callback =
-            {
-                self.state.lock().pending.remove(&id).unwrap_or_else(|| {
-                    panic!("id {} missing from request table", id)
-                })
-            };
-        callback.call(self, result);
-    }
-
-    pub fn write(&self, msg: &str) -> Result<()> {
-        let mut state = self.state.lock();
-        state.writer.write_all(msg.as_bytes())?;
-        state.writer.flush()?;
-        Ok(())
-    }
-
-    fn send_rpc(&self, value: &Value) {
-        let rpc = match prepare_lsp_json(value) {
-            Ok(r) => r,
-            Err(err) => panic!("Encoding Error {:?}", err),
-        };
-
-        let _ = self.write(rpc.as_ref());
-    }
-
-    pub fn send_notification(&self, method: &str, params: Params) {
-        let notification = JsonRpc::notification_with_params(method, params);
-        let res = to_value(&notification).unwrap();
-        self.send_rpc(&res);
-    }
-
-    pub fn send_request(&self, method: &str, params: Params, completion: Callback) {
-        let request = {
-            let mut state = self.state.lock();
-            let next_id = state.next_id;
-            state.pending.insert(next_id, completion);
-            state.next_id += 1;
-
-            JsonRpc::request_with_params(Id::Num(next_id as i64), method, params)
-        };
-
-        self.send_rpc(&to_value(&request).unwrap());
-    }
-
-    fn initialize(&self) {
-        if let Some(workspace) = self.dispatcher.workspace.lock().clone() {
-            let root_url = Url::from_directory_path(workspace).unwrap();
-            let (sender, receiver) = channel();
-            self.send_initialize(Some(root_url), move |lsp_client, result| {
-                if let Ok(result) = result {
-                    {
-                        let init_result: InitializeResult =
-                            serde_json::from_value(result).unwrap();
-                        let mut state = lsp_client.state.lock();
-                        state.server_capabilities = Some(init_result.capabilities);
-                        state.is_initialized = true;
-                    }
-                    lsp_client.send_initialized();
-                }
-                let _ = sender.send(true);
-            });
-            let _ = receiver.recv_timeout(Duration::from_millis(1000));
-        }
-    }
-
-    pub fn send_did_open(
-        &self,
-        buffer_id: &BufferId,
-        document_uri: Url,
-        language_id: &str,
-        document_text: String,
-    ) {
-        let is_initialized = {
-            let mut state = self.state.lock();
-            state
-                .opened_documents
-                .insert(*buffer_id, document_uri.clone());
-            state.is_initialized
-        };
-
-        if !is_initialized {
-            self.initialize();
-        }
-
-        let text_document_did_open_params = DidOpenTextDocumentParams {
-            text_document: TextDocumentItem {
-                language_id: language_id.to_string(),
-                uri: document_uri,
-                version: 0,
-                text: document_text,
-            },
-        };
-        let params = Params::from(
-            serde_json::to_value(text_document_did_open_params).unwrap(),
-        );
-        self.send_notification("textDocument/didOpen", params);
-    }
-
-    pub fn send_did_save(&self, uri: Url) {
-        let params = DidSaveTextDocumentParams {
-            text_document: TextDocumentIdentifier { uri },
-            text: None,
-        };
-        let params = Params::from(serde_json::to_value(params).unwrap());
-        self.send_notification("textDocument/didSave", params);
-    }
-
-    pub fn send_initialized(&self) {
-        self.send_notification("initialized", Params::from(json!({})));
-    }
-
-    pub fn send_initialize<CB>(&self, root_uri: Option<Url>, on_init: CB)
-    where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let client_capabilities = ClientCapabilities {
-            text_document: Some(TextDocumentClientCapabilities {
-                completion: Some(CompletionClientCapabilities {
-                    completion_item: Some(CompletionItemCapability {
-                        snippet_support: Some(true),
-                        resolve_support: Some(
-                            CompletionItemCapabilityResolveSupport {
-                                properties: vec!["additionalTextEdits".to_string()],
-                            },
-                        ),
-                        ..Default::default()
-                    }),
-                    ..Default::default()
-                }),
-                // signature_help: Some(SignatureHelpCapability {
-                //     signature_information: Some(SignatureInformationSettings {
-                //         parameter_information: Some(ParameterInformationSettings {
-                //             label_offset_support: Some(true),
-                //         }),
-                //         active_parameter_support: Some(true),
-                //         documentation_format: Some(vec![
-                //             MarkupKind::Markdown,
-                //             MarkupKind::PlainText,
-                //         ]),
-                //     }),
-                //     ..Default::default()
-                // }),
-                hover: Some(HoverClientCapabilities {
-                    content_format: Some(vec![
-                        MarkupKind::Markdown,
-                        MarkupKind::PlainText,
-                    ]),
-                    ..Default::default()
-                }),
-                code_action: Some(CodeActionClientCapabilities {
-                    code_action_literal_support: Some(CodeActionLiteralSupport {
-                        code_action_kind: CodeActionKindLiteralSupport {
-                            value_set: vec![
-                                CodeActionKind::EMPTY.as_str().to_string(),
-                                CodeActionKind::QUICKFIX.as_str().to_string(),
-                                CodeActionKind::REFACTOR.as_str().to_string(),
-                                CodeActionKind::REFACTOR_EXTRACT
-                                    .as_str()
-                                    .to_string(),
-                                CodeActionKind::REFACTOR_INLINE.as_str().to_string(),
-                                CodeActionKind::REFACTOR_REWRITE
-                                    .as_str()
-                                    .to_string(),
-                                CodeActionKind::SOURCE.as_str().to_string(),
-                                CodeActionKind::SOURCE_ORGANIZE_IMPORTS
-                                    .as_str()
-                                    .to_string(),
-                            ],
-                        },
-                    }),
-                    ..Default::default()
-                }),
-                semantic_tokens: Some(SemanticTokensClientCapabilities {
-                    ..Default::default()
-                }),
-
-                ..Default::default()
-            }),
-            window: Some(WindowClientCapabilities {
-                work_done_progress: Some(true),
-                show_message: Some(ShowMessageRequestClientCapabilities {
-                    message_action_item: Some(MessageActionItemCapabilities {
-                        additional_properties_support: Some(true),
-                    }),
-                }),
-                ..Default::default()
-            }),
-            experimental: Some(json!({
-                "serverStatusNotification": true,
-            })),
-            ..Default::default()
-        };
-
-        #[allow(deprecated)]
-        let init_params = InitializeParams {
-            process_id: Some(process::id()),
-            root_uri,
-            initialization_options: self.options.clone(),
-            capabilities: client_capabilities,
-            trace: Some(TraceOption::Verbose),
-            workspace_folders: None,
-            client_info: None,
-            root_path: None,
-            locale: None,
-        };
-
-        let params = Params::from(serde_json::to_value(init_params).unwrap());
-        self.send_request("initialize", params, Box::new(on_init));
-    }
-
-    pub fn request_document_symbols<CB>(&self, document_uri: Url, cb: CB)
-    where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let params = DocumentSymbolParams {
-            text_document: TextDocumentIdentifier { uri: document_uri },
-            work_done_progress_params: WorkDoneProgressParams::default(),
-            partial_result_params: PartialResultParams::default(),
-        };
-        let params = Params::from(serde_json::to_value(params).unwrap());
-        self.send_request("textDocument/documentSymbol", params, Box::new(cb));
-    }
-
-    pub fn request_document_formatting<CB>(&self, document_uri: Url, cb: CB)
-    where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let params = DocumentFormattingParams {
-            text_document: TextDocumentIdentifier { uri: document_uri },
-            options: FormattingOptions {
-                tab_size: 4,
-                insert_spaces: true,
-                ..Default::default()
-            },
-            work_done_progress_params: WorkDoneProgressParams::default(),
-        };
-        let params = Params::from(serde_json::to_value(params).unwrap());
-        self.send_request("textDocument/formatting", params, Box::new(cb));
-    }
-
-    pub fn request_semantic_tokens<CB>(&self, document_uri: Url, cb: CB)
-    where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let params = SemanticTokensParams {
-            text_document: TextDocumentIdentifier { uri: document_uri },
-            work_done_progress_params: WorkDoneProgressParams::default(),
-            partial_result_params: PartialResultParams::default(),
-        };
-        let params = Params::from(serde_json::to_value(params).unwrap());
-        self.send_request("textDocument/semanticTokens/full", params, Box::new(cb));
-    }
-
-    pub fn request_code_actions<CB>(&self, document_uri: Url, range: Range, cb: CB)
-    where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let params = CodeActionParams {
-            text_document: TextDocumentIdentifier { uri: document_uri },
-            range,
-            context: CodeActionContext::default(),
-            work_done_progress_params: WorkDoneProgressParams::default(),
-            partial_result_params: PartialResultParams::default(),
-        };
-        let params = Params::from(serde_json::to_value(params).unwrap());
-        self.send_request("textDocument/codeAction", params, Box::new(cb));
-    }
-
-    pub fn request_references<CB>(
-        &self,
-        document_uri: Url,
-        position: Position,
-        cb: CB,
-    ) where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let params = ReferenceParams {
-            text_document_position: TextDocumentPositionParams {
-                text_document: TextDocumentIdentifier { uri: document_uri },
-                position,
-            },
-            work_done_progress_params: WorkDoneProgressParams::default(),
-            partial_result_params: PartialResultParams::default(),
-            context: ReferenceContext {
-                include_declaration: false,
-            },
-        };
-        let params = Params::from(serde_json::to_value(params).unwrap());
-        self.send_request("textDocument/references", params, Box::new(cb));
-    }
-
-    pub fn request_definition<CB>(
-        &self,
-        document_uri: Url,
-        position: Position,
-        cb: CB,
-    ) where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let params = GotoDefinitionParams {
-            text_document_position_params: TextDocumentPositionParams {
-                text_document: TextDocumentIdentifier { uri: document_uri },
-                position,
-            },
-            work_done_progress_params: WorkDoneProgressParams::default(),
-            partial_result_params: PartialResultParams::default(),
-        };
-        let params = Params::from(serde_json::to_value(params).unwrap());
-        self.send_request("textDocument/definition", params, Box::new(cb));
-    }
-
-    pub fn request_completion<CB>(
-        &self,
-        document_uri: Url,
-        position: Position,
-        on_completion: CB,
-    ) where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let completion_params = CompletionParams {
-            text_document_position: TextDocumentPositionParams {
-                text_document: TextDocumentIdentifier { uri: document_uri },
-                position,
-            },
-            work_done_progress_params: WorkDoneProgressParams::default(),
-            partial_result_params: PartialResultParams::default(),
-            context: None,
-        };
-        let params = Params::from(serde_json::to_value(completion_params).unwrap());
-        self.send_request(
-            "textDocument/completion",
-            params,
-            Box::new(on_completion),
-        );
-    }
-
-    pub fn completion_resolve<CB>(
-        &self,
-        completion_item: &CompletionItem,
-        on_result: CB,
-    ) where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let params = Params::from(serde_json::to_value(completion_item).unwrap());
-        self.send_request("completionItem/resolve", params, Box::new(on_result));
-    }
-
-    pub fn request_hover<CB>(&self, document_uri: Url, position: Position, cb: CB)
-    where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let hover_params = HoverParams {
-            text_document_position_params: TextDocumentPositionParams {
-                text_document: TextDocumentIdentifier { uri: document_uri },
-                position,
-            },
-            work_done_progress_params: WorkDoneProgressParams::default(),
-        };
-        let params = Params::from(serde_json::to_value(hover_params).unwrap());
-        self.send_request("textDocument/hover", params, Box::new(cb));
-    }
-
-    pub fn request_signature<CB>(
-        &self,
-        document_uri: Url,
-        position: Position,
-        cb: CB,
-    ) where
-        CB: 'static + Send + FnOnce(&LspClient, Result<Value>),
-    {
-        let params = SignatureHelpParams {
-            text_document_position_params: TextDocumentPositionParams {
-                text_document: TextDocumentIdentifier { uri: document_uri },
-                position,
-            },
-            work_done_progress_params: WorkDoneProgressParams::default(),
-            context: None,
-        };
-        let params = Params::from(serde_json::to_value(params).unwrap());
-        self.send_request("textDocument/signatureHelp", params, Box::new(cb));
-    }
-
-    pub fn send_did_change(
-        &self,
-        buffer: &Buffer,
-        changes: Vec<TextDocumentContentChangeEvent>,
-        version: u64,
-    ) {
-        let uri = self.get_uri(buffer);
-        let text_document_did_change_params = DidChangeTextDocumentParams {
-            text_document: VersionedTextDocumentIdentifier {
-                uri,
-                version: version as i32,
-            },
-            content_changes: changes,
-        };
-
-        let params = Params::from(
-            serde_json::to_value(text_document_did_change_params).unwrap(),
-        );
-        self.send_notification("textDocument/didChange", params);
-    }
-
-    pub fn get_sync_kind(&self) -> Option<TextDocumentSyncKind> {
-        let state = self.state.lock();
-        let text_document_sync = state
-            .server_capabilities
-            .as_ref()
-            .and_then(|c| c.text_document_sync.as_ref())?;
-        match text_document_sync {
-            TextDocumentSyncCapability::Kind(kind) => Some(*kind),
-            TextDocumentSyncCapability::Options(options) => options.clone().change,
-        }
-    }
-
-    pub fn update(
-        &self,
-        buffer: &Buffer,
-        content_change: &TextDocumentContentChangeEvent,
-        rev: u64,
-    ) {
-        let sync_kind = self.get_sync_kind().unwrap_or(TextDocumentSyncKind::Full);
-        let changes = get_change_for_sync_kind(sync_kind, buffer, content_change);
-        if let Some(changes) = changes {
-            self.send_did_change(buffer, changes, rev);
-        }
-    }
-}
-
-pub enum LspHeader {
-    ContentType,
-    ContentLength(usize),
-}
-
-fn number_from_id(id: &Id) -> u64 {
-    match *id {
-        Id::Num(n) => n as u64,
-        Id::Str(ref s) => s
-            .parse::<u64>()
-            .expect("failed to convert string id to u64"),
-        _ => panic!("unexpected value for id: None"),
-    }
-}
-
-fn prepare_lsp_json(msg: &Value) -> Result<String> {
-    let request = serde_json::to_string(&msg)?;
-    Ok(format!(
-        "Content-Length: {}\r\n\r\n{}",
-        request.len(),
-        request
-    ))
-}
-
-fn parse_header(s: &str) -> Result<LspHeader> {
-    let split: Vec<String> =
-        s.splitn(2, ": ").map(|s| s.trim().to_lowercase()).collect();
-    if split.len() != 2 {
-        return Err(anyhow!("Malformed"));
-    };
-    match split[0].as_ref() {
-        HEADER_CONTENT_TYPE => Ok(LspHeader::ContentType),
-        HEADER_CONTENT_LENGTH => {
-            Ok(LspHeader::ContentLength(split[1].parse::<usize>()?))
-        }
-        _ => Err(anyhow!("Unknown parse error occurred")),
-    }
-}
-
-pub fn read_message<T: BufRead>(reader: &mut T) -> Result<String> {
-    let mut buffer = String::new();
-    let mut content_length: Option<usize> = None;
-
-    loop {
-        buffer.clear();
-        let _result = reader.read_line(&mut buffer);
-        // eprin
-        match &buffer {
-            s if s.trim().is_empty() => break,
-            s => {
-                match parse_header(s)? {
-                    LspHeader::ContentLength(len) => content_length = Some(len),
-                    LspHeader::ContentType => (),
-                };
-            }
-        };
-    }
-
-    let content_length = content_length
-        .ok_or_else(|| anyhow!("missing content-length header: {}", buffer))?;
-
-    let mut body_buffer = vec![0; content_length];
-    reader.read_exact(&mut body_buffer)?;
-
-    let body = String::from_utf8(body_buffer)?;
-    Ok(body)
-}
-
-pub fn get_change_for_sync_kind(
-    sync_kind: TextDocumentSyncKind,
-    buffer: &Buffer,
-    content_change: &TextDocumentContentChangeEvent,
-) -> Option<Vec<TextDocumentContentChangeEvent>> {
-    match sync_kind {
-        TextDocumentSyncKind::None => None,
-        TextDocumentSyncKind::Full => {
-            let text_document_content_change_event =
-                TextDocumentContentChangeEvent {
-                    range: None,
-                    range_length: None,
-                    text: buffer.get_document(),
-                };
-            Some(vec![text_document_content_change_event])
-        }
-        TextDocumentSyncKind::Incremental => Some(vec![content_change.clone()]),
-    }
-}
-
-fn format_semantic_styles(
-    buffer: &Buffer,
-    semantic_tokens_provider: &Option<SemanticTokensServerCapabilities>,
-    value: Value,
-) -> Option<Vec<LineStyle>> {
-    let semantic_tokens: SemanticTokens = serde_json::from_value(value).ok()?;
-    let semantic_tokens_provider = semantic_tokens_provider.as_ref()?;
-    let semantic_legends = semantic_tokens_legend(semantic_tokens_provider);
-
-    let mut highlights = Vec::new();
-    let mut line = 0;
-    let mut start = 0;
-    let mut last_start = 0;
-    for semantic_token in &semantic_tokens.data {
-        if semantic_token.delta_line > 0 {
-            line += semantic_token.delta_line as usize;
-            start = buffer.offset_of_line(line);
-        }
-        start += semantic_token.delta_start as usize;
-        let end = start + semantic_token.length as usize;
-        let kind = semantic_legends.token_types[semantic_token.token_type as usize]
-            .as_str()
-            .to_string();
-        if start < last_start {
-            continue;
-        }
-        last_start = start;
-        highlights.push(LineStyle {
-            start,
-            end,
-            style: Style {
-                fg_color: Some(kind),
-            },
-        });
-    }
-
-    Some(highlights)
-}
-
-fn semantic_tokens_legend(
-    semantic_tokens_provider: &SemanticTokensServerCapabilities,
-) -> SemanticTokensLegend {
-    match semantic_tokens_provider {
-        SemanticTokensServerCapabilities::SemanticTokensOptions(options) => {
-            options.legend.clone()
-        }
-        SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(
-            options,
-        ) => options.semantic_tokens_options.legend.clone(),
-    }
-}
diff --git a/lapce-proxy/src/plugin.rs b/lapce-proxy/src/plugin.rs
deleted file mode 100644
index 3a089183d5..0000000000
--- a/lapce-proxy/src/plugin.rs
+++ /dev/null
@@ -1,406 +0,0 @@
-use anyhow::{anyhow, Result};
-use home::home_dir;
-use hotwatch::Hotwatch;
-use lapce_rpc::counter::Counter;
-use lapce_rpc::plugin::{PluginDescription, PluginId, PluginInfo};
-use serde::de::DeserializeOwned;
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::collections::HashMap;
-use std::fs;
-use std::io::{Read, Write};
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::thread;
-use std::time::Duration;
-use toml;
-use wasmer::ChainableNamedResolver;
-use wasmer::ImportObject;
-use wasmer::Store;
-use wasmer::WasmerEnv;
-use wasmer_wasi::Pipe;
-use wasmer_wasi::WasiEnv;
-use wasmer_wasi::WasiState;
-
-use crate::dispatch::Dispatcher;
-
-pub type PluginName = String;
-
-#[derive(WasmerEnv, Clone)]
-pub(crate) struct PluginEnv {
-    wasi_env: WasiEnv,
-    desc: PluginDescription,
-    dispatcher: Dispatcher,
-}
-
-#[derive(Clone)]
-pub(crate) struct Plugin {
-    instance: wasmer::Instance,
-    env: PluginEnv,
-}
-
-pub struct PluginCatalog {
-    id_counter: Counter,
-    pub items: HashMap<PluginName, PluginDescription>,
-    plugins: HashMap<PluginName, Plugin>,
-    store: Store,
-}
-
-impl PluginCatalog {
-    pub fn new() -> PluginCatalog {
-        PluginCatalog {
-            id_counter: Counter::new(),
-            items: HashMap::new(),
-            plugins: HashMap::new(),
-            store: Store::default(),
-        }
-    }
-
-    pub fn stop(&mut self) {
-        self.items.clear();
-        self.plugins.clear();
-    }
-
-    pub fn reload(&mut self) {
-        self.items.clear();
-        self.plugins.clear();
-        self.load();
-    }
-
-    pub fn load(&mut self) {
-        let all_plugins = find_all_plugins();
-        for plugin_path in &all_plugins {
-            match load_plugin(plugin_path) {
-                Err(_e) => (),
-                Ok(plugin) => {
-                    self.items.insert(plugin.name.clone(), plugin);
-                }
-            }
-        }
-    }
-
-    pub fn install_plugin(
-        &mut self,
-        dispatcher: Dispatcher,
-        plugin: PluginDescription,
-    ) -> Result<()> {
-        let home = home_dir().unwrap();
-        let path = home.join(".lapce").join("plugins").join(&plugin.name);
-        let _ = fs::remove_dir_all(&path);
-
-        fs::create_dir_all(&path)?;
-
-        {
-            let mut file = fs::OpenOptions::new()
-                .create(true)
-                .truncate(true)
-                .write(true)
-                .open(path.join("plugin.toml"))?;
-            file.write_all(&toml::to_vec(&plugin)?)?;
-        }
-
-        let mut plugin = plugin;
-        if let Some(wasm) = plugin.wasm.clone() {
-            {
-                let url = format!(
-                    "https://raw.githubusercontent.com/{}/master/{}",
-                    plugin.repository, wasm
-                );
-                let mut resp = reqwest::blocking::get(url)?;
-                let mut file = fs::OpenOptions::new()
-                    .create(true)
-                    .truncate(true)
-                    .write(true)
-                    .open(path.join(&wasm))?;
-                std::io::copy(&mut resp, &mut file)?;
-            }
-
-            plugin.dir = Some(path.clone());
-            plugin.wasm = Some(
-                path.join(&wasm)
-                    .to_str()
-                    .ok_or_else(|| anyhow!("path can't to string"))?
-                    .to_string(),
-            );
-
-            if let Ok(p) = self.start_plugin(dispatcher, plugin.clone()) {
-                self.plugins.insert(plugin.name.clone(), p);
-            }
-        }
-        if let Some(themes) = plugin.themes.as_ref() {
-            for theme in themes {
-                {
-                    let url = format!(
-                        "https://raw.githubusercontent.com/{}/master/{}",
-                        plugin.repository, theme
-                    );
-                    let mut resp = reqwest::blocking::get(url)?;
-                    let mut file = fs::OpenOptions::new()
-                        .create(true)
-                        .truncate(true)
-                        .write(true)
-                        .open(path.join(theme))?;
-                    std::io::copy(&mut resp, &mut file)?;
-                }
-            }
-        }
-        self.items.insert(plugin.name.clone(), plugin);
-        Ok(())
-    }
-
-    pub fn start_all(&mut self, dispatcher: Dispatcher) {
-        for (_, plugin) in self.items.clone().iter() {
-            if let Ok(p) = self.start_plugin(dispatcher.clone(), plugin.clone()) {
-                self.plugins.insert(plugin.name.clone(), p);
-            }
-        }
-    }
-
-    fn start_plugin(
-        &mut self,
-        dispatcher: Dispatcher,
-        plugin_desc: PluginDescription,
-    ) -> Result<Plugin> {
-        let module = wasmer::Module::from_file(
-            &self.store,
-            plugin_desc
-                .wasm
-                .as_ref()
-                .ok_or_else(|| anyhow!("no wasm in plugin"))?,
-        )?;
-
-        let output = Pipe::new();
-        let input = Pipe::new();
-        let mut wasi_env = WasiState::new("Lapce")
-            .map_dir("/", plugin_desc.dir.clone().unwrap())?
-            .stdin(Box::new(input))
-            .stdout(Box::new(output))
-            .finalize()?;
-        let wasi = wasi_env.import_object(&module)?;
-
-        let plugin_env = PluginEnv {
-            wasi_env,
-            desc: plugin_desc.clone(),
-            dispatcher,
-        };
-        let lapce = lapce_exports(&self.store, &plugin_env);
-        let instance = wasmer::Instance::new(&module, &lapce.chain_back(wasi))?;
-        let plugin = Plugin {
-            instance,
-            env: plugin_env,
-        };
-
-        let local_plugin = plugin.clone();
-        thread::spawn(move || {
-            let initialize = local_plugin
-                .instance
-                .exports
-                .get_function("initialize")
-                .unwrap();
-            wasi_write_object(
-                &local_plugin.env.wasi_env,
-                &PluginInfo {
-                    os: std::env::consts::OS.to_string(),
-                    arch: std::env::consts::ARCH.to_string(),
-                    configuration: plugin_desc.configuration,
-                },
-            );
-            initialize.call(&[]).unwrap();
-        });
-
-        Ok(plugin)
-    }
-
-    pub fn next_plugin_id(&mut self) -> PluginId {
-        PluginId(self.id_counter.next())
-    }
-}
-
-impl Default for PluginCatalog {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-pub(crate) fn lapce_exports(store: &Store, plugin_env: &PluginEnv) -> ImportObject {
-    macro_rules! lapce_export {
-        ($($host_function:ident),+ $(,)?) => {
-            wasmer::imports! {
-                "lapce" => {
-                    $(stringify!($host_function) =>
-                        wasmer::Function::new_native_with_env(store, plugin_env.clone(), $host_function),)+
-                }
-            }
-        }
-    }
-
-    lapce_export! {
-        host_handle_notification,
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(rename_all = "snake_case")]
-#[serde(tag = "method", content = "params")]
-pub enum PluginNotification {
-    StartLspServer {
-        exec_path: String,
-        language_id: String,
-        options: Option<Value>,
-    },
-    DownloadFile {
-        url: String,
-        path: PathBuf,
-    },
-    LockFile {
-        path: PathBuf,
-    },
-    MakeFileExecutable {
-        path: PathBuf,
-    },
-}
-
-fn host_handle_notification(plugin_env: &PluginEnv) {
-    let notification: Result<PluginNotification> =
-        wasi_read_object(&plugin_env.wasi_env);
-    if let Ok(notification) = notification {
-        match notification {
-            PluginNotification::StartLspServer {
-                exec_path,
-                language_id,
-                options,
-            } => {
-                plugin_env.dispatcher.lsp.lock().start_server(
-                    plugin_env
-                        .desc
-                        .dir
-                        .clone()
-                        .unwrap()
-                        .join(&exec_path)
-                        .to_str()
-                        .unwrap(),
-                    &language_id,
-                    options,
-                );
-            }
-            PluginNotification::DownloadFile { url, path } => {
-                let mut resp = reqwest::blocking::get(url).expect("request failed");
-                let mut out = fs::File::create(
-                    plugin_env.desc.dir.clone().unwrap().join(path),
-                )
-                .expect("failed to create file");
-                std::io::copy(&mut resp, &mut out).expect("failed to copy content");
-            }
-            PluginNotification::LockFile { path } => {
-                let path = plugin_env.desc.dir.clone().unwrap().join(path);
-                let mut n = 0;
-                loop {
-                    if let Ok(_file) = fs::OpenOptions::new()
-                        .write(true)
-                        .create_new(true)
-                        .open(&path)
-                    {
-                        return;
-                    }
-                    if n > 10 {
-                        return;
-                    }
-                    n += 1;
-                    let mut hotwatch =
-                        Hotwatch::new().expect("hotwatch failed to initialize!");
-                    let (tx, rx) = crossbeam_channel::bounded(1);
-                    let _ = hotwatch.watch(&path, move |_event| {
-                        #[allow(deprecated)]
-                        let _ = tx.send(0);
-                    });
-                    let _ = rx.recv_timeout(Duration::from_secs(10));
-                }
-            }
-            PluginNotification::MakeFileExecutable { path } => {
-                let _ = Command::new("chmod")
-                    .arg("+x")
-                    .arg(&plugin_env.desc.dir.clone().unwrap().join(path))
-                    .output();
-            }
-        }
-    }
-}
-
-pub fn wasi_read_string(wasi_env: &WasiEnv) -> Result<String> {
-    let mut state = wasi_env.state();
-    let wasi_file = state
-        .fs
-        .stdout_mut()?
-        .as_mut()
-        .ok_or_else(|| anyhow!("can't get stdout"))?;
-    let mut buf = String::new();
-    wasi_file.read_to_string(&mut buf)?;
-    Ok(buf)
-}
-
-pub fn wasi_read_object<T: DeserializeOwned>(wasi_env: &WasiEnv) -> Result<T> {
-    let json = wasi_read_string(wasi_env)?;
-    Ok(serde_json::from_str(&json)?)
-}
-
-pub fn wasi_write_string(wasi_env: &WasiEnv, buf: &str) {
-    let mut state = wasi_env.state();
-    let wasi_file = state.fs.stdin_mut().unwrap().as_mut().unwrap();
-    writeln!(wasi_file, "{}\r", buf).unwrap();
-}
-
-pub fn wasi_write_object(wasi_env: &WasiEnv, object: &(impl Serialize + ?Sized)) {
-    wasi_write_string(wasi_env, &serde_json::to_string(&object).unwrap());
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub enum PluginRequest {}
-
-pub struct PluginHandler {}
-
-fn find_all_plugins() -> Vec<PathBuf> {
-    let mut plugin_paths = Vec::new();
-    let home = home_dir().unwrap();
-    let path = home.join(".lapce").join("plugins");
-    let _ = path.read_dir().map(|dir| {
-        dir.flat_map(|item| item.map(|p| p.path()).ok())
-            .map(|dir| dir.join("plugin.toml"))
-            .filter(|f| f.exists())
-            .for_each(|f| plugin_paths.push(f))
-    });
-    plugin_paths
-}
-
-fn load_plugin(path: &Path) -> Result<PluginDescription> {
-    let mut file = fs::File::open(&path)?;
-    let mut contents = String::new();
-    file.read_to_string(&mut contents)?;
-    let mut plugin: PluginDescription = toml::from_str(&contents)?;
-    plugin.dir = Some(path.parent().unwrap().canonicalize()?);
-    plugin.wasm = plugin.wasm.as_ref().and_then(|wasm| {
-        Some(
-            path.parent()?
-                .join(wasm)
-                .canonicalize()
-                .ok()?
-                .to_str()?
-                .to_string(),
-        )
-    });
-    plugin.themes = plugin.themes.as_ref().map(|themes| {
-        themes
-            .iter()
-            .filter_map(|theme| {
-                Some(
-                    path.parent()?
-                        .join(theme)
-                        .canonicalize()
-                        .ok()?
-                        .to_str()?
-                        .to_string(),
-                )
-            })
-            .collect()
-    });
-    Ok(plugin)
-}
diff --git a/lapce-proxy/src/plugin/catalog.rs b/lapce-proxy/src/plugin/catalog.rs
new file mode 100644
index 0000000000..949b9da370
--- /dev/null
+++ b/lapce-proxy/src/plugin/catalog.rs
@@ -0,0 +1,402 @@
+use std::{
+    collections::HashMap,
+    path::PathBuf,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+    thread,
+};
+
+use lapce_rpc::{
+    plugin::{PluginId, VoltID, VoltMetadata},
+    proxy::ProxyResponse,
+    style::LineStyle,
+    RpcError,
+};
+use lapce_xi_rope::{Rope, RopeDelta};
+use lsp_types::{
+    notification::DidOpenTextDocument, DidOpenTextDocumentParams, SemanticTokens,
+    TextDocumentIdentifier, TextDocumentItem, VersionedTextDocumentIdentifier,
+};
+use parking_lot::Mutex;
+use psp_types::Notification;
+use serde_json::Value;
+
+use super::{
+    psp::{ClonableCallback, PluginServerRpc, PluginServerRpcHandler, RpcCallback},
+    wasi::{load_all_volts, start_volt},
+    PluginCatalogNotification, PluginCatalogRpcHandler,
+};
+use crate::plugin::{install_volt, wasi::enable_volt};
+
+pub struct PluginCatalog {
+    workspace: Option<PathBuf>,
+    plugin_rpc: PluginCatalogRpcHandler,
+    plugins: HashMap<PluginId, PluginServerRpcHandler>,
+    plugin_configurations: HashMap<String, HashMap<String, serde_json::Value>>,
+    unactivated_volts: HashMap<VoltID, VoltMetadata>,
+    open_files: HashMap<PathBuf, String>,
+}
+
+impl PluginCatalog {
+    pub fn new(
+        workspace: Option<PathBuf>,
+        disabled_volts: Vec<VoltID>,
+        plugin_configurations: HashMap<String, HashMap<String, serde_json::Value>>,
+        plugin_rpc: PluginCatalogRpcHandler,
+    ) -> Self {
+        let plugin = Self {
+            workspace,
+            plugin_rpc: plugin_rpc.clone(),
+            plugin_configurations,
+            plugins: HashMap::new(),
+            unactivated_volts: HashMap::new(),
+            open_files: HashMap::new(),
+        };
+
+        thread::spawn(move || {
+            load_all_volts(plugin_rpc, disabled_volts);
+        });
+
+        plugin
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn handle_server_request(
+        &mut self,
+        plugin_id: Option<PluginId>,
+        request_sent: Option<Arc<AtomicUsize>>,
+        method: &'static str,
+        params: Value,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+        f: Box<dyn ClonableCallback>,
+    ) {
+        if let Some(plugin_id) = plugin_id {
+            if let Some(plugin) = self.plugins.get(&plugin_id) {
+                plugin.server_request_async(
+                    method,
+                    params,
+                    language_id,
+                    path,
+                    true,
+                    move |result| {
+                        f(plugin_id, result);
+                    },
+                );
+            } else {
+                f(
+                    plugin_id,
+                    Err(RpcError {
+                        code: 0,
+                        message: "plugin doesn't exist".to_string(),
+                    }),
+                );
+            }
+            return;
+        }
+
+        if let Some(request_sent) = request_sent {
+            // if there are no plugins installed the callback of the client is not called
+            // so check if plugins list is empty
+            if self.plugins.is_empty() {
+                // Add a request
+                request_sent.fetch_add(1, Ordering::Relaxed);
+
+                // make a direct callback with an "error"
+                f(
+                    lapce_rpc::plugin::PluginId(0),
+                    Err(RpcError {
+                        code: 0,
+                        message: "no available plugin could make a callback, because the plugins list is empty".to_string(),
+                    }),
+                );
+                return;
+            } else {
+                request_sent.fetch_add(self.plugins.len(), Ordering::Relaxed);
+            }
+        }
+        for (plugin_id, plugin) in self.plugins.iter() {
+            let f = dyn_clone::clone_box(&*f);
+            let plugin_id = *plugin_id;
+            plugin.server_request_async(
+                method,
+                params.clone(),
+                language_id.clone(),
+                path.clone(),
+                true,
+                move |result| {
+                    f(plugin_id, result);
+                },
+            );
+        }
+    }
+
+    pub fn handle_server_notification(
+        &mut self,
+        method: &'static str,
+        params: Value,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+    ) {
+        for (_, plugin) in self.plugins.iter() {
+            plugin.server_notification(
+                method,
+                params.clone(),
+                language_id.clone(),
+                path.clone(),
+                true,
+            );
+        }
+    }
+
+    fn start_unactivated_volts(&mut self, to_be_activated: Vec<VoltID>) {
+        for id in to_be_activated.iter() {
+            let workspace = self.workspace.clone();
+            if let Some(meta) = self.unactivated_volts.remove(id) {
+                let configurations =
+                    self.plugin_configurations.get(&meta.name).cloned();
+                let plugin_rpc = self.plugin_rpc.clone();
+                thread::spawn(move || {
+                    let _ = start_volt(workspace, configurations, plugin_rpc, meta);
+                });
+            }
+        }
+    }
+
+    fn check_unactivated_volts(&mut self) {
+        let to_be_activated: Vec<VoltID> = self
+            .unactivated_volts
+            .iter()
+            .filter_map(|(id, meta)| {
+                let contains = meta
+                    .activation
+                    .as_ref()
+                    .and_then(|a| a.language.as_ref())
+                    .map(|l| {
+                        self.open_files
+                            .iter()
+                            .any(|(_, language_id)| l.contains(language_id))
+                    })
+                    .unwrap_or(false);
+                if contains {
+                    return Some(id.clone());
+                }
+
+                if let Some(workspace) = self.workspace.as_ref() {
+                    if let Some(globs) = meta
+                        .activation
+                        .as_ref()
+                        .and_then(|a| a.workspace_contains.as_ref())
+                    {
+                        let mut builder = globset::GlobSetBuilder::new();
+                        for glob in globs {
+                            if let Ok(glob) = globset::Glob::new(glob) {
+                                builder.add(glob);
+                            }
+                        }
+                        if let Ok(matcher) = builder.build() {
+                            if !matcher.is_empty() {
+                                for entry in walkdir::WalkDir::new(workspace)
+                                    .into_iter()
+                                    .flatten()
+                                {
+                                    if matcher.is_match(entry.path()) {
+                                        return Some(id.clone());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                None
+            })
+            .collect();
+        self.start_unactivated_volts(to_be_activated);
+    }
+
+    pub fn handle_did_open_text_document(&mut self, document: TextDocumentItem) {
+        let language_id = document.language_id.clone();
+        if let Ok(path) = document.uri.to_file_path() {
+            self.open_files.insert(path, language_id.clone());
+        }
+
+        let to_be_activated: Vec<VoltID> = self
+            .unactivated_volts
+            .iter()
+            .filter_map(|(id, meta)| {
+                let contains = meta
+                    .activation
+                    .as_ref()
+                    .and_then(|a| a.language.as_ref())
+                    .map(|l| l.contains(&language_id))?;
+                if contains {
+                    Some(id.clone())
+                } else {
+                    None
+                }
+            })
+            .collect();
+        self.start_unactivated_volts(to_be_activated);
+
+        let path = document.uri.to_file_path().ok();
+        for (_, plugin) in self.plugins.iter() {
+            plugin.server_notification(
+                DidOpenTextDocument::METHOD,
+                DidOpenTextDocumentParams {
+                    text_document: document.clone(),
+                },
+                Some(language_id.clone()),
+                path.clone(),
+                true,
+            );
+        }
+    }
+
+    pub fn handle_did_save_text_document(
+        &mut self,
+        language_id: String,
+        path: PathBuf,
+        text_document: TextDocumentIdentifier,
+        text: Rope,
+    ) {
+        for (_, plugin) in self.plugins.iter() {
+            plugin.handle_rpc(PluginServerRpc::DidSaveTextDocument {
+                language_id: language_id.clone(),
+                path: path.clone(),
+                text_document: text_document.clone(),
+                text: text.clone(),
+            });
+        }
+    }
+
+    pub fn handle_did_change_text_document(
+        &mut self,
+        language_id: String,
+        document: VersionedTextDocumentIdentifier,
+        delta: RopeDelta,
+        text: Rope,
+        new_text: Rope,
+    ) {
+        let change = Arc::new(Mutex::new((None, None)));
+        for (_, plugin) in self.plugins.iter() {
+            plugin.handle_rpc(PluginServerRpc::DidChangeTextDocument {
+                language_id: language_id.clone(),
+                document: document.clone(),
+                delta: delta.clone(),
+                text: text.clone(),
+                new_text: new_text.clone(),
+                change: change.clone(),
+            });
+        }
+    }
+
+    pub fn format_semantic_tokens(
+        &self,
+        plugin_id: PluginId,
+        tokens: SemanticTokens,
+        text: Rope,
+        f: Box<dyn RpcCallback<Vec<LineStyle>, RpcError>>,
+    ) {
+        if let Some(plugin) = self.plugins.get(&plugin_id) {
+            plugin.handle_rpc(PluginServerRpc::FormatSemanticTokens {
+                tokens,
+                text,
+                f,
+            });
+        } else {
+            f.call(Err(RpcError {
+                code: 0,
+                message: "plugin doesn't exist".to_string(),
+            }));
+        }
+    }
+
+    pub fn handle_notification(&mut self, notification: PluginCatalogNotification) {
+        use PluginCatalogNotification::*;
+        match notification {
+            UnactivatedVolts(volts) => {
+                for volt in volts {
+                    let id = volt.id();
+                    self.unactivated_volts.insert(id, volt);
+                }
+                self.check_unactivated_volts();
+            }
+            UpdatePluginConfigs(configs) => {
+                self.plugin_configurations = configs;
+            }
+            PluginServerLoaded(plugin) => {
+                // TODO: check if the server has did open registered
+                if let Ok(ProxyResponse::GetOpenFilesContentResponse { items }) =
+                    self.plugin_rpc.proxy_rpc.get_open_files_content()
+                {
+                    for item in items {
+                        let language_id = Some(item.language_id.clone());
+                        let path = item.uri.to_file_path().ok();
+                        plugin.server_notification(
+                            DidOpenTextDocument::METHOD,
+                            DidOpenTextDocumentParams {
+                                text_document: item,
+                            },
+                            language_id,
+                            path,
+                            true,
+                        );
+                    }
+                }
+                self.plugins.insert(plugin.plugin_id, plugin);
+            }
+            InstallVolt(volt) => {
+                let workspace = self.workspace.clone();
+                let configurations =
+                    self.plugin_configurations.get(&volt.name).cloned();
+                let catalog_rpc = self.plugin_rpc.clone();
+                let _ = catalog_rpc.stop_volt(volt.clone());
+                thread::spawn(move || {
+                    let _ =
+                        install_volt(catalog_rpc, workspace, configurations, volt);
+                });
+            }
+            ReloadVolt(volt) => {
+                let volt_id = volt.id();
+                let ids: Vec<PluginId> = self.plugins.keys().cloned().collect();
+                for id in ids {
+                    if self.plugins.get(&id).unwrap().volt_id == volt_id {
+                        let plugin = self.plugins.remove(&id).unwrap();
+                        plugin.shutdown();
+                    }
+                }
+                let _ = self.plugin_rpc.unactivated_volts(vec![volt]);
+            }
+            StopVolt(volt) => {
+                let volt_id = volt.id();
+                let ids: Vec<PluginId> = self.plugins.keys().cloned().collect();
+                for id in ids {
+                    if self.plugins.get(&id).unwrap().volt_id == volt_id {
+                        let plugin = self.plugins.remove(&id).unwrap();
+                        plugin.shutdown();
+                    }
+                }
+            }
+            EnableVolt(volt) => {
+                let volt_id = volt.id();
+                for (_, volt) in self.plugins.iter() {
+                    if volt.volt_id == volt_id {
+                        return;
+                    }
+                }
+                let plugin_rpc = self.plugin_rpc.clone();
+                thread::spawn(move || {
+                    let _ = enable_volt(plugin_rpc, volt);
+                });
+            }
+            Shutdown => {
+                for (_, plugin) in self.plugins.iter() {
+                    plugin.shutdown();
+                }
+            }
+        }
+    }
+}
diff --git a/lapce-proxy/src/plugin/lsp.rs b/lapce-proxy/src/plugin/lsp.rs
new file mode 100644
index 0000000000..de3960520c
--- /dev/null
+++ b/lapce-proxy/src/plugin/lsp.rs
@@ -0,0 +1,488 @@
+#[cfg(target_os = "windows")]
+use std::os::windows::process::CommandExt;
+use std::{
+    io::{BufRead, BufReader, BufWriter, Write},
+    path::{Path, PathBuf},
+    process::{self, Child, Command, Stdio},
+    sync::Arc,
+    thread,
+};
+
+use anyhow::{anyhow, Result};
+use crossbeam_channel::Sender;
+use jsonrpc_lite::{Id, Params};
+use lapce_core::meta;
+use lapce_rpc::plugin::VoltID;
+use lapce_rpc::{style::LineStyle, RpcError};
+use lapce_xi_rope::Rope;
+use lsp_types::{
+    notification::{Initialized, Notification},
+    request::{Initialize, Request},
+    *,
+};
+use parking_lot::Mutex;
+use serde_json::Value;
+
+use super::{
+    client_capabilities,
+    psp::{
+        handle_plugin_server_message, PluginHandlerNotification, PluginHostHandler,
+        PluginServerHandler, PluginServerRpcHandler, RpcCallback,
+    },
+};
+use crate::{buffer::Buffer, plugin::PluginCatalogRpcHandler};
+
+const HEADER_CONTENT_LENGTH: &str = "content-length";
+const HEADER_CONTENT_TYPE: &str = "content-type";
+
+pub enum LspRpc {
+    Request {
+        id: u64,
+        method: String,
+        params: Params,
+    },
+    Notification {
+        method: String,
+        params: Params,
+    },
+    Response {
+        id: u64,
+        result: Value,
+    },
+    Error {
+        id: u64,
+        error: RpcError,
+    },
+}
+
+pub struct LspClient {
+    plugin_rpc: PluginCatalogRpcHandler,
+    server_rpc: PluginServerRpcHandler,
+    process: Child,
+    workspace: Option<PathBuf>,
+    host: PluginHostHandler,
+    options: Option<Value>,
+}
+
+impl PluginServerHandler for LspClient {
+    fn method_registered(&mut self, method: &'static str) -> bool {
+        self.host.method_registered(method)
+    }
+
+    fn document_supported(
+        &mut self,
+        lanaguage_id: Option<&str>,
+        path: Option<&Path>,
+    ) -> bool {
+        self.host.document_supported(lanaguage_id, path)
+    }
+
+    fn handle_handler_notification(
+        &mut self,
+        notification: PluginHandlerNotification,
+    ) {
+        use PluginHandlerNotification::*;
+        match notification {
+            Initialize => {
+                self.initialize();
+            }
+            InitializeResult(result) => {
+                self.host.server_capabilities = result.capabilities;
+            }
+            Shutdown => {
+                self.shutdown();
+            }
+        }
+    }
+
+    fn handle_host_request(
+        &mut self,
+        id: Id,
+        method: String,
+        params: Params,
+        chan: Sender<Result<Value, RpcError>>,
+    ) {
+        self.host.handle_request(id, method, params, chan);
+    }
+
+    fn handle_host_notification(&mut self, method: String, params: Params) {
+        let _ = self.host.handle_notification(method, params);
+    }
+
+    fn handle_did_save_text_document(
+        &self,
+        language_id: String,
+        path: PathBuf,
+        text_document: TextDocumentIdentifier,
+        text: lapce_xi_rope::Rope,
+    ) {
+        self.host.handle_did_save_text_document(
+            language_id,
+            path,
+            text_document,
+            text,
+        );
+    }
+
+    fn handle_did_change_text_document(
+        &mut self,
+        language_id: String,
+        document: lsp_types::VersionedTextDocumentIdentifier,
+        delta: lapce_xi_rope::RopeDelta,
+        text: lapce_xi_rope::Rope,
+        new_text: lapce_xi_rope::Rope,
+        change: Arc<
+            Mutex<(
+                Option<TextDocumentContentChangeEvent>,
+                Option<TextDocumentContentChangeEvent>,
+            )>,
+        >,
+    ) {
+        self.host.handle_did_change_text_document(
+            language_id,
+            document,
+            delta,
+            text,
+            new_text,
+            change,
+        );
+    }
+
+    fn format_semantic_tokens(
+        &self,
+        tokens: SemanticTokens,
+        text: Rope,
+        f: Box<dyn RpcCallback<Vec<LineStyle>, RpcError>>,
+    ) {
+        self.host.format_semantic_tokens(tokens, text, f);
+    }
+}
+
+impl LspClient {
+    #[allow(clippy::too_many_arguments)]
+    fn new(
+        plugin_rpc: PluginCatalogRpcHandler,
+        document_selector: DocumentSelector,
+        workspace: Option<PathBuf>,
+        volt_id: VoltID,
+        volt_display_name: String,
+        pwd: Option<PathBuf>,
+        server_uri: Url,
+        args: Vec<String>,
+        options: Option<Value>,
+    ) -> Result<Self> {
+        let server = match server_uri.scheme() {
+            "file" => {
+                let path = server_uri.to_file_path().map_err(|_| anyhow!(""))?;
+                #[cfg(unix)]
+                let _ = std::process::Command::new("chmod")
+                    .arg("+x")
+                    .arg(&path)
+                    .output();
+                path.to_str().ok_or_else(|| anyhow!(""))?.to_string()
+            }
+            "urn" => server_uri.path().to_string(),
+            _ => return Err(anyhow!("uri not supported")),
+        };
+
+        let mut process = Self::process(workspace.as_ref(), &server, &args)?;
+        let stdin = process.stdin.take().unwrap();
+        let stdout = process.stdout.take().unwrap();
+        let stderr = process.stderr.take().unwrap();
+
+        let mut writer = Box::new(BufWriter::new(stdin));
+        let (io_tx, io_rx) = crossbeam_channel::unbounded();
+        let server_rpc = PluginServerRpcHandler::new(volt_id.clone(), io_tx.clone());
+        thread::spawn(move || {
+            for msg in io_rx {
+                if let Ok(msg) = serde_json::to_string(&msg) {
+                    let msg =
+                        format!("Content-Length: {}\r\n\r\n{}", msg.len(), msg);
+                    let _ = writer.write(msg.as_bytes());
+                    let _ = writer.flush();
+                }
+            }
+        });
+
+        let local_server_rpc = server_rpc.clone();
+        let core_rpc = plugin_rpc.core_rpc.clone();
+        thread::spawn(move || {
+            let mut reader = Box::new(BufReader::new(stdout));
+            loop {
+                match read_message(&mut reader) {
+                    Ok(message_str) => {
+                        if let Some(resp) = handle_plugin_server_message(
+                            &local_server_rpc,
+                            &message_str,
+                        ) {
+                            let _ = io_tx.send(resp);
+                        }
+                    }
+                    Err(_err) => {
+                        core_rpc.log(
+                            log::Level::Error,
+                            format!("lsp server {server} stopped!"),
+                        );
+                        return;
+                    }
+                };
+            }
+        });
+
+        let core_rpc = plugin_rpc.core_rpc.clone();
+        thread::spawn(move || {
+            let mut reader = Box::new(BufReader::new(stderr));
+            loop {
+                let mut line = String::new();
+                match reader.read_line(&mut line) {
+                    Ok(n) => {
+                        if n == 0 {
+                            return;
+                        }
+                        core_rpc.log(
+                            log::Level::Error,
+                            format!("lsp server stderr: {}", line.trim_end()),
+                        );
+                    }
+                    Err(_) => {
+                        return;
+                    }
+                }
+            }
+        });
+
+        let host = PluginHostHandler::new(
+            workspace.clone(),
+            pwd,
+            volt_id,
+            volt_display_name,
+            document_selector,
+            server_rpc.clone(),
+            plugin_rpc.clone(),
+        );
+
+        Ok(Self {
+            plugin_rpc,
+            server_rpc,
+            process,
+            workspace,
+            host,
+            options,
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn start(
+        plugin_rpc: PluginCatalogRpcHandler,
+        document_selector: DocumentSelector,
+        workspace: Option<PathBuf>,
+        volt_id: VoltID,
+        volt_display_name: String,
+        pwd: Option<PathBuf>,
+        server_uri: Url,
+        args: Vec<String>,
+        options: Option<Value>,
+    ) -> Result<()> {
+        let mut lsp = Self::new(
+            plugin_rpc,
+            document_selector,
+            workspace,
+            volt_id,
+            volt_display_name,
+            pwd,
+            server_uri,
+            args,
+            options,
+        )?;
+        let rpc = lsp.server_rpc.clone();
+        thread::spawn(move || {
+            rpc.mainloop(&mut lsp);
+        });
+        Ok(())
+    }
+
+    fn initialize(&mut self) {
+        let root_uri = self
+            .workspace
+            .clone()
+            .map(|p| Url::from_directory_path(p).unwrap());
+        #[allow(deprecated)]
+        let params = InitializeParams {
+            process_id: Some(process::id()),
+            root_uri: root_uri.clone(),
+            initialization_options: self.options.clone(),
+            capabilities: client_capabilities(),
+            trace: Some(TraceValue::Verbose),
+            workspace_folders: root_uri.map(|uri| {
+                vec![WorkspaceFolder {
+                    name: uri.as_str().to_string(),
+                    uri,
+                }]
+            }),
+            client_info: Some(ClientInfo {
+                name: meta::NAME.to_owned(),
+                version: Some(meta::VERSION.to_owned()),
+            }),
+            locale: None,
+            root_path: None,
+        };
+        if let Ok(value) = self.server_rpc.server_request(
+            Initialize::METHOD,
+            params,
+            None,
+            None,
+            false,
+        ) {
+            let result: InitializeResult = serde_json::from_value(value).unwrap();
+            self.host.server_capabilities = result.capabilities;
+            self.server_rpc.server_notification(
+                Initialized::METHOD,
+                InitializedParams {},
+                None,
+                None,
+                false,
+            );
+            if self
+                .plugin_rpc
+                .plugin_server_loaded(self.server_rpc.clone())
+                .is_err()
+            {
+                self.server_rpc.shutdown();
+                self.shutdown();
+            }
+        }
+        //     move |result| {
+        //         if let Ok(value) = result {
+        //             let result: InitializeResult =
+        //                 serde_json::from_value(value).unwrap();
+        //             server_rpc.handle_rpc(PluginServerRpc::Handler(
+        //                 PluginHandlerNotification::InitializeDone(result),
+        //             ));
+        //         }
+        //     },
+        // );
+    }
+
+    fn shutdown(&mut self) {
+        let _ = self.process.kill();
+        let _ = self.process.wait();
+    }
+
+    fn process(
+        workspace: Option<&PathBuf>,
+        server: &str,
+        args: &[String],
+    ) -> Result<Child> {
+        let mut process = Command::new(server);
+        if let Some(workspace) = workspace {
+            process.current_dir(workspace);
+        }
+
+        process.args(args);
+
+        #[cfg(target_os = "windows")]
+        let process = process.creation_flags(0x08000000);
+        let child = process
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()?;
+        Ok(child)
+    }
+}
+
+pub struct DocumentFilter {
+    /// The document must have this language id, if it exists
+    pub language_id: Option<String>,
+    /// The document's path must match this glob, if it exists
+    pub pattern: Option<globset::GlobMatcher>,
+    // TODO: URI Scheme from lsp-types document filter
+}
+impl DocumentFilter {
+    /// Constructs a document filter from the LSP version
+    /// This ignores any fields that are badly constructed
+    pub(crate) fn from_lsp_filter_loose(
+        filter: &lsp_types::DocumentFilter,
+    ) -> DocumentFilter {
+        DocumentFilter {
+            language_id: filter.language.clone(),
+            // TODO: clean this up
+            pattern: filter
+                .pattern
+                .as_deref()
+                .map(globset::Glob::new)
+                .and_then(Result::ok)
+                .map(|x| globset::Glob::compile_matcher(&x)),
+        }
+    }
+}
+
+pub enum LspHeader {
+    ContentType,
+    ContentLength(usize),
+}
+
+fn parse_header(s: &str) -> Result<LspHeader> {
+    let split: Vec<String> =
+        s.splitn(2, ": ").map(|s| s.trim().to_lowercase()).collect();
+    if split.len() != 2 {
+        return Err(anyhow!("Malformed"));
+    };
+    match split[0].as_ref() {
+        HEADER_CONTENT_TYPE => Ok(LspHeader::ContentType),
+        HEADER_CONTENT_LENGTH => {
+            Ok(LspHeader::ContentLength(split[1].parse::<usize>()?))
+        }
+        _ => Err(anyhow!("Unknown parse error occurred")),
+    }
+}
+
+pub fn read_message<T: BufRead>(reader: &mut T) -> Result<String> {
+    let mut buffer = String::new();
+    let mut content_length: Option<usize> = None;
+
+    loop {
+        buffer.clear();
+        let _ = reader.read_line(&mut buffer)?;
+        // eprin
+        match &buffer {
+            s if s.trim().is_empty() => break,
+            s => {
+                match parse_header(s)? {
+                    LspHeader::ContentLength(len) => content_length = Some(len),
+                    LspHeader::ContentType => (),
+                };
+            }
+        };
+    }
+
+    let content_length = content_length
+        .ok_or_else(|| anyhow!("missing content-length header: {}", buffer))?;
+
+    let mut body_buffer = vec![0; content_length];
+    reader.read_exact(&mut body_buffer)?;
+
+    let body = String::from_utf8(body_buffer)?;
+    Ok(body)
+}
+
+pub fn get_change_for_sync_kind(
+    sync_kind: TextDocumentSyncKind,
+    buffer: &Buffer,
+    content_change: &TextDocumentContentChangeEvent,
+) -> Option<Vec<TextDocumentContentChangeEvent>> {
+    match sync_kind {
+        TextDocumentSyncKind::NONE => None,
+        TextDocumentSyncKind::FULL => {
+            let text_document_content_change_event =
+                TextDocumentContentChangeEvent {
+                    range: None,
+                    range_length: None,
+                    text: buffer.get_document(),
+                };
+            Some(vec![text_document_content_change_event])
+        }
+        TextDocumentSyncKind::INCREMENTAL => Some(vec![content_change.clone()]),
+        _ => None,
+    }
+}
diff --git a/lapce-proxy/src/plugin/mod.rs b/lapce-proxy/src/plugin/mod.rs
new file mode 100644
index 0000000000..1fa8c7bb17
--- /dev/null
+++ b/lapce-proxy/src/plugin/mod.rs
@@ -0,0 +1,1185 @@
+pub mod catalog;
+pub mod lsp;
+pub mod psp;
+pub mod wasi;
+
+use std::{
+    collections::HashMap,
+    fs,
+    path::{Path, PathBuf},
+    sync::{
+        atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering},
+        Arc,
+    },
+    thread,
+};
+
+use anyhow::{anyhow, Result};
+use crossbeam_channel::{Receiver, Sender};
+use dyn_clone::DynClone;
+use flate2::read::GzDecoder;
+use lapce_core::directory::Directory;
+use lapce_rpc::{
+    core::CoreRpcHandler,
+    plugin::{PluginId, VoltInfo, VoltMetadata},
+    proxy::ProxyRpcHandler,
+    style::LineStyle,
+    RequestId, RpcError,
+};
+use lapce_xi_rope::{Rope, RopeDelta};
+use lsp_types::{
+    request::{
+        CodeActionRequest, CodeActionResolveRequest, Completion,
+        DocumentSymbolRequest, Formatting, GotoDefinition, GotoTypeDefinition,
+        GotoTypeDefinitionParams, GotoTypeDefinitionResponse, HoverRequest,
+        InlayHintRequest, PrepareRenameRequest, References, Rename, Request,
+        ResolveCompletionItem, SelectionRangeRequest, SemanticTokensFullRequest,
+        SignatureHelpRequest, WorkspaceSymbol,
+    },
+    ClientCapabilities, CodeAction, CodeActionCapabilityResolveSupport,
+    CodeActionClientCapabilities, CodeActionContext, CodeActionKind,
+    CodeActionKindLiteralSupport, CodeActionLiteralSupport, CodeActionParams,
+    CodeActionResponse, CompletionClientCapabilities, CompletionItem,
+    CompletionItemCapability, CompletionItemCapabilityResolveSupport,
+    CompletionParams, CompletionResponse, Diagnostic, DocumentFormattingParams,
+    DocumentSymbolParams, DocumentSymbolResponse, FormattingOptions, GotoCapability,
+    GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverClientCapabilities,
+    HoverParams, InlayHint, InlayHintClientCapabilities, InlayHintParams, Location,
+    MarkupKind, MessageActionItemCapabilities, ParameterInformationSettings,
+    PartialResultParams, Position, PrepareRenameResponse, Range, ReferenceContext,
+    ReferenceParams, RenameParams, SelectionRange, SelectionRangeParams,
+    SemanticTokens, SemanticTokensClientCapabilities, SemanticTokensParams,
+    ShowMessageRequestClientCapabilities, SignatureHelp,
+    SignatureHelpClientCapabilities, SignatureHelpParams,
+    SignatureInformationSettings, SymbolInformation, TextDocumentClientCapabilities,
+    TextDocumentIdentifier, TextDocumentItem, TextDocumentPositionParams,
+    TextDocumentSyncClientCapabilities, TextEdit, Url,
+    VersionedTextDocumentIdentifier, WindowClientCapabilities,
+    WorkDoneProgressParams, WorkspaceClientCapabilities, WorkspaceEdit,
+    WorkspaceSymbolClientCapabilities, WorkspaceSymbolParams,
+};
+use parking_lot::Mutex;
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde_json::Value;
+use tar::Archive;
+
+use self::{
+    catalog::PluginCatalog,
+    psp::{ClonableCallback, PluginServerRpcHandler, RpcCallback},
+    wasi::{load_volt, start_volt},
+};
+use crate::buffer::language_id_from_path;
+
+pub type PluginName = String;
+
+#[allow(clippy::large_enum_variant)]
+pub enum PluginCatalogRpc {
+    ServerRequest {
+        plugin_id: Option<PluginId>,
+        request_sent: Option<Arc<AtomicUsize>>,
+        method: &'static str,
+        params: Value,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+        f: Box<dyn ClonableCallback>,
+    },
+    ServerNotification {
+        method: &'static str,
+        params: Value,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+    },
+    FormatSemanticTokens {
+        plugin_id: PluginId,
+        tokens: SemanticTokens,
+        text: Rope,
+        f: Box<dyn RpcCallback<Vec<LineStyle>, RpcError>>,
+    },
+    DidOpenTextDocument {
+        document: TextDocumentItem,
+    },
+    DidChangeTextDocument {
+        language_id: String,
+        document: VersionedTextDocumentIdentifier,
+        delta: RopeDelta,
+        text: Rope,
+        new_text: Rope,
+    },
+    DidSaveTextDocument {
+        language_id: String,
+        path: PathBuf,
+        text_document: TextDocumentIdentifier,
+        text: Rope,
+    },
+    Handler(PluginCatalogNotification),
+    Shutdown,
+}
+
+#[allow(clippy::large_enum_variant)]
+pub enum PluginCatalogNotification {
+    UpdatePluginConfigs(HashMap<String, HashMap<String, serde_json::Value>>),
+    UnactivatedVolts(Vec<VoltMetadata>),
+    PluginServerLoaded(PluginServerRpcHandler),
+    InstallVolt(VoltInfo),
+    StopVolt(VoltInfo),
+    EnableVolt(VoltInfo),
+    ReloadVolt(VoltMetadata),
+    Shutdown,
+}
+
+#[derive(Clone)]
+pub struct PluginCatalogRpcHandler {
+    core_rpc: CoreRpcHandler,
+    proxy_rpc: ProxyRpcHandler,
+    plugin_tx: Sender<PluginCatalogRpc>,
+    plugin_rx: Arc<Mutex<Option<Receiver<PluginCatalogRpc>>>>,
+    #[allow(dead_code)]
+    id: Arc<AtomicU64>,
+    #[allow(dead_code, clippy::type_complexity)]
+    pending: Arc<Mutex<HashMap<u64, Sender<Result<Value, RpcError>>>>>,
+}
+
+impl PluginCatalogRpcHandler {
+    pub fn new(core_rpc: CoreRpcHandler, proxy_rpc: ProxyRpcHandler) -> Self {
+        let (plugin_tx, plugin_rx) = crossbeam_channel::unbounded();
+        Self {
+            core_rpc,
+            proxy_rpc,
+            plugin_tx,
+            plugin_rx: Arc::new(Mutex::new(Some(plugin_rx))),
+            id: Arc::new(AtomicU64::new(0)),
+            pending: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    #[allow(dead_code)]
+    fn handle_response(&self, id: RequestId, result: Result<Value, RpcError>) {
+        if let Some(chan) = { self.pending.lock().remove(&id) } {
+            let _ = chan.send(result);
+        }
+    }
+
+    pub fn mainloop(&self, plugin: &mut PluginCatalog) {
+        let plugin_rx = self.plugin_rx.lock().take().unwrap();
+        for msg in plugin_rx {
+            match msg {
+                PluginCatalogRpc::ServerRequest {
+                    plugin_id,
+                    request_sent,
+                    method,
+                    params,
+                    language_id,
+                    path,
+                    f,
+                } => {
+                    plugin.handle_server_request(
+                        plugin_id,
+                        request_sent,
+                        method,
+                        params,
+                        language_id,
+                        path,
+                        f,
+                    );
+                }
+                PluginCatalogRpc::ServerNotification {
+                    method,
+                    params,
+                    language_id,
+                    path,
+                } => {
+                    plugin.handle_server_notification(
+                        method,
+                        params,
+                        language_id,
+                        path,
+                    );
+                }
+                PluginCatalogRpc::Handler(notification) => {
+                    plugin.handle_notification(notification);
+                }
+                PluginCatalogRpc::FormatSemanticTokens {
+                    plugin_id,
+                    tokens,
+                    text,
+                    f,
+                } => {
+                    plugin.format_semantic_tokens(plugin_id, tokens, text, f);
+                }
+                PluginCatalogRpc::DidOpenTextDocument { document } => {
+                    plugin.handle_did_open_text_document(document);
+                }
+                PluginCatalogRpc::DidSaveTextDocument {
+                    language_id,
+                    path,
+                    text_document,
+                    text,
+                } => {
+                    plugin.handle_did_save_text_document(
+                        language_id,
+                        path,
+                        text_document,
+                        text,
+                    );
+                }
+                PluginCatalogRpc::DidChangeTextDocument {
+                    language_id,
+                    document,
+                    delta,
+                    text,
+                    new_text,
+                } => {
+                    plugin.handle_did_change_text_document(
+                        language_id,
+                        document,
+                        delta,
+                        text,
+                        new_text,
+                    );
+                }
+                PluginCatalogRpc::Shutdown => {
+                    return;
+                }
+            }
+        }
+    }
+
+    pub fn shutdown(&self) {
+        let _ = self.catalog_notification(PluginCatalogNotification::Shutdown);
+        let _ = self.plugin_tx.send(PluginCatalogRpc::Shutdown);
+    }
+
+    fn catalog_notification(
+        &self,
+        notification: PluginCatalogNotification,
+    ) -> Result<()> {
+        self.plugin_tx
+            .send(PluginCatalogRpc::Handler(notification))
+            .map_err(|e| anyhow!(e.to_string()))?;
+        Ok(())
+    }
+
+    fn send_request_to_all_plugins<P, Resp>(
+        &self,
+        method: &'static str,
+        params: P,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+        cb: impl FnOnce(PluginId, Result<Resp, RpcError>) + Clone + Send + 'static,
+    ) where
+        P: Serialize,
+        Resp: DeserializeOwned,
+    {
+        let got_success = Arc::new(AtomicBool::new(false));
+        let request_sent = Arc::new(AtomicUsize::new(0));
+        let err_received = Arc::new(AtomicUsize::new(0));
+        self.send_request(
+            None,
+            Some(request_sent.clone()),
+            method,
+            params,
+            language_id,
+            path,
+            move |plugin_id, result| {
+                if got_success.load(Ordering::Acquire) {
+                    return;
+                }
+                let result = match result {
+                    Ok(value) => {
+                        if let Ok(item) = serde_json::from_value::<Resp>(value) {
+                            got_success.store(true, Ordering::Release);
+                            Ok(item)
+                        } else {
+                            Err(RpcError {
+                                code: 0,
+                                message: "deserialize error".to_string(),
+                            })
+                        }
+                    }
+                    Err(e) => Err(e),
+                };
+                if result.is_ok() {
+                    cb(plugin_id, result)
+                } else {
+                    let rx = err_received.fetch_add(1, Ordering::Relaxed) + 1;
+                    if request_sent.load(Ordering::Acquire) == rx {
+                        cb(plugin_id, result)
+                    }
+                }
+            },
+        );
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn send_request<P: Serialize>(
+        &self,
+        plugin_id: Option<PluginId>,
+        request_sent: Option<Arc<AtomicUsize>>,
+        method: &'static str,
+        params: P,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+        f: impl FnOnce(PluginId, Result<Value, RpcError>) + Send + DynClone + 'static,
+    ) {
+        let params = serde_json::to_value(params).unwrap();
+        let rpc = PluginCatalogRpc::ServerRequest {
+            plugin_id,
+            request_sent,
+            method,
+            params,
+            language_id,
+            path,
+            f: Box::new(f),
+        };
+        let _ = self.plugin_tx.send(rpc);
+    }
+
+    pub fn format_semantic_tokens(
+        &self,
+        plugin_id: PluginId,
+        tokens: SemanticTokens,
+        text: Rope,
+        f: Box<dyn RpcCallback<Vec<LineStyle>, RpcError>>,
+    ) {
+        let _ = self.plugin_tx.send(PluginCatalogRpc::FormatSemanticTokens {
+            plugin_id,
+            tokens,
+            text,
+            f,
+        });
+    }
+
+    pub fn did_save_text_document(&self, path: &Path, text: Rope) {
+        let text_document =
+            TextDocumentIdentifier::new(Url::from_file_path(path).unwrap());
+        let language_id = language_id_from_path(path).unwrap_or("").to_string();
+        let _ = self.plugin_tx.send(PluginCatalogRpc::DidSaveTextDocument {
+            language_id,
+            text_document,
+            path: path.into(),
+            text,
+        });
+    }
+
+    pub fn did_change_text_document(
+        &self,
+        path: &Path,
+        rev: u64,
+        delta: RopeDelta,
+        text: Rope,
+        new_text: Rope,
+    ) {
+        let document = VersionedTextDocumentIdentifier::new(
+            Url::from_file_path(path).unwrap(),
+            rev as i32,
+        );
+        let language_id = language_id_from_path(path).unwrap_or("").to_string();
+        let _ = self
+            .plugin_tx
+            .send(PluginCatalogRpc::DidChangeTextDocument {
+                language_id,
+                document,
+                delta,
+                text,
+                new_text,
+            });
+    }
+
+    pub fn get_definition(
+        &self,
+        path: &Path,
+        position: Position,
+        cb: impl FnOnce(PluginId, Result<GotoDefinitionResponse, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = GotoDefinition::METHOD;
+        let params = GotoDefinitionParams {
+            text_document_position_params: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri },
+                position,
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+        };
+
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn get_type_definition(
+        &self,
+        path: &Path,
+        position: Position,
+        cb: impl FnOnce(PluginId, Result<GotoTypeDefinitionResponse, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = GotoTypeDefinition::METHOD;
+        let params = GotoTypeDefinitionParams {
+            text_document_position_params: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri },
+                position,
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+        };
+
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn get_references(
+        &self,
+        path: &Path,
+        position: Position,
+        cb: impl FnOnce(PluginId, Result<Vec<Location>, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = References::METHOD;
+        let params = ReferenceParams {
+            text_document_position: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri },
+                position,
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+            context: ReferenceContext {
+                include_declaration: false,
+            },
+        };
+
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn get_code_actions(
+        &self,
+        path: &Path,
+        position: Position,
+        diagnostics: Vec<Diagnostic>,
+        cb: impl FnOnce(PluginId, Result<CodeActionResponse, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = CodeActionRequest::METHOD;
+        let params = CodeActionParams {
+            text_document: TextDocumentIdentifier { uri },
+            range: Range {
+                start: position,
+                end: position,
+            },
+            context: CodeActionContext {
+                diagnostics,
+                only: None,
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+        };
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn get_inlay_hints(
+        &self,
+        path: &Path,
+        range: Range,
+        cb: impl FnOnce(PluginId, Result<Vec<InlayHint>, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = InlayHintRequest::METHOD;
+        let params = InlayHintParams {
+            text_document: TextDocumentIdentifier { uri },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            range,
+        };
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn get_document_symbols(
+        &self,
+        path: &Path,
+        cb: impl FnOnce(PluginId, Result<DocumentSymbolResponse, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = DocumentSymbolRequest::METHOD;
+        let params = DocumentSymbolParams {
+            text_document: TextDocumentIdentifier { uri },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+        };
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn get_workspace_symbols(
+        &self,
+        query: String,
+        cb: impl FnOnce(PluginId, Result<Vec<SymbolInformation>, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let method = WorkspaceSymbol::METHOD;
+        let params = WorkspaceSymbolParams {
+            query,
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+        };
+        self.send_request_to_all_plugins(method, params, None, None, cb);
+    }
+
+    pub fn get_document_formatting(
+        &self,
+        path: &Path,
+        cb: impl FnOnce(PluginId, Result<Vec<TextEdit>, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = Formatting::METHOD;
+        let params = DocumentFormattingParams {
+            text_document: TextDocumentIdentifier { uri },
+            options: FormattingOptions {
+                tab_size: 4,
+                insert_spaces: true,
+                ..Default::default()
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+        };
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn prepare_rename(
+        &self,
+        path: &Path,
+        position: Position,
+        cb: impl FnOnce(PluginId, Result<PrepareRenameResponse, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = PrepareRenameRequest::METHOD;
+        let params = TextDocumentPositionParams {
+            text_document: TextDocumentIdentifier { uri },
+            position,
+        };
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn rename(
+        &self,
+        path: &Path,
+        position: Position,
+        new_name: String,
+        cb: impl FnOnce(PluginId, Result<WorkspaceEdit, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = Rename::METHOD;
+        let params = RenameParams {
+            text_document_position: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri },
+                position,
+            },
+            new_name,
+            work_done_progress_params: WorkDoneProgressParams::default(),
+        };
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn get_semantic_tokens(
+        &self,
+        path: &Path,
+        cb: impl FnOnce(PluginId, Result<SemanticTokens, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = SemanticTokensFullRequest::METHOD;
+        let params = SemanticTokensParams {
+            text_document: TextDocumentIdentifier { uri },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+        };
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn get_selection_range(
+        &self,
+        path: &Path,
+        positions: Vec<Position>,
+        cb: impl FnOnce(PluginId, Result<Vec<SelectionRange>, RpcError>)
+            + Clone
+            + Send
+            + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = SelectionRangeRequest::METHOD;
+        let params = SelectionRangeParams {
+            text_document: TextDocumentIdentifier { uri },
+            positions,
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: Default::default(),
+        };
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn hover(
+        &self,
+        path: &Path,
+        position: Position,
+        cb: impl FnOnce(PluginId, Result<Hover, RpcError>) + Clone + Send + 'static,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = HoverRequest::METHOD;
+        let params = HoverParams {
+            text_document_position_params: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri },
+                position,
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+        };
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            cb,
+        );
+    }
+
+    pub fn completion(
+        &self,
+        request_id: usize,
+        path: &Path,
+        input: String,
+        position: Position,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = Completion::METHOD;
+        let params = CompletionParams {
+            text_document_position: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri },
+                position,
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+            context: None,
+        };
+
+        let core_rpc = self.core_rpc.clone();
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+
+        self.send_request_to_all_plugins(
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            move |plugin_id, result| {
+                if let Ok(value) = result {
+                    if let Ok(resp) =
+                        serde_json::from_value::<CompletionResponse>(value)
+                    {
+                        core_rpc
+                            .completion_response(request_id, input, resp, plugin_id);
+                    }
+                }
+            },
+        );
+    }
+
+    pub fn completion_resolve(
+        &self,
+        plugin_id: PluginId,
+        item: CompletionItem,
+        cb: impl FnOnce(Result<CompletionItem, RpcError>) + Send + Clone + 'static,
+    ) {
+        let method = ResolveCompletionItem::METHOD;
+        self.send_request(
+            Some(plugin_id),
+            None,
+            method,
+            item,
+            None,
+            None,
+            move |_, result| {
+                let result = match result {
+                    Ok(value) => {
+                        if let Ok(item) =
+                            serde_json::from_value::<CompletionItem>(value)
+                        {
+                            Ok(item)
+                        } else {
+                            Err(RpcError {
+                                code: 0,
+                                message: "completion item deserialize error"
+                                    .to_string(),
+                            })
+                        }
+                    }
+                    Err(e) => Err(e),
+                };
+                cb(result)
+            },
+        );
+    }
+
+    pub fn signature_help(
+        &self,
+        request_id: usize,
+        path: &Path,
+        position: Position,
+    ) {
+        let uri = Url::from_file_path(path).unwrap();
+        let method = SignatureHelpRequest::METHOD;
+        let params = SignatureHelpParams {
+            // TODO: We could provide more information about the signature for the LSP to work with
+            context: None,
+            text_document_position_params: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri },
+                position,
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+        };
+
+        let core_rpc = self.core_rpc.clone();
+        let language_id =
+            Some(language_id_from_path(path).unwrap_or("").to_string());
+        self.send_request(
+            None,
+            None,
+            method,
+            params,
+            language_id,
+            Some(path.to_path_buf()),
+            move |plugin_id, result| {
+                if let Ok(value) = result {
+                    if let Ok(resp) = serde_json::from_value::<SignatureHelp>(value)
+                    {
+                        core_rpc
+                            .signature_help_response(request_id, resp, plugin_id);
+                    }
+                }
+            },
+        );
+    }
+
+    pub fn action_resolve(
+        &self,
+        item: CodeAction,
+        plugin_id: PluginId,
+        cb: impl FnOnce(Result<CodeAction, RpcError>) + Send + Clone + 'static,
+    ) {
+        let method = CodeActionResolveRequest::METHOD;
+        self.send_request(
+            Some(plugin_id),
+            None,
+            method,
+            item,
+            None,
+            None,
+            move |_, result| {
+                let result = match result {
+                    Ok(value) => {
+                        if let Ok(item) = serde_json::from_value::<CodeAction>(value)
+                        {
+                            Ok(item)
+                        } else {
+                            Err(RpcError {
+                                code: 0,
+                                message: "code_action item deserialize error"
+                                    .to_string(),
+                            })
+                        }
+                    }
+                    Err(e) => Err(e),
+                };
+                cb(result)
+            },
+        );
+    }
+
+    pub fn did_open_document(
+        &self,
+        path: &Path,
+        language_id: String,
+        version: i32,
+        text: String,
+    ) {
+        let _ = self.plugin_tx.send(PluginCatalogRpc::DidOpenTextDocument {
+            document: TextDocumentItem::new(
+                Url::from_file_path(path).unwrap(),
+                language_id,
+                version,
+                text,
+            ),
+        });
+    }
+
+    pub fn unactivated_volts(&self, volts: Vec<VoltMetadata>) -> Result<()> {
+        self.catalog_notification(PluginCatalogNotification::UnactivatedVolts(volts))
+    }
+
+    pub fn plugin_server_loaded(
+        &self,
+        plugin: PluginServerRpcHandler,
+    ) -> Result<()> {
+        self.catalog_notification(PluginCatalogNotification::PluginServerLoaded(
+            plugin,
+        ))
+    }
+
+    pub fn update_plugin_configs(
+        &self,
+        configs: HashMap<String, HashMap<String, serde_json::Value>>,
+    ) -> Result<()> {
+        self.catalog_notification(PluginCatalogNotification::UpdatePluginConfigs(
+            configs,
+        ))
+    }
+
+    pub fn install_volt(&self, volt: VoltInfo) -> Result<()> {
+        self.catalog_notification(PluginCatalogNotification::InstallVolt(volt))
+    }
+
+    pub fn stop_volt(&self, volt: VoltInfo) -> Result<()> {
+        self.catalog_notification(PluginCatalogNotification::StopVolt(volt))
+    }
+
+    pub fn reload_volt(&self, volt: VoltMetadata) -> Result<()> {
+        self.catalog_notification(PluginCatalogNotification::ReloadVolt(volt))
+    }
+
+    pub fn enable_volt(&self, volt: VoltInfo) -> Result<()> {
+        self.catalog_notification(PluginCatalogNotification::EnableVolt(volt))
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "snake_case")]
+#[serde(tag = "method", content = "params")]
+pub enum PluginNotification {
+    StartLspServer {
+        exec_path: String,
+        language_id: String,
+        options: Option<Value>,
+        system_lsp: Option<bool>,
+    },
+    DownloadFile {
+        url: String,
+        path: PathBuf,
+    },
+    LockFile {
+        path: PathBuf,
+    },
+    MakeFileExecutable {
+        path: PathBuf,
+    },
+}
+
+pub fn volt_icon(volt: &VoltMetadata) -> Option<Vec<u8>> {
+    let dir = volt.dir.as_ref()?;
+    let icon = dir.join(volt.icon.as_ref()?);
+    std::fs::read(icon).ok()
+}
+
+pub fn download_volt(volt: &VoltInfo) -> Result<VoltMetadata> {
+    let url = format!(
+        "https://plugins.lapce.dev/api/v1/plugins/{}/{}/{}/download",
+        volt.author, volt.name, volt.version
+    );
+
+    let resp = reqwest::blocking::get(url)?;
+    if !resp.status().is_success() {
+        return Err(anyhow!("can't download plugin"));
+    }
+
+    // this is the s3 url
+    let url = resp.text()?;
+
+    let mut resp = reqwest::blocking::get(url)?;
+    if !resp.status().is_success() {
+        return Err(anyhow!("can't download plugin"));
+    }
+
+    let is_zstd = resp
+        .headers()
+        .get("content-type")
+        .and_then(|v| v.to_str().ok())
+        == Some("application/zstd");
+
+    let id = volt.id();
+    let plugin_dir = Directory::plugins_directory()
+        .ok_or_else(|| anyhow!("can't get plugin directory"))?
+        .join(id.to_string());
+    let _ = fs::remove_dir_all(&plugin_dir);
+    fs::create_dir_all(&plugin_dir)?;
+
+    if is_zstd {
+        let tar = zstd::Decoder::new(&mut resp).unwrap();
+        let mut archive = Archive::new(tar);
+        archive.unpack(&plugin_dir)?;
+    } else {
+        let tar = GzDecoder::new(&mut resp);
+        let mut archive = Archive::new(tar);
+        archive.unpack(&plugin_dir)?;
+    }
+
+    let meta = load_volt(&plugin_dir)?;
+    Ok(meta)
+}
+
+pub fn install_volt(
+    catalog_rpc: PluginCatalogRpcHandler,
+    workspace: Option<PathBuf>,
+    configurations: Option<HashMap<String, serde_json::Value>>,
+    volt: VoltInfo,
+) -> Result<()> {
+    let download_volt_result = download_volt(&volt);
+    if download_volt_result.is_err() {
+        catalog_rpc
+            .core_rpc
+            .volt_installing(volt, "Could not download Plugin".to_string());
+    }
+    let meta = download_volt_result?;
+    let local_catalog_rpc = catalog_rpc.clone();
+    let local_meta = meta.clone();
+
+    let _ = start_volt(workspace, configurations, local_catalog_rpc, local_meta);
+    let icon = volt_icon(&meta);
+    catalog_rpc.core_rpc.volt_installed(meta, icon);
+    Ok(())
+}
+
+pub fn remove_volt(
+    catalog_rpc: PluginCatalogRpcHandler,
+    volt: VoltMetadata,
+) -> Result<()> {
+    thread::spawn(move || -> Result<()> {
+        let path = volt.dir.as_ref().ok_or_else(|| {
+            catalog_rpc
+                .core_rpc
+                .volt_removing(volt.clone(), "Plugin Directory not set".to_string());
+            anyhow::anyhow!("don't have dir")
+        })?;
+        if let Err(e) = std::fs::remove_dir_all(path) {
+            eprintln!("Could not delete plugin folder: {e}");
+            catalog_rpc.core_rpc.volt_removing(
+                volt.clone(),
+                "Could not remove Plugin Directory".to_string(),
+            );
+        } else {
+            catalog_rpc.core_rpc.volt_removed(volt.info(), false);
+        }
+        Ok(())
+    });
+    Ok(())
+}
+
+fn client_capabilities() -> ClientCapabilities {
+    ClientCapabilities {
+        text_document: Some(TextDocumentClientCapabilities {
+            synchronization: Some(TextDocumentSyncClientCapabilities {
+                did_save: Some(true),
+                dynamic_registration: Some(true),
+                ..Default::default()
+            }),
+            completion: Some(CompletionClientCapabilities {
+                completion_item: Some(CompletionItemCapability {
+                    snippet_support: Some(true),
+                    resolve_support: Some(CompletionItemCapabilityResolveSupport {
+                        properties: vec!["additionalTextEdits".to_string()],
+                    }),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            }),
+            signature_help: Some(SignatureHelpClientCapabilities {
+                signature_information: Some(SignatureInformationSettings {
+                    documentation_format: Some(vec![
+                        MarkupKind::Markdown,
+                        MarkupKind::PlainText,
+                    ]),
+                    parameter_information: Some(ParameterInformationSettings {
+                        label_offset_support: Some(true),
+                    }),
+                    active_parameter_support: Some(true),
+                }),
+                ..Default::default()
+            }),
+            hover: Some(HoverClientCapabilities {
+                content_format: Some(vec![
+                    MarkupKind::Markdown,
+                    MarkupKind::PlainText,
+                ]),
+                ..Default::default()
+            }),
+            inlay_hint: Some(InlayHintClientCapabilities {
+                ..Default::default()
+            }),
+            code_action: Some(CodeActionClientCapabilities {
+                data_support: Some(true),
+                resolve_support: Some(CodeActionCapabilityResolveSupport {
+                    properties: vec!["edit".to_string()],
+                }),
+                code_action_literal_support: Some(CodeActionLiteralSupport {
+                    code_action_kind: CodeActionKindLiteralSupport {
+                        value_set: vec![
+                            CodeActionKind::EMPTY.as_str().to_string(),
+                            CodeActionKind::QUICKFIX.as_str().to_string(),
+                            CodeActionKind::REFACTOR.as_str().to_string(),
+                            CodeActionKind::REFACTOR_EXTRACT.as_str().to_string(),
+                            CodeActionKind::REFACTOR_INLINE.as_str().to_string(),
+                            CodeActionKind::REFACTOR_REWRITE.as_str().to_string(),
+                            CodeActionKind::SOURCE.as_str().to_string(),
+                            CodeActionKind::SOURCE_ORGANIZE_IMPORTS
+                                .as_str()
+                                .to_string(),
+                            "quickassist".to_string(),
+                            "source.fixAll".to_string(),
+                        ],
+                    },
+                }),
+                ..Default::default()
+            }),
+            semantic_tokens: Some(SemanticTokensClientCapabilities {
+                ..Default::default()
+            }),
+            type_definition: Some(GotoCapability {
+                // Note: This is explicitly specified rather than left to the Default because
+                // of a bug in lsp-types https://github.com/gluon-lang/lsp-types/pull/244
+                link_support: Some(false),
+                ..Default::default()
+            }),
+            definition: Some(GotoCapability {
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+        window: Some(WindowClientCapabilities {
+            work_done_progress: Some(true),
+            show_message: Some(ShowMessageRequestClientCapabilities {
+                message_action_item: Some(MessageActionItemCapabilities {
+                    additional_properties_support: Some(true),
+                }),
+            }),
+            ..Default::default()
+        }),
+        workspace: Some(WorkspaceClientCapabilities {
+            symbol: Some(WorkspaceSymbolClientCapabilities {
+                ..Default::default()
+            }),
+            configuration: Some(false),
+            ..Default::default()
+        }),
+        ..Default::default()
+    }
+}
diff --git a/lapce-proxy/src/plugin/psp.rs b/lapce-proxy/src/plugin/psp.rs
new file mode 100644
index 0000000000..ae9f5c1653
--- /dev/null
+++ b/lapce-proxy/src/plugin/psp.rs
@@ -0,0 +1,1120 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::{
+        atomic::{AtomicU64, Ordering},
+        Arc,
+    },
+    thread,
+};
+
+use anyhow::{anyhow, Result};
+use crossbeam_channel::{Receiver, Sender};
+use dyn_clone::DynClone;
+use jsonrpc_lite::{Id, JsonRpc, Params};
+use lapce_core::{buffer::rope_text::RopeText, encoding::offset_utf16_to_utf8};
+use lapce_rpc::{
+    plugin::{PluginId, VoltID},
+    style::{LineStyle, Style},
+    RpcError,
+};
+use lapce_xi_rope::{Rope, RopeDelta};
+use lsp_types::{
+    notification::{
+        DidChangeTextDocument, DidOpenTextDocument, DidSaveTextDocument,
+        Initialized, LogMessage, Notification, Progress, PublishDiagnostics,
+        ShowMessage,
+    },
+    request::{
+        CodeActionRequest, CodeActionResolveRequest, Completion,
+        DocumentSymbolRequest, Formatting, GotoDefinition, GotoTypeDefinition,
+        HoverRequest, Initialize, InlayHintRequest, PrepareRenameRequest,
+        References, RegisterCapability, Rename, ResolveCompletionItem,
+        SelectionRangeRequest, SemanticTokensFullRequest, SignatureHelpRequest,
+        WorkDoneProgressCreate, WorkspaceSymbol,
+    },
+    CodeActionProviderCapability, DidChangeTextDocumentParams,
+    DidSaveTextDocumentParams, DocumentSelector, HoverProviderCapability,
+    InitializeResult, LogMessageParams, OneOf, ProgressParams,
+    PublishDiagnosticsParams, Range, Registration, RegistrationParams,
+    SemanticTokens, SemanticTokensLegend, SemanticTokensServerCapabilities,
+    ServerCapabilities, ShowMessageParams, TextDocumentContentChangeEvent,
+    TextDocumentIdentifier, TextDocumentSaveRegistrationOptions,
+    TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncSaveOptions,
+    VersionedTextDocumentIdentifier,
+};
+use parking_lot::Mutex;
+use psp_types::{
+    ExecuteProcess, ExecuteProcessParams, ExecuteProcessResult, Request,
+    StartLspServer, StartLspServerParams,
+};
+use serde::Serialize;
+use serde_json::Value;
+
+use super::{
+    lsp::{DocumentFilter, LspClient},
+    PluginCatalogRpcHandler,
+};
+
+pub enum ResponseHandler<Resp, Error> {
+    Chan(Sender<Result<Resp, Error>>),
+    Callback(Box<dyn RpcCallback<Resp, Error>>),
+}
+
+impl<Resp, Error> ResponseHandler<Resp, Error> {
+    fn invoke(self, result: Result<Resp, Error>) {
+        match self {
+            ResponseHandler::Chan(tx) => {
+                let _ = tx.send(result);
+            }
+            ResponseHandler::Callback(f) => f.call(result),
+        }
+    }
+}
+
+pub trait ClonableCallback:
+    FnOnce(PluginId, Result<Value, RpcError>) + Send + DynClone
+{
+}
+
+impl<F: Send + FnOnce(PluginId, Result<Value, RpcError>) + DynClone> ClonableCallback
+    for F
+{
+}
+
+pub trait RpcCallback<Resp, Error>: Send {
+    fn call(self: Box<Self>, result: Result<Resp, Error>);
+}
+
+impl<Resp, Error, F: Send + FnOnce(Result<Resp, Error>)> RpcCallback<Resp, Error>
+    for F
+{
+    fn call(self: Box<F>, result: Result<Resp, Error>) {
+        (*self)(result)
+    }
+}
+
+pub enum PluginHandlerNotification {
+    Initialize,
+    InitializeResult(InitializeResult),
+    Shutdown,
+}
+
+pub enum PluginServerRpc {
+    Shutdown,
+    Handler(PluginHandlerNotification),
+    ServerRequest {
+        id: Id,
+        method: &'static str,
+        params: Params,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+        rh: ResponseHandler<Value, RpcError>,
+    },
+    ServerNotification {
+        method: &'static str,
+        params: Params,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+    },
+    HostRequest {
+        id: Id,
+        method: String,
+        params: Params,
+        chan: Sender<Result<Value, RpcError>>,
+    },
+    HostNotification {
+        method: String,
+        params: Params,
+    },
+    DidSaveTextDocument {
+        language_id: String,
+        path: PathBuf,
+        text_document: TextDocumentIdentifier,
+        text: Rope,
+    },
+    DidChangeTextDocument {
+        language_id: String,
+        document: VersionedTextDocumentIdentifier,
+        delta: RopeDelta,
+        text: Rope,
+        new_text: Rope,
+        change: Arc<
+            Mutex<(
+                Option<TextDocumentContentChangeEvent>,
+                Option<TextDocumentContentChangeEvent>,
+            )>,
+        >,
+    },
+    FormatSemanticTokens {
+        tokens: SemanticTokens,
+        text: Rope,
+        f: Box<dyn RpcCallback<Vec<LineStyle>, RpcError>>,
+    },
+}
+
+#[derive(Clone)]
+pub struct PluginServerRpcHandler {
+    pub plugin_id: PluginId,
+    pub volt_id: VoltID,
+    rpc_tx: Sender<PluginServerRpc>,
+    rpc_rx: Receiver<PluginServerRpc>,
+    io_tx: Sender<JsonRpc>,
+    id: Arc<AtomicU64>,
+    server_pending: Arc<Mutex<HashMap<Id, ResponseHandler<Value, RpcError>>>>,
+}
+
+pub trait PluginServerHandler {
+    fn document_supported(
+        &mut self,
+        language_id: Option<&str>,
+        path: Option<&Path>,
+    ) -> bool;
+    fn method_registered(&mut self, method: &'static str) -> bool;
+    fn handle_host_notification(&mut self, method: String, params: Params);
+    fn handle_host_request(
+        &mut self,
+        id: Id,
+        method: String,
+        params: Params,
+        chan: Sender<Result<Value, RpcError>>,
+    );
+    fn handle_handler_notification(
+        &mut self,
+        notification: PluginHandlerNotification,
+    );
+    fn handle_did_save_text_document(
+        &self,
+        language_id: String,
+        path: PathBuf,
+        text_document: TextDocumentIdentifier,
+        text: Rope,
+    );
+    fn handle_did_change_text_document(
+        &mut self,
+        language_id: String,
+        document: VersionedTextDocumentIdentifier,
+        delta: RopeDelta,
+        text: Rope,
+        new_text: Rope,
+        change: Arc<
+            Mutex<(
+                Option<TextDocumentContentChangeEvent>,
+                Option<TextDocumentContentChangeEvent>,
+            )>,
+        >,
+    );
+    fn format_semantic_tokens(
+        &self,
+        tokens: SemanticTokens,
+        text: Rope,
+        f: Box<dyn RpcCallback<Vec<LineStyle>, RpcError>>,
+    );
+}
+
+impl PluginServerRpcHandler {
+    pub fn new(volt_id: VoltID, io_tx: Sender<JsonRpc>) -> Self {
+        let (rpc_tx, rpc_rx) = crossbeam_channel::unbounded();
+
+        let rpc = Self {
+            volt_id,
+            plugin_id: PluginId::next(),
+            rpc_tx,
+            rpc_rx,
+            io_tx,
+            id: Arc::new(AtomicU64::new(0)),
+            server_pending: Arc::new(Mutex::new(HashMap::new())),
+        };
+
+        rpc.initialize();
+        rpc
+    }
+
+    fn initialize(&self) {
+        self.handle_rpc(PluginServerRpc::Handler(
+            PluginHandlerNotification::Initialize,
+        ));
+    }
+
+    fn send_server_request(
+        &self,
+        id: Id,
+        method: &str,
+        params: Params,
+        rh: ResponseHandler<Value, RpcError>,
+    ) {
+        {
+            let mut pending = self.server_pending.lock();
+            pending.insert(id.clone(), rh);
+        }
+        let msg = JsonRpc::request_with_params(id, method, params);
+        self.send_server_rpc(msg);
+    }
+
+    fn send_server_notification(&self, method: &str, params: Params) {
+        let msg = JsonRpc::notification_with_params(method, params);
+        self.send_server_rpc(msg);
+    }
+
+    fn send_server_rpc(&self, msg: JsonRpc) {
+        let _ = self.io_tx.send(msg);
+    }
+
+    pub fn handle_rpc(&self, rpc: PluginServerRpc) {
+        let _ = self.rpc_tx.send(rpc);
+    }
+
+    pub fn server_notification<P: Serialize>(
+        &self,
+        method: &'static str,
+        params: P,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+        check: bool,
+    ) {
+        let params = Params::from(serde_json::to_value(params).unwrap());
+
+        if check {
+            let _ = self.rpc_tx.send(PluginServerRpc::ServerNotification {
+                method,
+                params,
+                language_id,
+                path,
+            });
+        } else {
+            self.send_server_notification(method, params);
+        }
+    }
+
+    /// Make a request to plugin/language server and get the response.
+    ///
+    /// When check is true, the request will be in the handler mainloop to
+    /// do checks like if the server has the capability of the request.
+    ///
+    /// When check is false, the request will be sent out straight away.
+    pub fn server_request<P: Serialize>(
+        &self,
+        method: &'static str,
+        params: P,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+        check: bool,
+    ) -> Result<Value, RpcError> {
+        let (tx, rx) = crossbeam_channel::bounded(1);
+        self.server_request_common(
+            method,
+            params,
+            language_id,
+            path,
+            check,
+            ResponseHandler::Chan(tx),
+        );
+        rx.recv().unwrap_or_else(|_| {
+            Err(RpcError {
+                code: 0,
+                message: "io error".to_string(),
+            })
+        })
+    }
+
+    pub fn server_request_async<P: Serialize>(
+        &self,
+        method: &'static str,
+        params: P,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+        check: bool,
+        f: impl RpcCallback<Value, RpcError> + 'static,
+    ) {
+        self.server_request_common(
+            method,
+            params,
+            language_id,
+            path,
+            check,
+            ResponseHandler::Callback(Box::new(f)),
+        );
+    }
+
+    fn server_request_common<P: Serialize>(
+        &self,
+        method: &'static str,
+        params: P,
+        language_id: Option<String>,
+        path: Option<PathBuf>,
+        check: bool,
+        rh: ResponseHandler<Value, RpcError>,
+    ) {
+        let id = self.id.fetch_add(1, Ordering::Relaxed);
+        let params = Params::from(serde_json::to_value(params).unwrap());
+        if check {
+            let _ = self.rpc_tx.send(PluginServerRpc::ServerRequest {
+                id: Id::Num(id as i64),
+                method,
+                params,
+                language_id,
+                path,
+                rh,
+            });
+        } else {
+            self.send_server_request(Id::Num(id as i64), method, params, rh);
+        }
+    }
+
+    pub fn handle_server_response(&self, id: Id, result: Result<Value, RpcError>) {
+        if let Some(handler) = { self.server_pending.lock().remove(&id) } {
+            handler.invoke(result);
+        }
+    }
+
+    pub fn shutdown(&self) {
+        self.handle_rpc(PluginServerRpc::Handler(
+            PluginHandlerNotification::Shutdown,
+        ));
+        self.handle_rpc(PluginServerRpc::Shutdown);
+    }
+
+    pub fn mainloop<H>(&self, handler: &mut H)
+    where
+        H: PluginServerHandler,
+    {
+        for msg in &self.rpc_rx {
+            match msg {
+                PluginServerRpc::ServerRequest {
+                    id,
+                    method,
+                    params,
+                    language_id,
+                    path,
+                    rh,
+                } => {
+                    if handler
+                        .document_supported(language_id.as_deref(), path.as_deref())
+                        && handler.method_registered(method)
+                    {
+                        self.send_server_request(id, method, params, rh);
+                    } else {
+                        rh.invoke(Err(RpcError {
+                            code: 0,
+                            message: "server not capable".to_string(),
+                        }));
+                    }
+                }
+                PluginServerRpc::ServerNotification {
+                    method,
+                    params,
+                    language_id,
+                    path,
+                } => {
+                    if handler
+                        .document_supported(language_id.as_deref(), path.as_deref())
+                        && handler.method_registered(method)
+                    {
+                        self.send_server_notification(method, params);
+                    }
+                }
+                PluginServerRpc::HostRequest {
+                    id,
+                    method,
+                    params,
+                    chan,
+                } => {
+                    handler.handle_host_request(id, method, params, chan);
+                }
+                PluginServerRpc::HostNotification { method, params } => {
+                    handler.handle_host_notification(method, params);
+                }
+                PluginServerRpc::DidSaveTextDocument {
+                    language_id,
+                    path,
+                    text_document,
+                    text,
+                } => {
+                    handler.handle_did_save_text_document(
+                        language_id,
+                        path,
+                        text_document,
+                        text,
+                    );
+                }
+                PluginServerRpc::DidChangeTextDocument {
+                    language_id,
+                    document,
+                    delta,
+                    text,
+                    new_text,
+                    change,
+                } => {
+                    handler.handle_did_change_text_document(
+                        language_id,
+                        document,
+                        delta,
+                        text,
+                        new_text,
+                        change,
+                    );
+                }
+                PluginServerRpc::FormatSemanticTokens { tokens, text, f } => {
+                    handler.format_semantic_tokens(tokens, text, f);
+                }
+                PluginServerRpc::Handler(notification) => {
+                    handler.handle_handler_notification(notification)
+                }
+                PluginServerRpc::Shutdown => {
+                    return;
+                }
+            }
+        }
+    }
+}
+
+pub fn handle_plugin_server_message(
+    server_rpc: &PluginServerRpcHandler,
+    message: &str,
+) -> Option<JsonRpc> {
+    match JsonRpc::parse(message) {
+        Ok(value @ JsonRpc::Request(_)) => {
+            let (tx, rx) = crossbeam_channel::bounded(1);
+            let id = value.get_id().unwrap();
+            let rpc = PluginServerRpc::HostRequest {
+                id: id.clone(),
+                method: value.get_method().unwrap().to_string(),
+                params: value.get_params().unwrap(),
+                chan: tx,
+            };
+            server_rpc.handle_rpc(rpc);
+            let result = rx.recv().unwrap();
+            let resp = match result {
+                Ok(v) => JsonRpc::success(id, &v),
+                Err(e) => JsonRpc::error(
+                    id,
+                    jsonrpc_lite::Error {
+                        code: e.code,
+                        message: e.message,
+                        data: None,
+                    },
+                ),
+            };
+            Some(resp)
+        }
+        Ok(value @ JsonRpc::Notification(_)) => {
+            let rpc = PluginServerRpc::HostNotification {
+                method: value.get_method().unwrap().to_string(),
+                params: value.get_params().unwrap(),
+            };
+            server_rpc.handle_rpc(rpc);
+            None
+        }
+        Ok(value @ JsonRpc::Success(_)) => {
+            let result = value.get_result().unwrap().clone();
+            server_rpc.handle_server_response(value.get_id().unwrap(), Ok(result));
+            None
+        }
+        Ok(value @ JsonRpc::Error(_)) => {
+            let error = value.get_error().unwrap();
+            server_rpc.handle_server_response(
+                value.get_id().unwrap(),
+                Err(RpcError {
+                    code: error.code,
+                    message: error.message.clone(),
+                }),
+            );
+            None
+        }
+        Err(err) => {
+            eprintln!("parse error {err} message {message}");
+            None
+        }
+    }
+}
+
+struct SaveRegistration {
+    include_text: bool,
+    filters: Vec<DocumentFilter>,
+}
+
+#[derive(Default)]
+struct ServerRegistrations {
+    save: Option<SaveRegistration>,
+}
+
+pub struct PluginHostHandler {
+    volt_id: VoltID,
+    volt_display_name: String,
+    pwd: Option<PathBuf>,
+    pub(crate) workspace: Option<PathBuf>,
+    document_selector: Vec<DocumentFilter>,
+    catalog_rpc: PluginCatalogRpcHandler,
+    pub server_rpc: PluginServerRpcHandler,
+    pub server_capabilities: ServerCapabilities,
+    server_registrations: ServerRegistrations,
+}
+
+impl PluginHostHandler {
+    pub fn new(
+        workspace: Option<PathBuf>,
+        pwd: Option<PathBuf>,
+        volt_id: VoltID,
+        volt_display_name: String,
+        document_selector: DocumentSelector,
+        server_rpc: PluginServerRpcHandler,
+        catalog_rpc: PluginCatalogRpcHandler,
+    ) -> Self {
+        let document_selector = document_selector
+            .iter()
+            .map(DocumentFilter::from_lsp_filter_loose)
+            .collect();
+        Self {
+            pwd,
+            workspace,
+            volt_id,
+            volt_display_name,
+            document_selector,
+            catalog_rpc,
+            server_rpc,
+            server_capabilities: ServerCapabilities::default(),
+            server_registrations: ServerRegistrations::default(),
+        }
+    }
+
+    pub fn document_supported(
+        &self,
+        language_id: Option<&str>,
+        path: Option<&Path>,
+    ) -> bool {
+        match language_id {
+            Some(language_id) => {
+                for filter in self.document_selector.iter() {
+                    if (filter.language_id.is_none()
+                        || filter.language_id.as_deref() == Some(language_id))
+                        && (path.is_none()
+                            || filter.pattern.is_none()
+                            || filter
+                                .pattern
+                                .as_ref()
+                                .unwrap()
+                                .is_match(path.as_ref().unwrap()))
+                    {
+                        return true;
+                    }
+                }
+                false
+            }
+            None => true,
+        }
+    }
+
+    pub fn method_registered(&mut self, method: &'static str) -> bool {
+        match method {
+            Initialize::METHOD => true,
+            Initialized::METHOD => true,
+            Completion::METHOD => {
+                self.server_capabilities.completion_provider.is_some()
+            }
+            ResolveCompletionItem::METHOD => self
+                .server_capabilities
+                .completion_provider
+                .as_ref()
+                .and_then(|c| c.resolve_provider)
+                .unwrap_or(false),
+            DidOpenTextDocument::METHOD => {
+                match &self.server_capabilities.text_document_sync {
+                    Some(TextDocumentSyncCapability::Kind(kind)) => {
+                        kind != &TextDocumentSyncKind::NONE
+                    }
+                    Some(TextDocumentSyncCapability::Options(options)) => options
+                        .open_close
+                        .or_else(|| {
+                            options
+                                .change
+                                .map(|kind| kind != TextDocumentSyncKind::NONE)
+                        })
+                        .unwrap_or(false),
+                    None => false,
+                }
+            }
+            DidChangeTextDocument::METHOD => {
+                match &self.server_capabilities.text_document_sync {
+                    Some(TextDocumentSyncCapability::Kind(kind)) => {
+                        kind != &TextDocumentSyncKind::NONE
+                    }
+                    Some(TextDocumentSyncCapability::Options(options)) => options
+                        .change
+                        .map(|kind| kind != TextDocumentSyncKind::NONE)
+                        .unwrap_or(false),
+                    None => false,
+                }
+            }
+            SignatureHelpRequest::METHOD => {
+                self.server_capabilities.signature_help_provider.is_some()
+            }
+            HoverRequest::METHOD => self
+                .server_capabilities
+                .hover_provider
+                .as_ref()
+                .map(|c| match c {
+                    HoverProviderCapability::Simple(is_capable) => *is_capable,
+                    HoverProviderCapability::Options(_) => true,
+                })
+                .unwrap_or(false),
+            GotoDefinition::METHOD => self
+                .server_capabilities
+                .definition_provider
+                .as_ref()
+                .map(|d| match d {
+                    OneOf::Left(is_capable) => *is_capable,
+                    OneOf::Right(_) => true,
+                })
+                .unwrap_or(false),
+            GotoTypeDefinition::METHOD => {
+                self.server_capabilities.type_definition_provider.is_some()
+            }
+            References::METHOD => self
+                .server_capabilities
+                .references_provider
+                .as_ref()
+                .map(|r| match r {
+                    OneOf::Left(is_capable) => *is_capable,
+                    OneOf::Right(_) => true,
+                })
+                .unwrap_or(false),
+            CodeActionRequest::METHOD => self
+                .server_capabilities
+                .code_action_provider
+                .as_ref()
+                .map(|a| match a {
+                    CodeActionProviderCapability::Simple(is_capable) => *is_capable,
+                    CodeActionProviderCapability::Options(_) => true,
+                })
+                .unwrap_or(false),
+            Formatting::METHOD => self
+                .server_capabilities
+                .document_formatting_provider
+                .as_ref()
+                .map(|f| match f {
+                    OneOf::Left(is_capable) => *is_capable,
+                    OneOf::Right(_) => true,
+                })
+                .unwrap_or(false),
+            SemanticTokensFullRequest::METHOD => {
+                self.server_capabilities.semantic_tokens_provider.is_some()
+            }
+            InlayHintRequest::METHOD => {
+                self.server_capabilities.inlay_hint_provider.is_some()
+            }
+            DocumentSymbolRequest::METHOD => {
+                self.server_capabilities.document_symbol_provider.is_some()
+            }
+            WorkspaceSymbol::METHOD => {
+                self.server_capabilities.workspace_symbol_provider.is_some()
+            }
+            PrepareRenameRequest::METHOD => {
+                self.server_capabilities.rename_provider.is_some()
+            }
+            Rename::METHOD => self.server_capabilities.rename_provider.is_some(),
+            SelectionRangeRequest::METHOD => {
+                self.server_capabilities.selection_range_provider.is_some()
+            }
+            CodeActionResolveRequest::METHOD => {
+                self.server_capabilities.code_action_provider.is_some()
+            }
+            _ => false,
+        }
+    }
+
+    fn check_save_capability(&self, language_id: &str, path: &Path) -> (bool, bool) {
+        if self.document_supported(Some(language_id), Some(path)) {
+            let (should_send, include_text) = self
+                .server_capabilities
+                .text_document_sync
+                .as_ref()
+                .and_then(|sync| match sync {
+                    TextDocumentSyncCapability::Kind(_) => None,
+                    TextDocumentSyncCapability::Options(options) => Some(options),
+                })
+                .and_then(|o| o.save.as_ref())
+                .map(|o| match o {
+                    TextDocumentSyncSaveOptions::Supported(is_supported) => {
+                        (*is_supported, true)
+                    }
+                    TextDocumentSyncSaveOptions::SaveOptions(options) => {
+                        (true, options.include_text.unwrap_or(false))
+                    }
+                })
+                .unwrap_or((false, false));
+            return (should_send, include_text);
+        }
+
+        if let Some(options) = self.server_registrations.save.as_ref() {
+            for filter in options.filters.iter() {
+                if (filter.language_id.is_none()
+                    || filter.language_id.as_deref() == Some(language_id))
+                    && (filter.pattern.is_none()
+                        || filter.pattern.as_ref().unwrap().is_match(path))
+                {
+                    return (true, options.include_text);
+                }
+            }
+        }
+
+        (false, false)
+    }
+
+    fn register_capabilities(&mut self, registrations: Vec<Registration>) {
+        for registration in registrations {
+            let _ = self.register_capability(registration);
+        }
+    }
+
+    fn register_capability(&mut self, registration: Registration) -> Result<()> {
+        match registration.method.as_str() {
+            DidSaveTextDocument::METHOD => {
+                let options = registration
+                    .register_options
+                    .ok_or_else(|| anyhow!("don't have options"))?;
+                let options: TextDocumentSaveRegistrationOptions =
+                    serde_json::from_value(options)?;
+                self.server_registrations.save = Some(SaveRegistration {
+                    include_text: options.include_text.unwrap_or(false),
+                    filters: options
+                        .text_document_registration_options
+                        .document_selector
+                        .map(|s| {
+                            s.iter()
+                                .map(DocumentFilter::from_lsp_filter_loose)
+                                .collect()
+                        })
+                        .unwrap_or_default(),
+                });
+            }
+            _ => {
+                eprintln!(
+                    "don't handle register capability for {}",
+                    registration.method
+                );
+            }
+        }
+        Ok(())
+    }
+
+    pub fn handle_request(
+        &mut self,
+        _id: Id,
+        method: String,
+        params: Params,
+        chan: Sender<Result<Value, RpcError>>,
+    ) {
+        let result = self.process_request(method, params);
+        let _ = chan.send(result.map_err(|e| RpcError {
+            code: 0,
+            message: e.to_string(),
+        }));
+    }
+
+    pub fn process_request(
+        &mut self,
+        method: String,
+        params: Params,
+    ) -> Result<Value> {
+        match method.as_str() {
+            WorkDoneProgressCreate::METHOD => Ok(Value::Null),
+            RegisterCapability::METHOD => {
+                let params: RegistrationParams =
+                    serde_json::from_value(serde_json::to_value(params)?)?;
+                self.register_capabilities(params.registrations);
+                Ok(Value::Null)
+            }
+            ExecuteProcess::METHOD => {
+                let params: ExecuteProcessParams =
+                    serde_json::from_value(serde_json::to_value(params)?)?;
+                let output = std::process::Command::new(params.program)
+                    .args(params.args)
+                    .output()?;
+                Ok(serde_json::to_value(ExecuteProcessResult {
+                    success: output.status.success(),
+                    stdout: Some(output.stdout),
+                    stderr: Some(output.stderr),
+                })?)
+            }
+            _ => Err(anyhow!("request not supported")),
+        }
+    }
+
+    pub fn handle_notification(
+        &mut self,
+        method: String,
+        params: Params,
+    ) -> Result<()> {
+        match method.as_str() {
+            StartLspServer::METHOD => {
+                let params: StartLspServerParams =
+                    serde_json::from_value(serde_json::to_value(params)?)?;
+                let workspace = self.workspace.clone();
+                let pwd = self.pwd.clone();
+                let catalog_rpc = self.catalog_rpc.clone();
+                let volt_id = self.volt_id.clone();
+                let volt_display_name = self.volt_display_name.clone();
+                thread::spawn(move || {
+                    let _ = LspClient::start(
+                        catalog_rpc,
+                        params.document_selector,
+                        workspace,
+                        volt_id,
+                        volt_display_name,
+                        pwd,
+                        params.server_uri,
+                        params.server_args,
+                        params.options,
+                    );
+                });
+            }
+            PublishDiagnostics::METHOD => {
+                let diagnostics: PublishDiagnosticsParams =
+                    serde_json::from_value(serde_json::to_value(params)?)?;
+                self.catalog_rpc.core_rpc.publish_diagnostics(diagnostics);
+            }
+            Progress::METHOD => {
+                let progress: ProgressParams =
+                    serde_json::from_value(serde_json::to_value(params)?)?;
+                self.catalog_rpc.core_rpc.work_done_progress(progress);
+            }
+            ShowMessage::METHOD => {
+                let message: ShowMessageParams =
+                    serde_json::from_value(serde_json::to_value(params)?)?;
+                let title = format!("Plugin: {}", self.volt_display_name);
+                self.catalog_rpc.core_rpc.show_message(title, message);
+            }
+            LogMessage::METHOD => {
+                let message: LogMessageParams =
+                    serde_json::from_value(serde_json::to_value(params)?)?;
+                self.catalog_rpc.core_rpc.log_message(message);
+            }
+            _ => {
+                eprintln!("host notificaton {method} not handled");
+            }
+        }
+        Ok(())
+    }
+
+    pub fn handle_did_save_text_document(
+        &self,
+        language_id: String,
+        path: PathBuf,
+        text_document: TextDocumentIdentifier,
+        text: Rope,
+    ) {
+        let (should_send, include_text) =
+            self.check_save_capability(language_id.as_str(), &path);
+        if !should_send {
+            return;
+        }
+        let params = DidSaveTextDocumentParams {
+            text_document,
+            text: if include_text {
+                Some(text.to_string())
+            } else {
+                None
+            },
+        };
+        self.server_rpc.server_notification(
+            DidSaveTextDocument::METHOD,
+            params,
+            Some(language_id),
+            Some(path),
+            false,
+        );
+    }
+
+    pub fn handle_did_change_text_document(
+        &mut self,
+        lanaguage_id: String,
+        document: VersionedTextDocumentIdentifier,
+        delta: RopeDelta,
+        text: Rope,
+        new_text: Rope,
+        change: Arc<
+            Mutex<(
+                Option<TextDocumentContentChangeEvent>,
+                Option<TextDocumentContentChangeEvent>,
+            )>,
+        >,
+    ) {
+        let kind = match &self.server_capabilities.text_document_sync {
+            Some(TextDocumentSyncCapability::Kind(kind)) => *kind,
+            Some(TextDocumentSyncCapability::Options(options)) => {
+                options.change.unwrap_or(TextDocumentSyncKind::NONE)
+            }
+            None => TextDocumentSyncKind::NONE,
+        };
+
+        let mut existing = change.lock();
+        let change = match kind {
+            TextDocumentSyncKind::FULL => {
+                if let Some(c) = existing.0.as_ref() {
+                    c.clone()
+                } else {
+                    let change = TextDocumentContentChangeEvent {
+                        range: None,
+                        range_length: None,
+                        text: new_text.to_string(),
+                    };
+                    existing.0 = Some(change.clone());
+                    change
+                }
+            }
+            TextDocumentSyncKind::INCREMENTAL => {
+                if let Some(c) = existing.1.as_ref() {
+                    c.clone()
+                } else {
+                    let change = get_document_content_change(&text, &delta)
+                        .unwrap_or_else(|| TextDocumentContentChangeEvent {
+                            range: None,
+                            range_length: None,
+                            text: new_text.to_string(),
+                        });
+                    existing.1 = Some(change.clone());
+                    change
+                }
+            }
+            TextDocumentSyncKind::NONE => return,
+            _ => return,
+        };
+
+        let path = document.uri.to_file_path().ok();
+
+        let params = DidChangeTextDocumentParams {
+            text_document: document,
+            content_changes: vec![change],
+        };
+
+        self.server_rpc.server_notification(
+            DidChangeTextDocument::METHOD,
+            params,
+            Some(lanaguage_id),
+            path,
+            false,
+        );
+    }
+
+    pub fn format_semantic_tokens(
+        &self,
+        tokens: SemanticTokens,
+        text: Rope,
+        f: Box<dyn RpcCallback<Vec<LineStyle>, RpcError>>,
+    ) {
+        let result = format_semantic_styles(
+            &text,
+            self.server_capabilities.semantic_tokens_provider.as_ref(),
+            &tokens,
+        )
+        .ok_or_else(|| RpcError {
+            code: 0,
+            message: "can't get styles".to_string(),
+        });
+        f.call(result);
+    }
+}
+
+fn get_document_content_change(
+    text: &Rope,
+    delta: &RopeDelta,
+) -> Option<TextDocumentContentChangeEvent> {
+    let (interval, _) = delta.summary();
+    let (start, end) = interval.start_end();
+
+    let text = RopeText::new(text);
+
+    // TODO: Handle more trivial cases like typing when there's a selection or transpose
+    if let Some(node) = delta.as_simple_insert() {
+        let (start, end) = interval.start_end();
+        let start = text.offset_to_position(start);
+
+        let end = text.offset_to_position(end);
+
+        let text = String::from(node);
+        let text_document_content_change_event = TextDocumentContentChangeEvent {
+            range: Some(Range { start, end }),
+            range_length: None,
+            text,
+        };
+
+        return Some(text_document_content_change_event);
+    }
+    // Or a simple delete
+    else if delta.is_simple_delete() {
+        let end_position = text.offset_to_position(end);
+
+        let start = text.offset_to_position(start);
+
+        let text_document_content_change_event = TextDocumentContentChangeEvent {
+            range: Some(Range {
+                start,
+                end: end_position,
+            }),
+            range_length: None,
+            text: String::new(),
+        };
+
+        return Some(text_document_content_change_event);
+    }
+
+    None
+}
+
+fn format_semantic_styles(
+    text: &Rope,
+    semantic_tokens_provider: Option<&SemanticTokensServerCapabilities>,
+    tokens: &SemanticTokens,
+) -> Option<Vec<LineStyle>> {
+    let semantic_tokens_provider = semantic_tokens_provider?;
+    let semantic_legends = semantic_tokens_legend(semantic_tokens_provider);
+
+    let text = RopeText::new(text);
+    let mut highlights = Vec::new();
+    let mut line = 0;
+    let mut start = 0;
+    let mut last_start = 0;
+    for semantic_token in &tokens.data {
+        if semantic_token.delta_line > 0 {
+            line += semantic_token.delta_line as usize;
+            start = text.offset_of_line(line);
+        }
+
+        let sub_text = text.char_indices_iter(start..);
+        start += offset_utf16_to_utf8(sub_text, semantic_token.delta_start as usize);
+
+        let sub_text = text.char_indices_iter(start..);
+        let end =
+            start + offset_utf16_to_utf8(sub_text, semantic_token.length as usize);
+
+        let kind = semantic_legends.token_types[semantic_token.token_type as usize]
+            .as_str()
+            .to_string();
+        if start < last_start {
+            continue;
+        }
+        last_start = start;
+        highlights.push(LineStyle {
+            start,
+            end,
+            style: Style {
+                fg_color: Some(kind),
+            },
+        });
+    }
+
+    Some(highlights)
+}
+
+fn semantic_tokens_legend(
+    semantic_tokens_provider: &SemanticTokensServerCapabilities,
+) -> &SemanticTokensLegend {
+    match semantic_tokens_provider {
+        SemanticTokensServerCapabilities::SemanticTokensOptions(options) => {
+            &options.legend
+        }
+        SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(
+            options,
+        ) => &options.semantic_tokens_options.legend,
+    }
+}
diff --git a/lapce-proxy/src/plugin/wasi.rs b/lapce-proxy/src/plugin/wasi.rs
new file mode 100644
index 0000000000..03cfdd56af
--- /dev/null
+++ b/lapce-proxy/src/plugin/wasi.rs
@@ -0,0 +1,546 @@
+#[cfg(test)]
+mod tests;
+
+use std::{
+    collections::{HashMap, VecDeque},
+    fs,
+    io::{Read, Seek, Write},
+    path::{Path, PathBuf},
+    process,
+    sync::{Arc, RwLock},
+    thread,
+};
+
+use anyhow::{anyhow, Result};
+use crossbeam_channel::Sender;
+use jsonrpc_lite::{Id, Params};
+use lapce_core::directory::Directory;
+use lapce_rpc::{
+    plugin::{PluginId, VoltID, VoltInfo, VoltMetadata},
+    style::LineStyle,
+    RpcError,
+};
+use lapce_xi_rope::{Rope, RopeDelta};
+use lsp_types::{
+    notification::Initialized, request::Initialize, DocumentFilter,
+    InitializeParams, InitializedParams, TextDocumentContentChangeEvent,
+    TextDocumentIdentifier, Url, VersionedTextDocumentIdentifier,
+};
+use parking_lot::Mutex;
+use psp_types::{Notification, Request};
+use toml_edit::easy as toml;
+use wasi_experimental_http_wasmtime::{HttpCtx, HttpState};
+use wasmtime_wasi::WasiCtxBuilder;
+
+use super::{
+    client_capabilities,
+    psp::{
+        handle_plugin_server_message, PluginHandlerNotification, PluginHostHandler,
+        PluginServerHandler, PluginServerRpc, RpcCallback,
+    },
+    volt_icon, PluginCatalogRpcHandler,
+};
+use crate::plugin::psp::PluginServerRpcHandler;
+
+#[derive(Default)]
+pub struct WasiPipe {
+    buffer: VecDeque<u8>,
+}
+
+impl WasiPipe {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+impl Read for WasiPipe {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        let amt = std::cmp::min(buf.len(), self.buffer.len());
+        for (i, byte) in self.buffer.drain(..amt).enumerate() {
+            buf[i] = byte;
+        }
+        Ok(amt)
+    }
+}
+
+impl Write for WasiPipe {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.buffer.extend(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Seek for WasiPipe {
+    fn seek(&mut self, _pos: std::io::SeekFrom) -> std::io::Result<u64> {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            "can not seek in a pipe",
+        ))
+    }
+}
+
+pub struct Plugin {
+    #[allow(dead_code)]
+    id: PluginId,
+    host: PluginHostHandler,
+    configurations: Option<HashMap<String, serde_json::Value>>,
+}
+
+impl PluginServerHandler for Plugin {
+    fn method_registered(&mut self, method: &'static str) -> bool {
+        self.host.method_registered(method)
+    }
+
+    fn document_supported(
+        &mut self,
+        language_id: Option<&str>,
+        path: Option<&Path>,
+    ) -> bool {
+        self.host.document_supported(language_id, path)
+    }
+
+    fn handle_handler_notification(
+        &mut self,
+        notification: PluginHandlerNotification,
+    ) {
+        use PluginHandlerNotification::*;
+        match notification {
+            Initialize => {
+                self.initialize();
+            }
+            InitializeResult(result) => {
+                self.host.server_capabilities = result.capabilities;
+            }
+            Shutdown => {
+                self.shutdown();
+            }
+        }
+    }
+
+    fn handle_host_notification(&mut self, method: String, params: Params) {
+        let _ = self.host.handle_notification(method, params);
+    }
+
+    fn handle_host_request(
+        &mut self,
+        id: Id,
+        method: String,
+        params: Params,
+        chan: Sender<Result<serde_json::Value, RpcError>>,
+    ) {
+        self.host.handle_request(id, method, params, chan);
+    }
+
+    fn handle_did_save_text_document(
+        &self,
+        language_id: String,
+        path: PathBuf,
+        text_document: TextDocumentIdentifier,
+        text: Rope,
+    ) {
+        self.host.handle_did_save_text_document(
+            language_id,
+            path,
+            text_document,
+            text,
+        );
+    }
+
+    fn handle_did_change_text_document(
+        &mut self,
+        language_id: String,
+        document: VersionedTextDocumentIdentifier,
+        delta: RopeDelta,
+        text: Rope,
+        new_text: Rope,
+        change: Arc<
+            Mutex<(
+                Option<TextDocumentContentChangeEvent>,
+                Option<TextDocumentContentChangeEvent>,
+            )>,
+        >,
+    ) {
+        self.host.handle_did_change_text_document(
+            language_id,
+            document,
+            delta,
+            text,
+            new_text,
+            change,
+        );
+    }
+
+    fn format_semantic_tokens(
+        &self,
+        tokens: lsp_types::SemanticTokens,
+        text: Rope,
+        f: Box<dyn RpcCallback<Vec<LineStyle>, RpcError>>,
+    ) {
+        self.host.format_semantic_tokens(tokens, text, f);
+    }
+}
+
+impl Plugin {
+    fn initialize(&mut self) {
+        let workspace = self.host.workspace.clone();
+        let configurations = self.configurations.as_ref().map(unflatten_map);
+        let root_uri = workspace.map(|p| Url::from_directory_path(p).unwrap());
+        let server_rpc = self.host.server_rpc.clone();
+        self.host.server_rpc.server_request_async(
+            Initialize::METHOD,
+            #[allow(deprecated)]
+            InitializeParams {
+                process_id: Some(process::id()),
+                root_path: None,
+                root_uri,
+                capabilities: client_capabilities(),
+                trace: None,
+                client_info: None,
+                locale: None,
+                initialization_options: configurations,
+                workspace_folders: None,
+            },
+            None,
+            None,
+            false,
+            move |value| {
+                if let Ok(value) = value {
+                    if let Ok(result) = serde_json::from_value(value) {
+                        server_rpc.handle_rpc(PluginServerRpc::Handler(
+                            PluginHandlerNotification::InitializeResult(result),
+                        ));
+                        server_rpc.server_notification(
+                            Initialized::METHOD,
+                            InitializedParams {},
+                            None,
+                            None,
+                            false,
+                        );
+                    }
+                }
+            },
+        );
+    }
+
+    fn shutdown(&self) {}
+}
+
+pub fn load_all_volts(
+    plugin_rpc: PluginCatalogRpcHandler,
+    disabled_volts: Vec<VoltID>,
+) {
+    let all_volts = find_all_volts();
+    let volts = all_volts
+        .into_iter()
+        .filter_map(|meta| {
+            meta.wasm.as_ref()?;
+            let icon = volt_icon(&meta);
+            plugin_rpc.core_rpc.volt_installed(meta.clone(), icon);
+            if disabled_volts.contains(&meta.id()) {
+                return None;
+            }
+            Some(meta)
+        })
+        .collect();
+    let _ = plugin_rpc.unactivated_volts(volts);
+}
+
+pub fn find_all_volts() -> Vec<VoltMetadata> {
+    Directory::plugins_directory()
+        .and_then(|d| {
+            d.read_dir().ok().map(|dir| {
+                dir.filter_map(|result| {
+                    let entry = result.ok()?;
+                    let metadata = entry.metadata().ok()?;
+
+                    if metadata.is_file()
+                        || entry.file_name().to_str()?.starts_with('.')
+                    {
+                        return None;
+                    }
+                    load_volt(&entry.path()).ok()
+                })
+                .collect()
+            })
+        })
+        .unwrap_or_default()
+}
+
+/// Returns an instance of "VoltMetadata" or an error if there is no file in the path,
+/// the contents of the file cannot be read into a string, or the content read cannot
+/// be converted to an instance of "VoltMetadata".
+///
+/// # Examples
+///
+/// ```
+/// use std::fs::File;
+/// use std::io::Write;
+/// use lapce_proxy::plugin::wasi::load_volt;
+/// use lapce_rpc::plugin::VoltMetadata;
+///
+/// let parent_path = std::env::current_dir().unwrap();
+/// let mut file = File::create(parent_path.join("volt.toml")).unwrap();
+/// let _ = writeln!(file, "name = \"plugin\" \n version = \"0.1\"");
+/// let _ = writeln!(file, "display-name = \"Plugin\" \n author = \"Author\"");
+/// let _ = writeln!(file, "description = \"Useful plugin\"");///
+/// let volt_metadata = match load_volt(&parent_path) {
+///     Ok(volt_metadata) => volt_metadata,
+///     Err(error) => panic!("{}", error),
+/// };
+/// assert_eq!(
+///     volt_metadata,
+///     VoltMetadata {
+///         name: "plugin".to_string(),
+///         version: "0.1".to_string(),
+///         display_name: "Plugin".to_string(),
+///         author: "Author".to_string(),
+///         description: "Useful plugin".to_string(),
+///         icon: None,
+///         repository: None,
+///         wasm: None,
+///         color_themes: None,
+///         icon_themes: None,
+///         dir: parent_path.canonicalize().ok(),
+///         activation: None,
+///         config: None
+///     }
+/// );
+/// let _ = std::fs::remove_file(parent_path.join("volt.toml"));
+/// ```
+pub fn load_volt(path: &Path) -> Result<VoltMetadata> {
+    let path = path.canonicalize()?;
+    let mut file = fs::File::open(path.join("volt.toml"))?;
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?;
+    let mut meta: VoltMetadata = toml::from_str(&contents)?;
+
+    meta.dir = Some(path.clone());
+    meta.wasm = meta.wasm.as_ref().and_then(|wasm| {
+        Some(path.join(wasm).canonicalize().ok()?.to_str()?.to_string())
+    });
+    // FIXME: This does `meta.color_themes = Some([])` in case, for example,
+    // it cannot find matching files, but in that case it should do `meta.color_themes = None`
+    meta.color_themes = meta.color_themes.as_ref().map(|themes| {
+        themes
+            .iter()
+            .filter_map(|theme| {
+                Some(path.join(theme).canonicalize().ok()?.to_str()?.to_string())
+            })
+            .collect()
+    });
+    // FIXME: This does `meta.icon_themes = Some([])` in case, for example,
+    // it cannot find matching files, but in that case it should do `meta.icon_themes = None`
+    meta.icon_themes = meta.icon_themes.as_ref().map(|themes| {
+        themes
+            .iter()
+            .filter_map(|theme| {
+                Some(path.join(theme).canonicalize().ok()?.to_str()?.to_string())
+            })
+            .collect()
+    });
+
+    Ok(meta)
+}
+
+pub fn enable_volt(
+    plugin_rpc: PluginCatalogRpcHandler,
+    volt: VoltInfo,
+) -> Result<()> {
+    let path = Directory::plugins_directory()
+        .ok_or_else(|| anyhow!("can't get plugin directory"))?
+        .join(volt.id().to_string());
+    let meta = load_volt(&path)?;
+    plugin_rpc.unactivated_volts(vec![meta])?;
+    Ok(())
+}
+
+pub fn start_volt(
+    workspace: Option<PathBuf>,
+    configurations: Option<HashMap<String, serde_json::Value>>,
+    plugin_rpc: PluginCatalogRpcHandler,
+    meta: VoltMetadata,
+) -> Result<()> {
+    let engine = wasmtime::Engine::default();
+    let module = wasmtime::Module::from_file(
+        &engine,
+        meta.wasm
+            .as_ref()
+            .ok_or_else(|| anyhow!("no wasm in plugin"))?,
+    )?;
+    let mut linker = wasmtime::Linker::new(&engine);
+    wasmtime_wasi::add_to_linker(&mut linker, |s| s)?;
+    HttpState::new()?.add_to_linker(&mut linker, |_| HttpCtx {
+        allowed_hosts: Some(vec!["insecure:allow-all".to_string()]),
+        max_concurrent_requests: Some(100),
+    })?;
+
+    let volt_path = meta
+        .dir
+        .as_ref()
+        .ok_or_else(|| anyhow!("plugin meta doesn't have dir"))?;
+
+    #[cfg(target_os = "linux")]
+    let volt_libc = {
+        match std::process::Command::new("ldd").arg("--version").output() {
+            Ok(cmd) => {
+                if String::from_utf8_lossy(&cmd.stdout)
+                    .to_lowercase()
+                    .split_terminator('\n')
+                    .next()
+                    .unwrap_or("")
+                    .contains("musl")
+                {
+                    "musl"
+                } else {
+                    "glibc"
+                }
+            }
+            _ => "glibc",
+        }
+    };
+
+    #[cfg(not(target_os = "linux"))]
+    let volt_libc = "";
+
+    let stdin = Arc::new(RwLock::new(WasiPipe::new()));
+    let stdout = Arc::new(RwLock::new(WasiPipe::new()));
+    let stderr = Arc::new(RwLock::new(WasiPipe::new()));
+    let wasi = WasiCtxBuilder::new()
+        .inherit_env()?
+        .env("VOLT_OS", std::env::consts::OS)?
+        .env("VOLT_ARCH", std::env::consts::ARCH)?
+        .env("VOLT_LIBC", volt_libc)?
+        .env(
+            "VOLT_URI",
+            Url::from_directory_path(volt_path)
+                .map_err(|_| anyhow!("can't convert folder path to uri"))?
+                .as_ref(),
+        )?
+        .stdin(Box::new(wasi_common::pipe::ReadPipe::from_shared(
+            stdin.clone(),
+        )))
+        .stdout(Box::new(wasi_common::pipe::WritePipe::from_shared(
+            stdout.clone(),
+        )))
+        .stderr(Box::new(wasi_common::pipe::WritePipe::from_shared(
+            stderr.clone(),
+        )))
+        .preopened_dir(
+            wasmtime_wasi::Dir::open_ambient_dir(
+                volt_path,
+                wasmtime_wasi::ambient_authority(),
+            )?,
+            "/",
+        )?
+        .build();
+    let mut store = wasmtime::Store::new(&engine, wasi);
+
+    let (io_tx, io_rx) = crossbeam_channel::unbounded();
+    let rpc = PluginServerRpcHandler::new(meta.id(), io_tx);
+
+    let local_rpc = rpc.clone();
+    let local_stdin = stdin.clone();
+    linker.func_wrap("lapce", "host_handle_rpc", move || {
+        if let Ok(msg) = wasi_read_string(&stdout) {
+            if let Some(resp) = handle_plugin_server_message(&local_rpc, &msg) {
+                if let Ok(msg) = serde_json::to_string(&resp) {
+                    let _ = writeln!(local_stdin.write().unwrap(), "{msg}");
+                }
+            }
+        }
+    })?;
+    linker.func_wrap("lapce", "host_handle_stderr", move || {
+        if let Ok(msg) = wasi_read_string(&stderr) {
+            eprintln!("got stderr from plugin: {msg}");
+        }
+    })?;
+    linker.module(&mut store, "", &module)?;
+    thread::spawn(move || {
+        let instance = linker.instantiate(&mut store, &module).unwrap();
+        let handle_rpc = instance
+            .get_func(&mut store, "handle_rpc")
+            .ok_or_else(|| anyhow!("can't convet to function"))
+            .unwrap()
+            .typed::<(), (), _>(&mut store)
+            .unwrap();
+        for msg in io_rx {
+            if let Ok(msg) = serde_json::to_string(&msg) {
+                let _ = writeln!(stdin.write().unwrap(), "{msg}");
+            }
+            let _ = handle_rpc.call(&mut store, ());
+        }
+    });
+
+    let id = PluginId::next();
+    let mut plugin = Plugin {
+        id,
+        host: PluginHostHandler::new(
+            workspace,
+            meta.dir.clone(),
+            meta.id(),
+            meta.display_name.clone(),
+            meta.activation
+                .iter()
+                .flat_map(|m| m.language.iter().flatten())
+                .cloned()
+                .map(|s| DocumentFilter {
+                    language: Some(s),
+                    pattern: None,
+                    scheme: None,
+                })
+                .chain(
+                    meta.activation
+                        .iter()
+                        .flat_map(|m| m.workspace_contains.iter().flatten())
+                        .cloned()
+                        .map(|s| DocumentFilter {
+                            language: None,
+                            pattern: Some(s),
+                            scheme: None,
+                        }),
+                )
+                .collect(),
+            rpc.clone(),
+            plugin_rpc.clone(),
+        ),
+        configurations,
+    };
+    let local_rpc = rpc.clone();
+    thread::spawn(move || {
+        local_rpc.mainloop(&mut plugin);
+    });
+
+    if plugin_rpc.plugin_server_loaded(rpc.clone()).is_err() {
+        rpc.shutdown();
+    }
+    Ok(())
+}
+
+fn wasi_read_string(stdout: &Arc<RwLock<WasiPipe>>) -> Result<String> {
+    let mut buf = String::new();
+    stdout.write().unwrap().read_to_string(&mut buf)?;
+    Ok(buf)
+}
+
+fn unflatten_map(map: &HashMap<String, serde_json::Value>) -> serde_json::Value {
+    let mut new = serde_json::json!({});
+    for (key, value) in map.iter() {
+        let mut current = new.as_object_mut().unwrap();
+        let parts: Vec<&str> = key.split('.').collect();
+        let total_parts = parts.len();
+        for (i, part) in parts.into_iter().enumerate() {
+            if i + 1 < total_parts {
+                if !current.get(part).map(|v| v.is_object()).unwrap_or(false) {
+                    current.insert(part.to_string(), serde_json::json!({}));
+                }
+                current = current.get_mut(part).unwrap().as_object_mut().unwrap();
+            } else {
+                current.insert(part.to_string(), value.clone());
+            }
+        }
+    }
+    new
+}
diff --git a/lapce-proxy/src/plugin/wasi/plugins/smiley.png b/lapce-proxy/src/plugin/wasi/plugins/smiley.png
new file mode 100644
index 0000000000..469c8109d8
Binary files /dev/null and b/lapce-proxy/src/plugin/wasi/plugins/smiley.png differ
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/Dark.svg b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/Dark.svg
new file mode 100644
index 0000000000..86ce3c1de0
--- /dev/null
+++ b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/Dark.svg
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="100"
+   height="100"
+   viewBox="0 0 26.458333 26.458333"
+   version="1.1"
+   id="svg169"
+   inkscape:version="1.2 (dc2aedaf03, 2022-05-15)"
+   sodipodi:docname="рисунок.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview171"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:document-units="mm"
+     showgrid="false"
+     inkscape:zoom="5.9651515"
+     inkscape:cx="41.490983"
+     inkscape:cy="49.286259"
+     inkscape:window-width="1920"
+     inkscape:window-height="1017"
+     inkscape:window-x="-8"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1" />
+  <defs
+     id="defs166" />
+  <g
+     inkscape:label="Слой 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <ellipse
+       style="fill:#000000;fill-opacity:1;stroke:#0000ff;stroke-width:2.0673;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+       id="path483"
+       cx="13.173385"
+       cy="13.48387"
+       rx="12.114121"
+       ry="11.892347" />
+  </g>
+</svg>
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/Dark.toml b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/Dark.toml
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/Light.svg b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/Light.svg
new file mode 100644
index 0000000000..9fee4f095d
--- /dev/null
+++ b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/Light.svg
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="100"
+   height="100"
+   viewBox="0 0 26.458333 26.458333"
+   version="1.1"
+   id="svg169"
+   inkscape:version="1.2 (dc2aedaf03, 2022-05-15)"
+   sodipodi:docname="рисунок1.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview171"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:document-units="mm"
+     showgrid="false"
+     inkscape:zoom="5.9651515"
+     inkscape:cx="41.490983"
+     inkscape:cy="49.286259"
+     inkscape:window-width="1920"
+     inkscape:window-height="1017"
+     inkscape:window-x="-8"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1" />
+  <defs
+     id="defs166" />
+  <g
+     inkscape:label="Слой 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <ellipse
+       style="fill:#ffffff;fill-opacity:1;stroke:#0000ff;stroke-width:2.0673;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+       id="path483"
+       cx="13.173385"
+       cy="13.48387"
+       rx="12.114121"
+       ry="11.892347" />
+  </g>
+</svg>
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/Light.toml b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/Light.toml
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/lapce.wasm b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/lapce.wasm
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/volt.toml b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/volt.toml
new file mode 100644
index 0000000000..bde3fe9554
--- /dev/null
+++ b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-one/volt.toml
@@ -0,0 +1,16 @@
+name = "some-useful-plugin"
+version = "0.1.56"
+display-name = "Some Useful Plugin Name"
+author = "some_author"
+description = "very useful plugin"
+icon = "icon.svg"
+repository = "https://github.com/lapce"
+wasm = "lapce.wasm"
+color-themes = [
+    "Dark.toml",
+    "Light.toml",
+]
+icon-themes = [
+    "Dark.svg",
+    "Light.svg",
+]
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-three/volt.toml b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-three/volt.toml
new file mode 100644
index 0000000000..bde3fe9554
--- /dev/null
+++ b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-three/volt.toml
@@ -0,0 +1,16 @@
+name = "some-useful-plugin"
+version = "0.1.56"
+display-name = "Some Useful Plugin Name"
+author = "some_author"
+description = "very useful plugin"
+icon = "icon.svg"
+repository = "https://github.com/lapce"
+wasm = "lapce.wasm"
+color-themes = [
+    "Dark.toml",
+    "Light.toml",
+]
+icon-themes = [
+    "Dark.svg",
+    "Light.svg",
+]
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-two/Light.svg b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-two/Light.svg
new file mode 100644
index 0000000000..9fee4f095d
--- /dev/null
+++ b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-two/Light.svg
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="100"
+   height="100"
+   viewBox="0 0 26.458333 26.458333"
+   version="1.1"
+   id="svg169"
+   inkscape:version="1.2 (dc2aedaf03, 2022-05-15)"
+   sodipodi:docname="рисунок1.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview171"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:document-units="mm"
+     showgrid="false"
+     inkscape:zoom="5.9651515"
+     inkscape:cx="41.490983"
+     inkscape:cy="49.286259"
+     inkscape:window-width="1920"
+     inkscape:window-height="1017"
+     inkscape:window-x="-8"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1" />
+  <defs
+     id="defs166" />
+  <g
+     inkscape:label="Слой 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <ellipse
+       style="fill:#ffffff;fill-opacity:1;stroke:#0000ff;stroke-width:2.0673;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+       id="path483"
+       cx="13.173385"
+       cy="13.48387"
+       rx="12.114121"
+       ry="11.892347" />
+  </g>
+</svg>
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-two/Light.toml b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-two/Light.toml
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-two/lapce.wasm b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-two/lapce.wasm
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-two/volt.toml b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-two/volt.toml
new file mode 100644
index 0000000000..8170be8cd4
--- /dev/null
+++ b/lapce-proxy/src/plugin/wasi/plugins/some_author.test-plugin-two/volt.toml
@@ -0,0 +1,16 @@
+name = "some-useful-plugin"
+version = "0.1.56"
+display-name = "Some Useful Plugin Name"
+author = "some_author."
+description = "very useful plugin"
+icon = "icon.svg"
+repository = "https://github.com/lapce"
+wasm = "lapce.wasm"
+color-themes = [
+    "Dark.toml",
+    "Light.toml",
+]
+icon-themes = [
+    "Dark.svg",
+    "Light.svg",
+]
diff --git a/lapce-proxy/src/plugin/wasi/tests.rs b/lapce-proxy/src/plugin/wasi/tests.rs
new file mode 100644
index 0000000000..8711d2b760
--- /dev/null
+++ b/lapce-proxy/src/plugin/wasi/tests.rs
@@ -0,0 +1,236 @@
+use super::load_volt;
+use super::unflatten_map;
+use lapce_rpc::plugin::VoltMetadata;
+use serde_json::{json, Value};
+use std::collections::HashMap;
+
+#[test]
+fn test_unflatten_map() {
+    let map: HashMap<String, Value> = serde_json::from_value(json!({
+        "a.b.c": "d",
+        "a.d": ["e"],
+    }))
+    .unwrap();
+    assert_eq!(
+        unflatten_map(&map),
+        json!({
+            "a": {
+                "b": {
+                    "c": "d",
+                },
+                "d": ["e"],
+            }
+        })
+    );
+}
+
+#[test]
+fn test_load_volt() {
+    let lapce_proxy_dir = std::env::current_dir()
+        .expect("Can't get \"lapce-proxy\" directory")
+        .join("src")
+        .join("plugin")
+        .join("wasi")
+        .join("plugins");
+
+    // Invalid path (file does not exist)
+    let path = lapce_proxy_dir.join("some-path");
+    match path.canonicalize() {
+        Ok(path) => panic!("{path:?} file must not exast, but it is"),
+        Err(err) => assert_eq!(err.kind(), std::io::ErrorKind::NotFound),
+    };
+    // This should return Err since the file does not exist
+    if let Ok(volt_metadata) = load_volt(&lapce_proxy_dir) {
+        panic!(
+            "Unexpected result from `lapce_proxy::plugin::wasi::load_volt` function: {volt_metadata:?}"
+        );
+    }
+
+    // Invalid file (not readable into a string)
+    // Making sure the file exists
+    let path = lapce_proxy_dir.join("smiley.png");
+    let path = match path.canonicalize() {
+        Ok(path) => path,
+        Err(err) => panic!("{path:?} file must exast, but: {err:?}"),
+    };
+    // Making sure the data in the file is invalid utf-8
+    match std::fs::read_to_string(path.clone()) {
+        Ok(str) => panic!(
+            "{path:?} file must be invalid utf-8, but it is valid utf-8: {str:?}",
+        ),
+        Err(err) => assert_eq!(err.kind(), std::io::ErrorKind::InvalidData),
+    }
+    // This should return Err since the `*.png` file cannot be read as a String
+    if let Ok(volt_metadata) = load_volt(&path) {
+        panic!(
+            "Unexpected result from `lapce_proxy::plugin::wasi::load_volt` function: {volt_metadata:?}",
+        );
+    }
+
+    // Invalid data in file (cannot be read as VoltMetadata)
+    // Making sure the file exists
+    let path = lapce_proxy_dir
+        .join("some_author.test-plugin-one")
+        .join("Light.svg");
+    let path = match path.canonicalize() {
+        Ok(path) => path,
+        Err(err) => panic!("{path:?} file must exast, but: {err:?}"),
+    };
+    // Making sure the data in the file is valid utf-8 (*.svg file is must be a valid utf-8)
+    match std::fs::read_to_string(path.clone()) {
+        Ok(_) => {}
+        Err(err) => panic!("{path:?} file must be valid utf-8, but {err:?}"),
+    }
+    // This should return Err since the data in the file cannot be interpreted as VoltMetadata
+    if let Ok(volt_metadata) = load_volt(&path) {
+        panic!(
+            "Unexpected result from `lapce_proxy::plugin::wasi::load_volt` function: {volt_metadata:?}",
+        );
+    }
+
+    let parent_path = lapce_proxy_dir.join("some_author.test-plugin-one");
+
+    let volt_metadata = match load_volt(&parent_path) {
+        Ok(volt_metadata) => volt_metadata,
+        Err(error) => panic!("{}", error),
+    };
+
+    let wasm_path = parent_path
+        .join("lapce.wasm")
+        .canonicalize()
+        .ok()
+        .as_ref()
+        .and_then(|path| path.to_str())
+        .map(ToOwned::to_owned);
+
+    let color_themes_pathes = ["Dark.toml", "Light.toml"]
+        .into_iter()
+        .filter_map(|theme| {
+            parent_path
+                .join(theme)
+                .canonicalize()
+                .ok()
+                .as_ref()
+                .and_then(|path| path.to_str())
+                .map(ToOwned::to_owned)
+        })
+        .collect::<Vec<_>>();
+
+    let icon_themes_pathes = ["Dark.svg", "Light.svg"]
+        .into_iter()
+        .filter_map(|theme| {
+            parent_path
+                .join(theme)
+                .canonicalize()
+                .ok()
+                .as_ref()
+                .and_then(|path| path.to_str())
+                .map(ToOwned::to_owned)
+        })
+        .collect::<Vec<_>>();
+
+    assert_eq!(
+        volt_metadata,
+        VoltMetadata {
+            name: "some-useful-plugin".to_string(),
+            version: "0.1.56".to_string(),
+            display_name: "Some Useful Plugin Name".to_string(),
+            author: "some_author".to_string(),
+            description: "very useful plugin".to_string(),
+            icon: Some("icon.svg".to_string()),
+            repository: Some("https://github.com/lapce".to_string()),
+            wasm: wasm_path,
+            color_themes: Some(color_themes_pathes),
+            icon_themes: Some(icon_themes_pathes),
+            dir: parent_path.canonicalize().ok(),
+            activation: None,
+            config: None
+        }
+    );
+
+    let parent_path = lapce_proxy_dir.join("some_author.test-plugin-two");
+
+    let volt_metadata = match load_volt(&parent_path) {
+        Ok(volt_metadata) => volt_metadata,
+        Err(error) => panic!("{}", error),
+    };
+
+    let wasm_path = parent_path
+        .join("lapce.wasm")
+        .canonicalize()
+        .ok()
+        .as_ref()
+        .and_then(|path| path.to_str())
+        .map(ToOwned::to_owned);
+
+    let color_themes_pathes = ["Light.toml"]
+        .into_iter()
+        .filter_map(|theme| {
+            parent_path
+                .join(theme)
+                .canonicalize()
+                .ok()
+                .as_ref()
+                .and_then(|path| path.to_str())
+                .map(ToOwned::to_owned)
+        })
+        .collect::<Vec<_>>();
+
+    let icon_themes_pathes = ["Light.svg"]
+        .into_iter()
+        .filter_map(|theme| {
+            parent_path
+                .join(theme)
+                .canonicalize()
+                .ok()
+                .as_ref()
+                .and_then(|path| path.to_str())
+                .map(ToOwned::to_owned)
+        })
+        .collect::<Vec<_>>();
+
+    assert_eq!(
+        volt_metadata,
+        VoltMetadata {
+            name: "some-useful-plugin".to_string(),
+            version: "0.1.56".to_string(),
+            display_name: "Some Useful Plugin Name".to_string(),
+            author: "some_author.".to_string(),
+            description: "very useful plugin".to_string(),
+            icon: Some("icon.svg".to_string()),
+            repository: Some("https://github.com/lapce".to_string()),
+            wasm: wasm_path,
+            color_themes: Some(color_themes_pathes),
+            icon_themes: Some(icon_themes_pathes),
+            dir: parent_path.canonicalize().ok(),
+            activation: None,
+            config: None
+        }
+    );
+
+    let parent_path = lapce_proxy_dir.join("some_author.test-plugin-three");
+
+    let volt_metadata = match load_volt(&parent_path) {
+        Ok(volt_metadata) => volt_metadata,
+        Err(error) => panic!("{}", error),
+    };
+
+    assert_eq!(
+        volt_metadata,
+        VoltMetadata {
+            name: "some-useful-plugin".to_string(),
+            version: "0.1.56".to_string(),
+            display_name: "Some Useful Plugin Name".to_string(),
+            author: "some_author".to_string(),
+            description: "very useful plugin".to_string(),
+            icon: Some("icon.svg".to_string()),
+            repository: Some("https://github.com/lapce".to_string()),
+            wasm: None,
+            color_themes: Some(Vec::new()),
+            icon_themes: Some(Vec::new()),
+            dir: parent_path.canonicalize().ok(),
+            activation: None,
+            config: None
+        }
+    );
+}
diff --git a/lapce-proxy/src/terminal.rs b/lapce-proxy/src/terminal.rs
index 45d877f1fd..d97ff5274b 100644
--- a/lapce-proxy/src/terminal.rs
+++ b/lapce-proxy/src/terminal.rs
@@ -1,3 +1,5 @@
+#[cfg(target_os = "linux")]
+use std::process::Command;
 use std::{
     borrow::Cow,
     collections::VecDeque,
@@ -7,13 +9,12 @@ use std::{
 
 use alacritty_terminal::{
     config::Program,
-    event::OnResize,
+    event::{OnResize, WindowSize},
     event_loop::Msg,
-    term::SizeInfo,
     tty::{self, setup_env, EventedPty, EventedReadWrite},
 };
 use directories::BaseDirs;
-use lapce_rpc::terminal::TermId;
+use lapce_rpc::{core::CoreRpcHandler, terminal::TermId};
 #[cfg(not(windows))]
 use mio::unix::UnixReady;
 #[allow(deprecated)]
@@ -21,9 +22,6 @@ use mio::{
     channel::{channel, Receiver, Sender},
     Events, PollOpt, Ready,
 };
-use serde_json::json;
-
-use crate::dispatch::Dispatcher;
 
 const READ_BUFFER_SIZE: usize = 0x10_0000;
 
@@ -52,16 +50,44 @@ impl Terminal {
         let poll = mio::Poll::new().unwrap();
         let mut config = TermConfig::default();
         config.pty_config.working_directory =
-            cwd.or_else(|| BaseDirs::new().map(|d| PathBuf::from(d.home_dir())));
+            if cwd.is_some() && cwd.clone().unwrap().exists() {
+                cwd
+            } else {
+                BaseDirs::new().map(|d| PathBuf::from(d.home_dir()))
+            };
         let shell = shell.trim();
-        if !shell.is_empty() {
+        let flatpak_use_host_terminal = flatpak_should_use_host_terminal();
+
+        if !shell.is_empty() || flatpak_use_host_terminal {
             let mut parts = shell.split(' ');
-            let program = parts.next().unwrap();
-            if let Ok(p) = which::which(program) {
+
+            if flatpak_use_host_terminal {
+                let flatpak_spawn_path = "/usr/bin/flatpak-spawn".to_string();
+                let host_shell = flatpak_get_default_host_shell();
+
+                let args = if shell.is_empty() {
+                    vec!["--host".to_string(), host_shell]
+                } else {
+                    vec![
+                        "--host".to_string(),
+                        host_shell,
+                        "-c".to_string(),
+                        shell.to_string(),
+                    ]
+                };
+
                 config.pty_config.shell = Some(Program::WithArgs {
-                    program: p.to_str().unwrap().to_string(),
-                    args: parts.map(|p| p.to_string()).collect::<Vec<String>>(),
+                    program: flatpak_spawn_path,
+                    args,
                 })
+            } else {
+                let program = parts.next().unwrap();
+                if let Ok(p) = which::which(program) {
+                    config.pty_config.shell = Some(Program::WithArgs {
+                        program: p.to_str().unwrap().to_string(),
+                        args: parts.map(|p| p.to_string()).collect::<Vec<String>>(),
+                    })
+                }
             }
         }
         setup_env(&config);
@@ -69,10 +95,13 @@ impl Terminal {
         #[cfg(target_os = "macos")]
         set_locale_environment();
 
-        let size =
-            SizeInfo::new(width as f32, height as f32, 1.0, 1.0, 0.0, 0.0, true);
-        let pty =
-            alacritty_terminal::tty::new(&config.pty_config, &size, None).unwrap();
+        let size = WindowSize {
+            num_lines: height as u16,
+            num_cols: width as u16,
+            cell_width: 1,
+            cell_height: 1,
+        };
+        let pty = alacritty_terminal::tty::new(&config.pty_config, size, 0).unwrap();
 
         #[allow(deprecated)]
         let (tx, rx) = channel();
@@ -86,7 +115,7 @@ impl Terminal {
         }
     }
 
-    pub fn run(&mut self, dispatcher: Dispatcher) {
+    pub fn run(&mut self, core_rpc: CoreRpcHandler) {
         let mut tokens = (0..).map(Into::into);
         let poll_opts = PollOpt::edge() | PollOpt::oneshot();
 
@@ -117,12 +146,7 @@ impl Terminal {
                         if let Some(tty::ChildEvent::Exited) =
                             self.pty.next_child_event()
                         {
-                            dispatcher.send_notification(
-                                "close_terminal",
-                                json!({
-                                    "term_id": self.term_id,
-                                }),
-                            );
+                            core_rpc.close_terminal(self.term_id);
                             break 'event_loop;
                         }
                     }
@@ -139,12 +163,9 @@ impl Terminal {
                         if event.readiness().is_readable() {
                             match self.pty.reader().read(&mut buf) {
                                 Ok(n) => {
-                                    dispatcher.send_notification(
-                                        "update_terminal",
-                                        json!({
-                                            "term_id": self.term_id,
-                                            "content": base64::encode(&buf[..n]),
-                                        }),
+                                    core_rpc.update_terminal(
+                                        self.term_id,
+                                        buf[..n].to_vec(),
                                     );
                                 }
                                 Err(_e) => (),
@@ -182,7 +203,7 @@ impl Terminal {
             match msg {
                 Msg::Input(input) => state.write_list.push_back(input),
                 Msg::Shutdown => return false,
-                Msg::Resize(size) => self.pty.on_resize(&size),
+                Msg::Resize(size) => self.pty.on_resize(size),
             }
         }
 
@@ -307,10 +328,128 @@ impl State {
     }
 }
 
+/// Code taken (and slightly modified) from wezterm's env-bootstrap
+/// Source: https://github.com/wez/wezterm/blob/691ec187ba29fcae45ddf4e4f88fd02c49988c86/env-bootstrap/src/lib.rs#L86
+/// License: https://github.com/wez/wezterm/blob/691ec187ba29fcae45ddf4e4f88fd02c49988c86/LICENSE.md
+/// SPDX: MIT
 #[cfg(target_os = "macos")]
 fn set_locale_environment() {
-    let locale = locale_config::Locale::global_default()
-        .to_string()
-        .replace('-', "_");
-    std::env::set_var("LC_ALL", locale + ".UTF-8");
+    use cocoa::base::id;
+    use cocoa::foundation::NSString;
+    use objc::runtime::Object;
+    use objc::*;
+
+    fn lang_is_set() -> bool {
+        match std::env::var_os("LANG") {
+            None => false,
+            Some(lang) => !lang.is_empty(),
+        }
+    }
+
+    if !lang_is_set() {
+        unsafe fn nsstring_to_str<'a>(ns: *mut Object) -> &'a str {
+            let data = NSString::UTF8String(ns as id) as *const u8;
+            let len = NSString::len(ns as id);
+            let bytes = std::slice::from_raw_parts(data, len);
+            std::str::from_utf8_unchecked(bytes)
+        }
+
+        unsafe {
+            let locale: *mut Object =
+                msg_send![class!(NSLocale), autoupdatingCurrentLocale];
+            let lang_code_obj: *mut Object = msg_send![locale, languageCode];
+            let country_code_obj: *mut Object = msg_send![locale, countryCode];
+
+            {
+                let lang_code = nsstring_to_str(lang_code_obj);
+                let country_code = nsstring_to_str(country_code_obj);
+
+                let candidate = format!("{lang_code}_{country_code}.UTF-8");
+                let candidate_cstr =
+                    std::ffi::CString::new(<&[u8]>::clone(&candidate.as_bytes()))
+                        .expect("make cstr from str");
+
+                // If this looks like a working locale then export it to
+                // the environment so that our child processes inherit it.
+                let old = libc::setlocale(libc::LC_CTYPE, std::ptr::null());
+                if !libc::setlocale(libc::LC_CTYPE, candidate_cstr.as_ptr())
+                    .is_null()
+                {
+                    std::env::set_var("LANG", &candidate);
+                } else {
+                    log::warn!(
+                        "setlocale({}) failed, fall back to en_US.UTF-8",
+                        candidate
+                    );
+                    std::env::set_var("LANG", "en_US.UTF-8");
+                }
+                libc::setlocale(libc::LC_CTYPE, old);
+            }
+
+            let _: () = msg_send![lang_code_obj, release];
+            let _: () = msg_send![country_code_obj, release];
+            let _: () = msg_send![locale, release];
+        }
+    }
+}
+
+#[inline]
+#[cfg(not(target_os = "linux"))]
+fn flatpak_get_default_host_shell() -> String {
+    panic!(
+        "This should never be reached. If it is, ensure you don't have a file
+        called .flatpak-info in your root directory"
+    );
+}
+
+#[inline]
+#[cfg(target_os = "linux")]
+fn flatpak_get_default_host_shell() -> String {
+    let env_string = Command::new("flatpak-spawn")
+        .arg("--host")
+        .arg("printenv")
+        .output()
+        .unwrap()
+        .stdout;
+
+    let env_string = String::from_utf8(env_string).unwrap();
+
+    for env_pair in env_string.split('\n') {
+        let name_value: Vec<&str> = env_pair.split('=').collect();
+
+        if name_value[0] == "SHELL" {
+            return name_value[1].to_string();
+        }
+    }
+
+    // In case SHELL isn't set for whatever reason, fall back to this
+    "/bin/sh".to_string()
+}
+
+#[inline]
+#[cfg(not(target_os = "linux"))]
+fn flatpak_should_use_host_terminal() -> bool {
+    false // Flatpak is only available on Linux
+}
+
+#[inline]
+#[cfg(target_os = "linux")]
+fn flatpak_should_use_host_terminal() -> bool {
+    use std::path::Path;
+
+    const FLATPAK_INFO_PATH: &str = "/.flatpak-info";
+
+    // The de-facto way of checking whether one is inside of a Flatpak container is by checking for
+    // the presence of /.flatpak-info in the filesystem
+    if !Path::new(FLATPAK_INFO_PATH).exists() {
+        return false;
+    }
+
+    // Ensure flatpak-spawn --host can execute a basic command
+    Command::new("flatpak-spawn")
+        .arg("--host")
+        .arg("true")
+        .status()
+        .map(|status| status.success())
+        .unwrap_or(false)
 }
diff --git a/lapce-proxy/src/watcher.rs b/lapce-proxy/src/watcher.rs
index 6ca65b4a43..6d2713375c 100644
--- a/lapce-proxy/src/watcher.rs
+++ b/lapce-proxy/src/watcher.rs
@@ -4,7 +4,7 @@ use std::{
     sync::Arc,
 };
 
-use crossbeam_channel::unbounded;
+use crossbeam_channel::{unbounded, Receiver};
 use notify::{
     event::{ModifyKind, RenameMode},
     recommended_watcher, Event, EventKind, RecommendedWatcher, RecursiveMode,
@@ -16,6 +16,7 @@ use parking_lot::Mutex;
 /// in a separate thread, and communicates with it via a [crossbeam channel].
 /// [crossbeam channel]: https://docs.rs/crossbeam-channel
 pub struct FileWatcher {
+    rx_event: Option<Receiver<Result<Event, notify::Error>>>,
     inner: RecommendedWatcher,
     state: Arc<Mutex<WatcherState>>,
 }
@@ -47,7 +48,7 @@ pub struct WatchToken(pub usize);
 /// A trait for types which can be notified of new events.
 /// New events are accessible through the `FileWatcher` instance.
 pub trait Notify: Send {
-    fn notify(&self);
+    fn notify(&self, events: Vec<(WatchToken, Event)>);
 }
 
 pub type EventQueue = VecDeque<(WatchToken, Event)>;
@@ -55,35 +56,42 @@ pub type EventQueue = VecDeque<(WatchToken, Event)>;
 pub type PathFilter = dyn Fn(&Path) -> bool + Send + 'static;
 
 impl FileWatcher {
-    pub fn new<T: Notify + 'static>(peer: T) -> Self {
+    pub fn new() -> Self {
         let (tx_event, rx_event) = unbounded();
 
         let state = Arc::new(Mutex::new(WatcherState::default()));
-        let state_clone = state.clone();
 
         let inner = recommended_watcher(tx_event).expect("watcher should spawn");
 
+        FileWatcher {
+            rx_event: Some(rx_event),
+            inner,
+            state,
+        }
+    }
+
+    pub fn notify<T: Notify + 'static>(&mut self, peer: T) {
+        let rx_event = self.rx_event.take().unwrap();
+        let state = self.state.clone();
         std::thread::spawn(move || {
             while let Ok(Ok(event)) = rx_event.recv() {
+                let mut events = Vec::new();
                 {
-                    let mut state = state_clone.lock();
+                    let mut state = state.lock();
                     let WatcherState {
-                        ref mut events,
-                        ref mut watchees,
+                        ref mut watchees, ..
                     } = *state;
 
                     watchees
                         .iter()
                         .filter(|w| w.wants_event(&event))
                         .map(|w| w.token)
-                        .for_each(|t| events.push_back((t, event.clone())));
+                        .for_each(|t| events.push((t, event.clone())));
                 }
 
-                peer.notify();
+                peer.notify(events);
             }
         });
-
-        FileWatcher { inner, state }
     }
 
     /// Begin watching `path`. As `Event`s (documented in the
@@ -188,13 +196,19 @@ impl FileWatcher {
     }
 
     /// Takes ownership of this `Watcher`'s current event queue.
-    pub fn take_events(&mut self) -> VecDeque<(WatchToken, Event)> {
+    pub fn take_events(&self) -> VecDeque<(WatchToken, Event)> {
         let mut state = self.state.lock();
         let WatcherState { ref mut events, .. } = *state;
         std::mem::take(events)
     }
 }
 
+impl Default for FileWatcher {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Watchee {
     fn wants_event(&self, event: &Event) -> bool {
         match &event.kind {
diff --git a/lapce-rpc/Cargo.toml b/lapce-rpc/Cargo.toml
index 37be886787..5fba39d730 100644
--- a/lapce-rpc/Cargo.toml
+++ b/lapce-rpc/Cargo.toml
@@ -1,16 +1,22 @@
 [package]
 name = "lapce-rpc"
-version = "0.1.2"
-authors = ["Dongdong Zhou <dzhou121@gmail.com>"]
-edition = "2021"
+description = "Data formats between lapce components"
+license = "Apache-2.0"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
 
 [dependencies]
-notify = { version = "5.0.0-pre.13", features = ["serde"] }
-parking_lot = "0.11.2"
-anyhow = "1.0.34"
-serde_json = "1.0.59"
-serde = "1.0"
-jsonrpc-lite = "0.5.0"
-crossbeam-channel = "0.5.0"
-lsp-types = { version = "0.89.2", features = ["proposed"] }
-xi-rope = { git = "https://github.com/lapce/xi-editor", features = ["serde"] }
+anyhow.workspace = true
+crossbeam-channel.workspace = true
+indexmap.workspace = true
+log.workspace = true
+parking_lot.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+
+lsp-types.workspace = true
+
+lapce-xi-rope.workspace = true
+
+human-sort = { git = "https://github.com/dragazo/human-sort" }
diff --git a/lapce-rpc/src/core.rs b/lapce-rpc/src/core.rs
index 60d7ef9e48..d542a099f6 100644
--- a/lapce-rpc/src/core.rs
+++ b/lapce-rpc/src/core.rs
@@ -1,47 +1,96 @@
-use lsp_types::{ProgressParams, PublishDiagnosticsParams};
+use std::{
+    collections::HashMap,
+    path::PathBuf,
+    sync::{
+        atomic::{AtomicU64, Ordering},
+        Arc,
+    },
+};
+
+use crossbeam_channel::{Receiver, Sender};
+use lsp_types::{
+    CompletionResponse, LogMessageParams, ProgressParams, PublishDiagnosticsParams,
+    ShowMessageParams, SignatureHelp,
+};
+use parking_lot::Mutex;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, path::PathBuf};
 
 use crate::{
-    buffer::BufferId, file::FileNodeItem, plugin::PluginDescription,
-    source_control::DiffInfo, style::LineStyle, terminal::TermId,
+    file::FileNodeItem,
+    plugin::{PluginId, VoltInfo, VoltMetadata},
+    source_control::DiffInfo,
+    terminal::TermId,
+    RequestId, RpcError, RpcMessage,
 };
 
+pub enum CoreRpc {
+    Request(RequestId, CoreRequest),
+    Notification(Box<CoreNotification>), // Box it since clippy complains
+    Shutdown,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 #[serde(tag = "method", content = "params")]
 pub enum CoreNotification {
     ProxyConnected {},
-    SemanticStyles {
-        rev: u64,
-        buffer_id: BufferId,
-        path: PathBuf,
-        len: usize,
-        styles: Vec<LineStyle>,
-    },
     OpenFileChanged {
         path: PathBuf,
         content: String,
     },
+    CompletionResponse {
+        request_id: usize,
+        input: String,
+        resp: CompletionResponse,
+        plugin_id: PluginId,
+    },
+    SignatureHelpResponse {
+        request_id: usize,
+        resp: SignatureHelp,
+        plugin_id: PluginId,
+    },
     ReloadBuffer {
         path: PathBuf,
         content: String,
         rev: u64,
     },
-    FileChange {
-        event: notify::Event,
+    OpenPaths {
+        window_tab_id: Option<(usize, usize)>,
+        folders: Vec<PathBuf>,
+        files: Vec<PathBuf>,
     },
+    WorkspaceFileChange {},
     PublishDiagnostics {
         diagnostics: PublishDiagnosticsParams,
     },
     WorkDoneProgress {
         progress: ProgressParams,
     },
+    ShowMessage {
+        title: String,
+        message: ShowMessageParams,
+    },
+    LogMessage {
+        message: LogMessageParams,
+    },
     HomeDir {
         path: PathBuf,
     },
-    InstalledPlugins {
-        plugins: HashMap<String, PluginDescription>,
+    VoltInstalled {
+        volt: VoltMetadata,
+        icon: Option<Vec<u8>>,
+    },
+    VoltInstalling {
+        volt: VoltInfo,
+        error: String,
+    },
+    VoltRemoving {
+        volt: VoltMetadata,
+        error: String,
+    },
+    VoltRemoved {
+        volt: VoltInfo,
+        only_installing: bool,
     },
     ListDir {
         items: Vec<FileNodeItem>,
@@ -54,12 +103,211 @@ pub enum CoreNotification {
     },
     UpdateTerminal {
         term_id: TermId,
-        content: String,
+        content: Vec<u8>,
     },
     CloseTerminal {
         term_id: TermId,
     },
+    Log {
+        level: String,
+        message: String,
+    },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum CoreRequest {}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(tag = "method", content = "params")]
+pub enum CoreResponse {}
+
+pub type CoreMessage = RpcMessage<CoreRequest, CoreNotification, CoreResponse>;
+
+pub trait CoreHandler {
+    fn handle_notification(&mut self, rpc: CoreNotification);
+    fn handle_request(&mut self, id: RequestId, rpc: CoreRequest);
+}
+
+#[derive(Clone)]
+pub struct CoreRpcHandler {
+    tx: Sender<CoreRpc>,
+    rx: Receiver<CoreRpc>,
+    id: Arc<AtomicU64>,
+    #[allow(clippy::type_complexity)]
+    pending: Arc<Mutex<HashMap<u64, Sender<Result<CoreResponse, RpcError>>>>>,
+}
+
+impl CoreRpcHandler {
+    pub fn new() -> Self {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        Self {
+            tx,
+            rx,
+            id: Arc::new(AtomicU64::new(0)),
+            pending: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    pub fn mainloop<H>(&self, handler: &mut H)
+    where
+        H: CoreHandler,
+    {
+        for msg in &self.rx {
+            match msg {
+                CoreRpc::Request(id, rpc) => {
+                    handler.handle_request(id, rpc);
+                }
+                CoreRpc::Notification(rpc) => {
+                    handler.handle_notification(*rpc);
+                }
+                CoreRpc::Shutdown => {
+                    return;
+                }
+            }
+        }
+    }
+
+    pub fn rx(&self) -> &Receiver<CoreRpc> {
+        &self.rx
+    }
+
+    pub fn handle_response(
+        &self,
+        id: RequestId,
+        response: Result<CoreResponse, RpcError>,
+    ) {
+        let tx = { self.pending.lock().remove(&id) };
+        if let Some(tx) = tx {
+            let _ = tx.send(response);
+        }
+    }
+
+    pub fn request(&self, request: CoreRequest) -> Result<CoreResponse, RpcError> {
+        let (tx, rx) = crossbeam_channel::bounded(1);
+        let id = self.id.fetch_add(1, Ordering::Relaxed);
+        {
+            let mut pending = self.pending.lock();
+            pending.insert(id, tx);
+        }
+        let _ = self.tx.send(CoreRpc::Request(id, request));
+        rx.recv().unwrap_or_else(|_| {
+            Err(RpcError {
+                code: 0,
+                message: "io error".to_string(),
+            })
+        })
+    }
+
+    pub fn shutdown(&self) {
+        let _ = self.tx.send(CoreRpc::Shutdown);
+    }
+
+    pub fn notification(&self, notification: CoreNotification) {
+        let _ = self.tx.send(CoreRpc::Notification(Box::new(notification)));
+    }
+
+    pub fn proxy_connected(&self) {
+        self.notification(CoreNotification::ProxyConnected {});
+    }
+
+    pub fn workspace_file_change(&self) {
+        self.notification(CoreNotification::WorkspaceFileChange {});
+    }
+
+    pub fn diff_info(&self, diff: DiffInfo) {
+        self.notification(CoreNotification::DiffInfo { diff });
+    }
+
+    pub fn open_file_changed(&self, path: PathBuf, content: String) {
+        self.notification(CoreNotification::OpenFileChanged { path, content });
+    }
+
+    pub fn completion_response(
+        &self,
+        request_id: usize,
+        input: String,
+        resp: CompletionResponse,
+        plugin_id: PluginId,
+    ) {
+        self.notification(CoreNotification::CompletionResponse {
+            request_id,
+            input,
+            resp,
+            plugin_id,
+        });
+    }
+
+    pub fn signature_help_response(
+        &self,
+        request_id: usize,
+        resp: SignatureHelp,
+        plugin_id: PluginId,
+    ) {
+        self.notification(CoreNotification::SignatureHelpResponse {
+            request_id,
+            resp,
+            plugin_id,
+        });
+    }
+
+    pub fn volt_installed(&self, volt: VoltMetadata, icon: Option<Vec<u8>>) {
+        self.notification(CoreNotification::VoltInstalled { volt, icon });
+    }
+
+    pub fn volt_installing(&self, volt: VoltInfo, error: String) {
+        self.notification(CoreNotification::VoltInstalling { volt, error });
+    }
+
+    pub fn volt_removing(&self, volt: VoltMetadata, error: String) {
+        self.notification(CoreNotification::VoltRemoving { volt, error });
+    }
+
+    pub fn volt_removed(&self, volt: VoltInfo, only_installing: bool) {
+        self.notification(CoreNotification::VoltRemoved {
+            volt,
+            only_installing,
+        });
+    }
+
+    pub fn log(&self, level: log::Level, message: String) {
+        self.notification(CoreNotification::Log {
+            level: level.as_str().to_string(),
+            message,
+        });
+    }
+
+    pub fn publish_diagnostics(&self, diagnostics: PublishDiagnosticsParams) {
+        self.notification(CoreNotification::PublishDiagnostics { diagnostics });
+    }
+
+    pub fn work_done_progress(&self, progress: ProgressParams) {
+        self.notification(CoreNotification::WorkDoneProgress { progress });
+    }
+
+    pub fn show_message(&self, title: String, message: ShowMessageParams) {
+        self.notification(CoreNotification::ShowMessage { title, message });
+    }
+
+    pub fn log_message(&self, message: LogMessageParams) {
+        self.notification(CoreNotification::LogMessage { message });
+    }
+
+    pub fn close_terminal(&self, term_id: TermId) {
+        self.notification(CoreNotification::CloseTerminal { term_id });
+    }
+
+    pub fn update_terminal(&self, term_id: TermId, content: Vec<u8>) {
+        self.notification(CoreNotification::UpdateTerminal { term_id, content });
+    }
+
+    pub fn home_dir(&self, path: PathBuf) {
+        self.notification(CoreNotification::HomeDir { path });
+    }
+}
+
+impl Default for CoreRpcHandler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/lapce-rpc/src/file.rs b/lapce-rpc/src/file.rs
index 152fbba7bf..53fb9a96a9 100644
--- a/lapce-rpc/src/file.rs
+++ b/lapce-rpc/src/file.rs
@@ -1,5 +1,5 @@
 use std::{
-    cmp::{self, Ordering},
+    cmp::{Ord, Ordering, PartialOrd},
     collections::HashMap,
     path::{Path, PathBuf},
 };
@@ -16,98 +16,92 @@ pub struct FileNodeItem {
     pub children_open_count: usize,
 }
 
-impl std::cmp::PartialOrd for FileNodeItem {
-    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
-        let self_dir = self.is_dir;
-        let other_dir = other.is_dir;
-        if self_dir && !other_dir {
-            return Some(cmp::Ordering::Less);
-        }
-        if !self_dir && other_dir {
-            return Some(cmp::Ordering::Greater);
+impl PartialOrd for FileNodeItem {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (self.is_dir, other.is_dir) {
+            (true, false) => return Some(Ordering::Less),
+            (false, true) => return Some(Ordering::Greater),
+            _ => {}
         }
 
-        let self_file_name = self.path_buf.file_name()?.to_str()?.to_lowercase();
-        let other_file_name = other.path_buf.file_name()?.to_str()?.to_lowercase();
-        if self_file_name.starts_with('.') && !other_file_name.starts_with('.') {
-            return Some(cmp::Ordering::Less);
-        }
-        if !self_file_name.starts_with('.') && other_file_name.starts_with('.') {
-            return Some(cmp::Ordering::Greater);
-        }
-        self_file_name.partial_cmp(&other_file_name)
+        let self_file_name = self.path_buf.file_name()?.to_str()?;
+        let other_file_name = other.path_buf.file_name()?.to_str()?;
+
+        // TODO(dbuga): it would be nicer if human_sort had a `eq_ignore_ascii_case` function.
+        Some(human_sort::compare(
+            &self_file_name.to_lowercase(),
+            &other_file_name.to_lowercase(),
+        ))
+    }
+}
+
+impl Ord for FileNodeItem {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.partial_cmp(other).unwrap()
     }
 }
 
 impl FileNodeItem {
     pub fn sorted_children(&self) -> Vec<&FileNodeItem> {
-        let mut children = self
-            .children
-            .iter()
-            .map(|(_, item)| item)
-            .collect::<Vec<&FileNodeItem>>();
-        children.sort_by(|a, b| match (a.is_dir, b.is_dir) {
-            (true, true) => a
-                .path_buf
-                .to_str()
-                .unwrap()
-                .cmp(b.path_buf.to_str().unwrap()),
-            (true, false) => Ordering::Less,
-            (false, true) => Ordering::Greater,
-            (false, false) => a
-                .path_buf
-                .to_str()
-                .unwrap()
-                .cmp(b.path_buf.to_str().unwrap()),
-        });
+        let mut children = self.children.values().collect::<Vec<&FileNodeItem>>();
+        children.sort();
         children
     }
 
     pub fn sorted_children_mut(&mut self) -> Vec<&mut FileNodeItem> {
         let mut children = self
             .children
-            .iter_mut()
-            .map(|(_, item)| item)
+            .values_mut()
             .collect::<Vec<&mut FileNodeItem>>();
-        children.sort_by(|a, b| match (a.is_dir, b.is_dir) {
-            (true, true) => a
-                .path_buf
-                .to_str()
-                .unwrap()
-                .cmp(b.path_buf.to_str().unwrap()),
-            (true, false) => Ordering::Less,
-            (false, true) => Ordering::Greater,
-            (false, false) => a
-                .path_buf
-                .to_str()
-                .unwrap()
-                .cmp(b.path_buf.to_str().unwrap()),
-        });
+        children.sort();
         children
     }
 
-    pub fn get_file_node(&self, path: &Path) -> Option<&FileNodeItem> {
-        let path_buf = self.path_buf.clone();
-        let path = path.strip_prefix(&self.path_buf).ok()?;
-        let ancestors = path.ancestors().collect::<Vec<&Path>>();
+    /// Returns an iterator over the ancestors of `path`, starting with the first decendant of `prefix`.
+    ///
+    /// # Example:
+    /// (ignored because the function is private but I promise this passes)
+    /// ```rust,ignore
+    /// # use lapce_rpc::file::FileNodeItem;
+    /// # use std::path::{Path, PathBuf};
+    /// # use std::collections::HashMap;
+    /// #
+    /// let node_item = FileNodeItem {
+    ///     path_buf: PathBuf::from("/pre/fix"),
+    ///     // ...
+    /// #    is_dir: true,
+    /// #    read: false,
+    /// #    open: false,
+    /// #    children: HashMap::new(),
+    /// #    children_open_count: 0,
+    ///};
+    /// let mut iter = node_item.ancestors_rev(Path::new("/pre/fix/foo/bar")).unwrap();
+    /// assert_eq!(Some(Path::new("/pre/fix/foo")), iter.next());
+    /// assert_eq!(Some(Path::new("/pre/fix/foo/bar")), iter.next());
+    /// ```
+    fn ancestors_rev<'a>(
+        &self,
+        path: &'a Path,
+    ) -> Option<impl Iterator<Item = &'a Path>> {
+        let take = if let Ok(suffix) = path.strip_prefix(&self.path_buf) {
+            suffix.components().count()
+        } else {
+            return None;
+        };
+
+        #[allow(clippy::needless_collect)] // Ancestors is not reversible
+        let ancestors = path.ancestors().take(take).collect::<Vec<&Path>>();
+        Some(ancestors.into_iter().rev())
+    }
 
-        let mut node = Some(self);
-        for p in ancestors[..ancestors.len() - 1].iter().rev() {
-            node = Some(node?.children.get(&path_buf.join(p))?);
-        }
-        node
+    pub fn get_file_node(&self, path: &Path) -> Option<&FileNodeItem> {
+        self.ancestors_rev(path)?
+            .try_fold(self, |node, path| node.children.get(path))
     }
 
     pub fn get_file_node_mut(&mut self, path: &Path) -> Option<&mut FileNodeItem> {
-        let path_buf = self.path_buf.clone();
-        let path = path.strip_prefix(&self.path_buf).ok()?;
-        let ancestors = path.ancestors().collect::<Vec<&Path>>();
-
-        let mut node = Some(self);
-        for p in ancestors[..ancestors.len() - 1].iter().rev() {
-            node = Some(node?.children.get_mut(&path_buf.join(p))?);
-        }
-        node
+        self.ancestors_rev(path)?
+            .try_fold(self, |node, path| node.children.get_mut(path))
     }
 
     pub fn remove_child(&mut self, path: &Path) -> Option<FileNodeItem> {
@@ -161,15 +155,14 @@ impl FileNodeItem {
     pub fn update_node_count(&mut self, path: &Path) -> Option<()> {
         let node = self.get_file_node_mut(path)?;
         if node.is_dir {
-            if node.open {
-                node.children_open_count = node
-                    .children
-                    .iter()
-                    .map(|(_, item)| item.children_open_count + 1)
-                    .sum::<usize>();
+            node.children_open_count = if node.open {
+                node.children
+                    .values()
+                    .map(|item| item.children_open_count + 1)
+                    .sum::<usize>()
             } else {
-                node.children_open_count = 0;
-            }
+                0
+            };
         }
         None
     }
diff --git a/lapce-rpc/src/lib.rs b/lapce-rpc/src/lib.rs
index 846b11f6cf..a4501564d8 100644
--- a/lapce-rpc/src/lib.rs
+++ b/lapce-rpc/src/lib.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::manual_clamp)]
+
 pub mod buffer;
 pub mod core;
 pub mod counter;
@@ -6,238 +8,24 @@ mod parse;
 pub mod plugin;
 pub mod proxy;
 pub mod source_control;
-mod stdio;
+pub mod stdio;
 pub mod style;
 pub mod terminal;
 
-use std::collections::HashMap;
-use std::io::stdin;
-use std::io::stdout;
-use std::io::BufReader;
-use std::sync::atomic::AtomicU64;
-use std::sync::atomic::Ordering;
-use std::sync::Arc;
-
-use anyhow::Result;
-use crossbeam_channel::{Receiver, Sender};
-use parking_lot::Mutex;
-pub use parse::Call;
-pub use parse::RequestId;
-pub use parse::RpcObject;
-use serde::de::DeserializeOwned;
-use serde_json::json;
-use serde_json::Value;
-
+pub use parse::{Call, RequestId, RpcObject};
+use serde::{Deserialize, Serialize};
 pub use stdio::stdio_transport;
 
-pub fn stdio() -> (Sender<Value>, Receiver<Value>) {
-    let stdout = stdout();
-    let stdin = BufReader::new(stdin());
-    let (writer_sender, writer_receiver) = crossbeam_channel::unbounded();
-    let (reader_sender, reader_receiver) = crossbeam_channel::unbounded();
-    stdio::stdio_transport(stdout, writer_receiver, stdin, reader_sender);
-    (writer_sender, reader_receiver)
-}
-
-pub trait Callback: Send {
-    fn call(self: Box<Self>, result: Result<Value, Value>);
-}
-
-impl<F: Send + FnOnce(Result<Value, Value>)> Callback for F {
-    fn call(self: Box<F>, result: Result<Value, Value>) {
-        (*self)(result)
-    }
-}
-
-enum ResponseHandler {
-    Chan(Sender<Result<Value, Value>>),
-    Callback(Box<dyn Callback>),
-}
-
-impl ResponseHandler {
-    fn invoke(self, result: Result<Value, Value>) {
-        match self {
-            ResponseHandler::Chan(tx) => {
-                let _ = tx.send(result);
-            }
-            ResponseHandler::Callback(f) => f.call(result),
-        }
-    }
-}
-
-#[derive(PartialEq)]
-pub enum ControlFlow {
-    Continue,
-    Exit,
-}
-
-pub trait Handler {
-    type Notification: DeserializeOwned;
-    type Request: DeserializeOwned;
-
-    fn handle_notification(&mut self, rpc: Self::Notification) -> ControlFlow;
-    fn handle_request(&mut self, rpc: Self::Request) -> Result<Value, Value>;
-}
-
-#[derive(Clone)]
-pub struct RpcHandler {
-    sender: Sender<Value>,
-    id: Arc<AtomicU64>,
-    pending: Arc<Mutex<HashMap<u64, ResponseHandler>>>,
+#[derive(Debug)]
+pub enum RpcMessage<Req, Notif, Resp> {
+    Request(RequestId, Req),
+    Response(RequestId, Resp),
+    Notification(Notif),
+    Error(RequestId, RpcError),
 }
 
-impl RpcHandler {
-    pub fn new(sender: Sender<Value>) -> Self {
-        Self {
-            sender,
-            id: Arc::new(AtomicU64::new(0)),
-            pending: Arc::new(Mutex::new(HashMap::new())),
-        }
-    }
-
-    pub fn mainloop<H>(&mut self, receiver: Receiver<Value>, handler: &mut H)
-    where
-        H: Handler,
-    {
-        for msg in receiver {
-            let rpc: RpcObject = msg.into();
-            if rpc.is_response() {
-                let id = rpc.get_id().unwrap();
-                match rpc.into_response() {
-                    Ok(resp) => {
-                        self.handle_response(id, resp);
-                    }
-                    Err(msg) => {
-                        self.handle_response(id, Err(json!(msg)));
-                    }
-                }
-            } else {
-                match rpc.into_rpc::<H::Notification, H::Request>() {
-                    Ok(Call::Request(id, request)) => {
-                        let result = handler.handle_request(request);
-                        self.respond(id, result);
-                    }
-                    Ok(Call::Notification(notification)) => {
-                        if handler.handle_notification(notification)
-                            == ControlFlow::Exit
-                        {
-                            return;
-                        }
-                    }
-                    Err(_e) => {}
-                }
-            }
-        }
-    }
-
-    pub fn send_rpc_notification(&self, method: &str, params: &Value) {
-        if let Err(_e) = self.sender.send(json!({
-            "method": method,
-            "params": params,
-        })) {}
-    }
-
-    fn send_rpc_request_common(
-        &self,
-        method: &str,
-        params: &Value,
-        rh: ResponseHandler,
-    ) {
-        let id = self.id.fetch_add(1, Ordering::Relaxed);
-        {
-            let mut pending = self.pending.lock();
-            pending.insert(id, rh);
-        }
-        if let Err(_e) = self.sender.send(json!({
-            "id": id,
-            "method": method,
-            "params": params,
-        })) {
-            let mut pending = self.pending.lock();
-            if let Some(rh) = pending.remove(&id) {
-                rh.invoke(Err(json!("io error")));
-            }
-        }
-    }
-
-    fn send_rpc_request_value_common<T: serde::Serialize>(
-        &self,
-        request: T,
-        rh: ResponseHandler,
-    ) {
-        let id = self.id.fetch_add(1, Ordering::Relaxed);
-        {
-            let mut pending = self.pending.lock();
-            pending.insert(id, rh);
-        }
-        let mut request = serde_json::to_value(request).unwrap();
-        request
-            .as_object_mut()
-            .unwrap()
-            .insert("id".to_string(), json!(id));
-
-        if let Err(_e) = self.sender.send(request) {
-            let mut pending = self.pending.lock();
-            if let Some(rh) = pending.remove(&id) {
-                rh.invoke(Err(json!("io error")));
-            }
-        }
-    }
-
-    pub fn send_rpc_request_value<T: serde::Serialize>(
-        &self,
-        request: T,
-    ) -> Result<Value, Value> {
-        let (tx, rx) = crossbeam_channel::bounded(1);
-        self.send_rpc_request_value_common(request, ResponseHandler::Chan(tx));
-        rx.recv().unwrap_or_else(|_| Err(json!("io error")))
-    }
-
-    pub fn send_rpc_request_value_async<T: serde::Serialize>(
-        &self,
-        request: T,
-        f: Box<dyn Callback>,
-    ) {
-        self.send_rpc_request_value_common(request, ResponseHandler::Callback(f));
-    }
-
-    pub fn send_rpc_request(
-        &self,
-        method: &str,
-        params: &Value,
-    ) -> Result<Value, Value> {
-        let (tx, rx) = crossbeam_channel::bounded(1);
-        self.send_rpc_request_common(method, params, ResponseHandler::Chan(tx));
-        rx.recv().unwrap_or_else(|_| Err(json!("io error")))
-    }
-
-    pub fn send_rpc_request_async(
-        &self,
-        method: &str,
-        params: &Value,
-        f: Box<dyn Callback>,
-    ) {
-        self.send_rpc_request_common(method, params, ResponseHandler::Callback(f));
-    }
-
-    fn handle_response(&self, id: u64, resp: Result<Value, Value>) {
-        let handler = {
-            let mut pending = self.pending.lock();
-            pending.remove(&id)
-        };
-        if let Some(responsehandler) = handler {
-            responsehandler.invoke(resp)
-        }
-    }
-
-    fn respond(&self, id: u64, result: Result<Value, Value>) {
-        let mut response = json!({ "id": id });
-        match result {
-            Ok(result) => response["result"] = result,
-            Err(error) => response["error"] = json!(error),
-        };
-
-        #[allow(deprecated)]
-        let _ = self.sender.send(response);
-    }
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RpcError {
+    pub code: i64,
+    pub message: String,
 }
diff --git a/lapce-rpc/src/parse.rs b/lapce-rpc/src/parse.rs
index f147cf0a29..b9ceee2395 100644
--- a/lapce-rpc/src/parse.rs
+++ b/lapce-rpc/src/parse.rs
@@ -7,7 +7,7 @@ pub struct RpcObject(pub Value);
 
 pub type RequestId = u64;
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 /// An RPC call, which may be either a notification or a request.
 pub enum Call<N, R> {
     /// An id and an RPC Request
diff --git a/lapce-rpc/src/plugin.rs b/lapce-rpc/src/plugin.rs
index 918da51b1f..031b9c9fd1 100644
--- a/lapce-rpc/src/plugin.rs
+++ b/lapce-rpc/src/plugin.rs
@@ -1,29 +1,237 @@
-use std::path::PathBuf;
+use core::fmt;
+use std::{collections::HashMap, path::PathBuf};
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-#[derive(Eq, PartialEq, Hash, Clone, Debug, Serialize, Deserialize)]
+use crate::counter::Counter;
+
+#[derive(Eq, PartialEq, Hash, Clone, Copy, Debug, Serialize, Deserialize)]
 pub struct PluginId(pub u64);
 
+impl PluginId {
+    pub fn next() -> Self {
+        static PLUGIN_ID_COUNTER: Counter = Counter::new();
+        Self(PLUGIN_ID_COUNTER.next())
+    }
+}
+
 #[derive(Deserialize, Clone, Debug, Serialize)]
+pub struct PluginConfiguration {
+    #[serde(rename(deserialize = "type"))]
+    pub kind: String,
+    pub default: Value,
+    pub description: String,
+}
+
+#[derive(Deserialize, Clone, Debug, Serialize, PartialEq, Eq)]
+pub struct VoltInfo {
+    pub name: String,
+    pub version: String,
+    pub display_name: String,
+    pub author: String,
+    pub description: String,
+    pub repository: Option<String>,
+    pub wasm: bool,
+    pub updated_at_ts: i64,
+}
+
+impl VoltInfo {
+    pub fn id(&self) -> VoltID {
+        VoltID::from(self)
+    }
+}
+
+#[derive(Deserialize, Clone, Debug, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct VoltActivation {
+    pub language: Option<Vec<String>>,
+    pub workspace_contains: Option<Vec<String>>,
+}
+
+#[derive(Deserialize, Clone, Debug, Serialize, PartialEq, Eq)]
+pub struct VoltConfig {
+    pub default: Value,
+    pub description: String,
+}
+
+#[derive(Deserialize, Clone, Debug, Serialize, PartialEq, Eq)]
 #[serde(rename_all = "kebab-case")]
-pub struct PluginDescription {
+pub struct VoltMetadata {
     pub name: String,
     pub version: String,
     pub display_name: String,
     pub author: String,
     pub description: String,
-    pub repository: String,
+    pub icon: Option<String>,
+    pub repository: Option<String>,
     pub wasm: Option<String>,
-    pub themes: Option<Vec<String>>,
+    pub color_themes: Option<Vec<String>>,
+    pub icon_themes: Option<Vec<String>>,
     pub dir: Option<PathBuf>,
-    pub configuration: Option<Value>,
+    pub activation: Option<VoltActivation>,
+    pub config: Option<HashMap<String, VoltConfig>>,
 }
 
-#[derive(Serialize, Clone)]
-pub struct PluginInfo {
-    pub arch: String,
-    pub os: String,
-    pub configuration: Option<Value>,
+impl VoltMetadata {
+    pub fn id(&self) -> VoltID {
+        VoltID::from(self)
+    }
+
+    pub fn info(&self) -> VoltInfo {
+        VoltInfo {
+            name: self.name.clone(),
+            version: self.version.clone(),
+            display_name: self.display_name.clone(),
+            author: self.author.clone(),
+            description: self.description.clone(),
+            repository: self.repository.clone(),
+            wasm: self.wasm.is_some(),
+            updated_at_ts: 0,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
+pub struct VoltID {
+    pub author: String,
+    pub name: String,
+}
+
+impl fmt::Display for VoltID {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}.{}", self.author, self.name)
+    }
+}
+
+impl From<VoltMetadata> for VoltID {
+    fn from(volt: VoltMetadata) -> Self {
+        Self {
+            author: volt.author,
+            name: volt.name,
+        }
+    }
+}
+
+impl From<&VoltMetadata> for VoltID {
+    fn from(volt: &VoltMetadata) -> Self {
+        Self {
+            author: volt.author.clone(),
+            name: volt.name.clone(),
+        }
+    }
+}
+
+impl From<VoltInfo> for VoltID {
+    fn from(volt: VoltInfo) -> Self {
+        Self {
+            author: volt.author,
+            name: volt.name,
+        }
+    }
+}
+
+impl From<&VoltInfo> for VoltID {
+    fn from(volt: &VoltInfo) -> Self {
+        Self {
+            author: volt.author.clone(),
+            name: volt.name.clone(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{VoltID, VoltInfo, VoltMetadata};
+
+    #[test]
+    fn test_volt_metadata_id() {
+        let volt_metadata = VoltMetadata {
+            name: "plugin".to_string(),
+            version: "0.1".to_string(),
+            display_name: "Plugin".to_string(),
+            author: "Author".to_string(),
+            description: "Useful plugin".to_string(),
+            icon: None,
+            repository: None,
+            wasm: None,
+            color_themes: None,
+            icon_themes: None,
+            dir: std::env::current_dir().unwrap().canonicalize().ok(),
+            activation: None,
+            config: None,
+        };
+        let volt_id = VoltID {
+            author: "Author".to_string(),
+            name: "plugin".to_string(),
+        };
+
+        assert_eq!(volt_metadata.id(), volt_id);
+        assert_eq!(
+            <VoltID as From<&VoltMetadata>>::from(&volt_metadata),
+            volt_id
+        );
+        assert_eq!(
+            <VoltID as From<VoltMetadata>>::from(volt_metadata.clone()),
+            volt_id
+        );
+        assert_eq!(
+            <&VoltMetadata as Into<VoltID>>::into(&volt_metadata),
+            volt_id
+        );
+        assert_eq!(<VoltMetadata as Into<VoltID>>::into(volt_metadata), volt_id);
+    }
+
+    #[test]
+    fn test_volt_metadata_info() {
+        let volt_metadata = VoltMetadata {
+            name: "plugin".to_string(),
+            version: "0.1".to_string(),
+            display_name: "Plugin".to_string(),
+            author: "Author".to_string(),
+            description: "Useful plugin".to_string(),
+            icon: None,
+            repository: None,
+            wasm: None,
+            color_themes: None,
+            icon_themes: None,
+            dir: std::env::current_dir().unwrap().canonicalize().ok(),
+            activation: None,
+            config: None,
+        };
+        let volt_info = VoltInfo {
+            name: "plugin".to_string(),
+            version: "0.1".to_string(),
+            display_name: "Plugin".to_string(),
+            author: "Author".to_string(),
+            description: "Useful plugin".to_string(),
+            repository: None,
+            wasm: false,
+            updated_at_ts: 0,
+        };
+        assert_eq!(volt_metadata.info(), volt_info);
+    }
+
+    #[test]
+    fn test_volt_info_id() {
+        let volt_info = VoltInfo {
+            name: "plugin".to_string(),
+            version: "0.1".to_string(),
+            display_name: "Plugin".to_string(),
+            author: "Author".to_string(),
+            description: "Useful plugin".to_string(),
+            repository: None,
+            wasm: false,
+            updated_at_ts: 0,
+        };
+        let volt_id = VoltID {
+            author: "Author".to_string(),
+            name: "plugin".to_string(),
+        };
+        assert_eq!(volt_info.id(), volt_id);
+        assert_eq!(<VoltID as From<&VoltInfo>>::from(&volt_info), volt_id);
+        assert_eq!(<VoltID as From<VoltInfo>>::from(volt_info.clone()), volt_id);
+        assert_eq!(<&VoltInfo as Into<VoltID>>::into(&volt_info), volt_id);
+        assert_eq!(<VoltInfo as Into<VoltID>>::into(volt_info), volt_id);
+    }
 }
diff --git a/lapce-rpc/src/proxy.rs b/lapce-rpc/src/proxy.rs
index 65ca13bd0a..f91489d476 100644
--- a/lapce-rpc/src/proxy.rs
+++ b/lapce-rpc/src/proxy.rs
@@ -1,34 +1,217 @@
-use std::{collections::HashMap, path::PathBuf};
+use std::{
+    collections::HashMap,
+    path::PathBuf,
+    sync::{
+        atomic::{AtomicU64, Ordering},
+        Arc,
+    },
+};
 
-use lsp_types::{CompletionItem, Position};
+use super::plugin::VoltID;
+use crossbeam_channel::{Receiver, Sender};
+use indexmap::IndexMap;
+use lapce_xi_rope::RopeDelta;
+use lsp_types::{
+    request::GotoTypeDefinitionResponse, CodeAction, CodeActionResponse,
+    CompletionItem, Diagnostic, DocumentSymbolResponse, GotoDefinitionResponse,
+    Hover, InlayHint, Location, Position, PrepareRenameResponse, SelectionRange,
+    SymbolInformation, TextDocumentItem, TextEdit, WorkspaceEdit,
+};
+use parking_lot::Mutex;
 use serde::{Deserialize, Serialize};
-use xi_rope::RopeDelta;
 
 use crate::{
-    buffer::BufferId, file::FileNodeItem, plugin::PluginDescription,
-    source_control::FileDiff, terminal::TermId,
+    buffer::BufferId,
+    file::FileNodeItem,
+    plugin::{PluginId, VoltInfo, VoltMetadata},
+    source_control::FileDiff,
+    style::SemanticStyles,
+    terminal::TermId,
+    RequestId, RpcError, RpcMessage,
 };
 
+#[allow(clippy::large_enum_variant)]
+pub enum ProxyRpc {
+    Request(RequestId, ProxyRequest),
+    Notification(ProxyNotification),
+    Shutdown,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(tag = "method", content = "params")]
+pub enum ProxyRequest {
+    NewBuffer {
+        buffer_id: BufferId,
+        path: PathBuf,
+    },
+    BufferHead {
+        path: PathBuf,
+    },
+    GlobalSearch {
+        pattern: String,
+        case_sensitive: bool,
+    },
+    CompletionResolve {
+        plugin_id: PluginId,
+        completion_item: Box<CompletionItem>,
+    },
+    CodeActionResolve {
+        plugin_id: PluginId,
+        action_item: Box<CodeAction>,
+    },
+    GetHover {
+        request_id: usize,
+        path: PathBuf,
+        position: Position,
+    },
+    GetSignature {
+        buffer_id: BufferId,
+        position: Position,
+    },
+    GetSelectionRange {
+        path: PathBuf,
+        positions: Vec<Position>,
+    },
+    GitGetRemoteFileUrl {
+        file: PathBuf,
+    },
+    GetReferences {
+        path: PathBuf,
+        position: Position,
+    },
+    GetDefinition {
+        request_id: usize,
+        path: PathBuf,
+        position: Position,
+    },
+    GetTypeDefinition {
+        request_id: usize,
+        path: PathBuf,
+        position: Position,
+    },
+    GetInlayHints {
+        path: PathBuf,
+    },
+    GetSemanticTokens {
+        path: PathBuf,
+    },
+    PrepareRename {
+        path: PathBuf,
+        position: Position,
+    },
+    Rename {
+        path: PathBuf,
+        position: Position,
+        new_name: String,
+    },
+    GetCodeActions {
+        path: PathBuf,
+        position: Position,
+        diagnostics: Vec<Diagnostic>,
+    },
+    GetDocumentSymbols {
+        path: PathBuf,
+    },
+    GetWorkspaceSymbols {
+        /// The search query
+        query: String,
+    },
+    GetDocumentFormatting {
+        path: PathBuf,
+    },
+    GetOpenFilesContent {},
+    GetFiles {
+        path: String,
+    },
+    ReadDir {
+        path: PathBuf,
+    },
+    Save {
+        rev: u64,
+        path: PathBuf,
+    },
+    SaveBufferAs {
+        buffer_id: BufferId,
+        path: PathBuf,
+        rev: u64,
+        content: String,
+    },
+    CreateFile {
+        path: PathBuf,
+    },
+    CreateDirectory {
+        path: PathBuf,
+    },
+    TrashPath {
+        path: PathBuf,
+    },
+    DuplicatePath {
+        existing_path: PathBuf,
+        new_path: PathBuf,
+    },
+    RenamePath {
+        from: PathBuf,
+        to: PathBuf,
+    },
+}
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 #[serde(tag = "method", content = "params")]
 pub enum ProxyNotification {
     Initialize {
-        workspace: PathBuf,
+        workspace: Option<PathBuf>,
+        disabled_volts: Vec<VoltID>,
+        plugin_configurations: HashMap<String, HashMap<String, serde_json::Value>>,
+        window_id: usize,
+        tab_id: usize,
+    },
+    OpenFileChanged {
+        path: PathBuf,
+    },
+    OpenPaths {
+        folders: Vec<PathBuf>,
+        files: Vec<PathBuf>,
     },
     Shutdown {},
+    Completion {
+        request_id: usize,
+        path: PathBuf,
+        input: String,
+        position: Position,
+    },
+    SignatureHelp {
+        request_id: usize,
+        path: PathBuf,
+        position: Position,
+    },
     Update {
-        buffer_id: BufferId,
+        path: PathBuf,
         delta: RopeDelta,
         rev: u64,
     },
+    UpdatePluginConfigs {
+        configs: HashMap<String, HashMap<String, serde_json::Value>>,
+    },
     NewTerminal {
         term_id: TermId,
         cwd: Option<PathBuf>,
         shell: String,
     },
-    InstallPlugin {
-        plugin: PluginDescription,
+    InstallVolt {
+        volt: VoltInfo,
+    },
+    RemoveVolt {
+        volt: VoltMetadata,
+    },
+    ReloadVolt {
+        volt: VoltMetadata,
+    },
+    DisableVolt {
+        volt: VoltInfo,
+    },
+    EnableVolt {
+        volt: VoltInfo,
     },
     GitCommit {
         message: String,
@@ -37,6 +220,11 @@ pub enum ProxyNotification {
     GitCheckout {
         branch: String,
     },
+    GitDiscardFilesChanges {
+        files: Vec<PathBuf>,
+    },
+    GitDiscardWorkspaceChanges {},
+    GitInit {},
     TerminalWrite {
         term_id: TermId,
         content: String,
@@ -54,74 +242,631 @@ pub enum ProxyNotification {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 #[serde(tag = "method", content = "params")]
-pub enum ProxyRequest {
-    NewBuffer {
-        buffer_id: BufferId,
-        path: PathBuf,
+pub enum ProxyResponse {
+    GitGetRemoteFileUrl {
+        file_url: String,
     },
-    BufferHead {
-        buffer_id: BufferId,
-        path: PathBuf,
+    NewBufferResponse {
+        content: String,
     },
-    GetCompletion {
-        request_id: usize,
-        buffer_id: BufferId,
-        position: Position,
+    BufferHeadResponse {
+        version: String,
+        content: String,
     },
-    GlobalSearch {
-        pattern: String,
+    ReadDirResponse {
+        items: HashMap<PathBuf, FileNodeItem>,
     },
-    CompletionResolve {
-        buffer_id: BufferId,
-        completion_item: Box<CompletionItem>,
+    CompletionResolveResponse {
+        item: Box<CompletionItem>,
     },
-    GetHover {
-        request_id: usize,
-        buffer_id: BufferId,
-        position: Position,
+    CodeActionResolveResponse {
+        item: Box<CodeAction>,
     },
-    GetSignature {
-        buffer_id: BufferId,
-        position: Position,
+    HoverResponse {
+        request_id: usize,
+        hover: Hover,
     },
-    GetReferences {
-        buffer_id: BufferId,
-        position: Position,
+    GetDefinitionResponse {
+        request_id: usize,
+        definition: GotoDefinitionResponse,
     },
-    GetDefinition {
+    GetTypeDefinition {
         request_id: usize,
-        buffer_id: BufferId,
-        position: Position,
+        definition: GotoTypeDefinitionResponse,
     },
-    GetCodeActions {
-        buffer_id: BufferId,
-        position: Position,
+    GetReferencesResponse {
+        references: Vec<Location>,
     },
-    GetDocumentSymbols {
-        buffer_id: BufferId,
+    GetCodeActionsResponse {
+        plugin_id: PluginId,
+        resp: CodeActionResponse,
+    },
+    GetFilesResponse {
+        items: Vec<PathBuf>,
     },
     GetDocumentFormatting {
-        buffer_id: BufferId,
+        edits: Vec<TextEdit>,
     },
-    GetFiles {
-        path: String,
+    GetDocumentSymbols {
+        resp: DocumentSymbolResponse,
     },
-    ReadDir {
-        path: PathBuf,
+    GetWorkspaceSymbols {
+        symbols: Vec<SymbolInformation>,
     },
-    Save {
-        rev: u64,
-        buffer_id: BufferId,
+    GetSelectionRange {
+        ranges: Vec<SelectionRange>,
     },
-    SaveBufferAs {
-        buffer_id: BufferId,
-        path: PathBuf,
-        rev: u64,
-        content: String,
+    GetInlayHints {
+        hints: Vec<InlayHint>,
+    },
+    GetSemanticTokens {
+        styles: SemanticStyles,
+    },
+    PrepareRename {
+        resp: PrepareRenameResponse,
+    },
+    Rename {
+        edit: WorkspaceEdit,
     },
+    GetOpenFilesContentResponse {
+        items: Vec<TextDocumentItem>,
+    },
+    GlobalSearchResponse {
+        #[allow(clippy::type_complexity)]
+        matches: IndexMap<PathBuf, Vec<(usize, (usize, usize), String)>>,
+    },
+    Success {},
+    SaveResponse {},
 }
 
+pub type ProxyMessage = RpcMessage<ProxyRequest, ProxyNotification, ProxyResponse>;
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ReadDirResponse {
     pub items: HashMap<PathBuf, FileNodeItem>,
 }
+
+pub trait ProxyCallback: Send + FnOnce(Result<ProxyResponse, RpcError>) {}
+
+impl<F: Send + FnOnce(Result<ProxyResponse, RpcError>)> ProxyCallback for F {}
+
+enum ResponseHandler {
+    Callback(Box<dyn ProxyCallback>),
+    Chan(Sender<Result<ProxyResponse, RpcError>>),
+}
+
+impl ResponseHandler {
+    fn invoke(self, result: Result<ProxyResponse, RpcError>) {
+        match self {
+            ResponseHandler::Callback(f) => f(result),
+            ResponseHandler::Chan(tx) => {
+                let _ = tx.send(result);
+            }
+        }
+    }
+}
+
+pub trait ProxyHandler {
+    fn handle_notification(&mut self, rpc: ProxyNotification);
+    fn handle_request(&mut self, id: RequestId, rpc: ProxyRequest);
+}
+
+#[derive(Clone)]
+pub struct ProxyRpcHandler {
+    tx: Sender<ProxyRpc>,
+    rx: Receiver<ProxyRpc>,
+    id: Arc<AtomicU64>,
+    pending: Arc<Mutex<HashMap<u64, ResponseHandler>>>,
+}
+
+impl ProxyRpcHandler {
+    pub fn new() -> Self {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        Self {
+            tx,
+            rx,
+            id: Arc::new(AtomicU64::new(0)),
+            pending: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    pub fn rx(&self) -> &Receiver<ProxyRpc> {
+        &self.rx
+    }
+
+    pub fn mainloop<H>(&self, handler: &mut H)
+    where
+        H: ProxyHandler,
+    {
+        use ProxyRpc::*;
+        for msg in &self.rx {
+            match msg {
+                Request(id, request) => {
+                    handler.handle_request(id, request);
+                }
+                Notification(notification) => {
+                    handler.handle_notification(notification);
+                }
+                Shutdown => {
+                    return;
+                }
+            }
+        }
+    }
+
+    fn request_common(&self, request: ProxyRequest, rh: ResponseHandler) {
+        let id = self.id.fetch_add(1, Ordering::Relaxed);
+
+        self.pending.lock().insert(id, rh);
+
+        let _ = self.tx.send(ProxyRpc::Request(id, request));
+    }
+
+    fn request(&self, request: ProxyRequest) -> Result<ProxyResponse, RpcError> {
+        let (tx, rx) = crossbeam_channel::bounded(1);
+        self.request_common(request, ResponseHandler::Chan(tx));
+        rx.recv().unwrap_or_else(|_| {
+            Err(RpcError {
+                code: 0,
+                message: "io error".to_string(),
+            })
+        })
+    }
+
+    pub fn request_async(
+        &self,
+        request: ProxyRequest,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_common(request, ResponseHandler::Callback(Box::new(f)))
+    }
+
+    pub fn handle_response(
+        &self,
+        id: RequestId,
+        result: Result<ProxyResponse, RpcError>,
+    ) {
+        let handler = { self.pending.lock().remove(&id) };
+        if let Some(handler) = handler {
+            handler.invoke(result);
+        }
+    }
+
+    pub fn notification(&self, notification: ProxyNotification) {
+        let _ = self.tx.send(ProxyRpc::Notification(notification));
+    }
+
+    pub fn git_init(&self) {
+        self.notification(ProxyNotification::GitInit {});
+    }
+
+    pub fn git_commit(&self, message: String, diffs: Vec<FileDiff>) {
+        self.notification(ProxyNotification::GitCommit { message, diffs });
+    }
+
+    pub fn git_checkout(&self, branch: String) {
+        self.notification(ProxyNotification::GitCheckout { branch });
+    }
+
+    pub fn install_volt(&self, volt: VoltInfo) {
+        self.notification(ProxyNotification::InstallVolt { volt });
+    }
+
+    pub fn reload_volt(&self, volt: VoltMetadata) {
+        self.notification(ProxyNotification::ReloadVolt { volt });
+    }
+
+    pub fn remove_volt(&self, volt: VoltMetadata) {
+        self.notification(ProxyNotification::RemoveVolt { volt });
+    }
+
+    pub fn disable_volt(&self, volt: VoltInfo) {
+        self.notification(ProxyNotification::DisableVolt { volt });
+    }
+
+    pub fn enable_volt(&self, volt: VoltInfo) {
+        self.notification(ProxyNotification::EnableVolt { volt });
+    }
+
+    pub fn shutdown(&self) {
+        self.notification(ProxyNotification::Shutdown {});
+        let _ = self.tx.send(ProxyRpc::Shutdown);
+    }
+
+    pub fn initialize(
+        &self,
+        workspace: Option<PathBuf>,
+        disabled_volts: Vec<VoltID>,
+        plugin_configurations: HashMap<String, HashMap<String, serde_json::Value>>,
+        window_id: usize,
+        tab_id: usize,
+    ) {
+        self.notification(ProxyNotification::Initialize {
+            workspace,
+            disabled_volts,
+            plugin_configurations,
+            window_id,
+            tab_id,
+        });
+    }
+
+    pub fn completion(
+        &self,
+        request_id: usize,
+        path: PathBuf,
+        input: String,
+        position: Position,
+    ) {
+        self.notification(ProxyNotification::Completion {
+            request_id,
+            path,
+            input,
+            position,
+        });
+    }
+
+    pub fn signature_help(
+        &self,
+        request_id: usize,
+        path: PathBuf,
+        position: Position,
+    ) {
+        self.notification(ProxyNotification::SignatureHelp {
+            request_id,
+            path,
+            position,
+        });
+    }
+
+    pub fn new_terminal(
+        &self,
+        term_id: TermId,
+        cwd: Option<PathBuf>,
+        shell: String,
+    ) {
+        self.notification(ProxyNotification::NewTerminal {
+            term_id,
+            cwd,
+            shell,
+        })
+    }
+
+    pub fn terminal_close(&self, term_id: TermId) {
+        self.notification(ProxyNotification::TerminalClose { term_id });
+    }
+
+    pub fn terminal_resize(&self, term_id: TermId, width: usize, height: usize) {
+        self.notification(ProxyNotification::TerminalResize {
+            term_id,
+            width,
+            height,
+        });
+    }
+
+    pub fn terminal_write(&self, term_id: TermId, content: &str) {
+        self.notification(ProxyNotification::TerminalWrite {
+            term_id,
+            content: content.to_string(),
+        });
+    }
+
+    pub fn new_buffer(
+        &self,
+        buffer_id: BufferId,
+        path: PathBuf,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::NewBuffer { buffer_id, path }, f);
+    }
+
+    pub fn get_buffer_head(
+        &self,
+        _buffer_id: BufferId,
+        path: PathBuf,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::BufferHead { path }, f);
+    }
+
+    pub fn create_file(&self, path: PathBuf, f: impl ProxyCallback + 'static) {
+        self.request_async(ProxyRequest::CreateFile { path }, f);
+    }
+
+    pub fn create_directory(&self, path: PathBuf, f: impl ProxyCallback + 'static) {
+        self.request_async(ProxyRequest::CreateDirectory { path }, f);
+    }
+
+    pub fn trash_path(&self, path: PathBuf, f: impl ProxyCallback + 'static) {
+        self.request_async(ProxyRequest::TrashPath { path }, f);
+    }
+
+    pub fn duplicate_path(
+        &self,
+        existing_path: PathBuf,
+        new_path: PathBuf,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(
+            ProxyRequest::DuplicatePath {
+                existing_path,
+                new_path,
+            },
+            f,
+        );
+    }
+
+    pub fn rename_path(
+        &self,
+        from: PathBuf,
+        to: PathBuf,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::RenamePath { from, to }, f);
+    }
+
+    pub fn save_buffer_as(
+        &self,
+        buffer_id: BufferId,
+        path: PathBuf,
+        rev: u64,
+        content: String,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(
+            ProxyRequest::SaveBufferAs {
+                buffer_id,
+                path,
+                rev,
+                content,
+            },
+            f,
+        );
+    }
+
+    pub fn global_search(
+        &self,
+        pattern: String,
+        case_sensitive: bool,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(
+            ProxyRequest::GlobalSearch {
+                pattern,
+                case_sensitive,
+            },
+            f,
+        );
+    }
+
+    pub fn save(&self, rev: u64, path: PathBuf, f: impl ProxyCallback + 'static) {
+        self.request_async(ProxyRequest::Save { rev, path }, f);
+    }
+
+    pub fn get_files(&self, f: impl ProxyCallback + 'static) {
+        self.request_async(
+            ProxyRequest::GetFiles {
+                path: "path".into(),
+            },
+            f,
+        );
+    }
+
+    pub fn get_open_files_content(&self) -> Result<ProxyResponse, RpcError> {
+        self.request(ProxyRequest::GetOpenFilesContent {})
+    }
+
+    pub fn read_dir(&self, path: PathBuf, f: impl ProxyCallback + 'static) {
+        self.request_async(ProxyRequest::ReadDir { path }, f);
+    }
+
+    pub fn completion_resolve(
+        &self,
+        plugin_id: PluginId,
+        completion_item: CompletionItem,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(
+            ProxyRequest::CompletionResolve {
+                plugin_id,
+                completion_item: Box::new(completion_item),
+            },
+            f,
+        );
+    }
+
+    pub fn code_action_resolve(
+        &self,
+        action_item: CodeAction,
+        plugin_id: PluginId,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(
+            ProxyRequest::CodeActionResolve {
+                action_item: Box::new(action_item),
+                plugin_id,
+            },
+            f,
+        );
+    }
+
+    pub fn get_hover(
+        &self,
+        request_id: usize,
+        path: PathBuf,
+        position: Position,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(
+            ProxyRequest::GetHover {
+                request_id,
+                path,
+                position,
+            },
+            f,
+        );
+    }
+
+    pub fn get_definition(
+        &self,
+        request_id: usize,
+        path: PathBuf,
+        position: Position,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(
+            ProxyRequest::GetDefinition {
+                request_id,
+                path,
+                position,
+            },
+            f,
+        );
+    }
+
+    pub fn get_type_definition(
+        &self,
+        request_id: usize,
+        path: PathBuf,
+        position: Position,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(
+            ProxyRequest::GetTypeDefinition {
+                request_id,
+                path,
+                position,
+            },
+            f,
+        );
+    }
+
+    pub fn get_references(
+        &self,
+        path: PathBuf,
+        position: Position,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::GetReferences { path, position }, f);
+    }
+
+    pub fn get_code_actions(
+        &self,
+        path: PathBuf,
+        position: Position,
+        diagnostics: Vec<Diagnostic>,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(
+            ProxyRequest::GetCodeActions {
+                path,
+                position,
+                diagnostics,
+            },
+            f,
+        );
+    }
+
+    pub fn get_document_formatting(
+        &self,
+        path: PathBuf,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::GetDocumentFormatting { path }, f);
+    }
+
+    pub fn get_semantic_tokens(
+        &self,
+        path: PathBuf,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::GetSemanticTokens { path }, f);
+    }
+
+    pub fn get_document_symbols(
+        &self,
+        path: PathBuf,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::GetDocumentSymbols { path }, f);
+    }
+
+    pub fn get_workspace_symbols(
+        &self,
+        query: String,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::GetWorkspaceSymbols { query }, f);
+    }
+
+    pub fn prepare_rename(
+        &self,
+        path: PathBuf,
+        position: Position,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::PrepareRename { path, position }, f);
+    }
+
+    pub fn git_get_remote_file_url(
+        &self,
+        file: PathBuf,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::GitGetRemoteFileUrl { file }, f);
+    }
+
+    pub fn rename(
+        &self,
+        path: PathBuf,
+        position: Position,
+        new_name: String,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(
+            ProxyRequest::Rename {
+                path,
+                position,
+                new_name,
+            },
+            f,
+        );
+    }
+
+    pub fn get_inlay_hints(&self, path: PathBuf, f: impl ProxyCallback + 'static) {
+        self.request_async(ProxyRequest::GetInlayHints { path }, f);
+    }
+
+    pub fn update(&self, path: PathBuf, delta: RopeDelta, rev: u64) {
+        self.notification(ProxyNotification::Update { path, delta, rev });
+    }
+
+    pub fn update_plugin_configs(
+        &self,
+        configs: HashMap<String, HashMap<String, serde_json::Value>>,
+    ) {
+        self.notification(ProxyNotification::UpdatePluginConfigs { configs });
+    }
+
+    pub fn git_discard_files_changes(&self, files: Vec<PathBuf>) {
+        self.notification(ProxyNotification::GitDiscardFilesChanges { files });
+    }
+
+    pub fn git_discard_workspace_changes(&self) {
+        self.notification(ProxyNotification::GitDiscardWorkspaceChanges {});
+    }
+
+    pub fn get_selection_range(
+        &self,
+        path: PathBuf,
+        positions: Vec<Position>,
+        f: impl ProxyCallback + 'static,
+    ) {
+        self.request_async(ProxyRequest::GetSelectionRange { path, positions }, f);
+    }
+}
+
+impl Default for ProxyRpcHandler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/lapce-rpc/src/source_control.rs b/lapce-rpc/src/source_control.rs
index 32e782b99d..3ec2522305 100644
--- a/lapce-rpc/src/source_control.rs
+++ b/lapce-rpc/src/source_control.rs
@@ -2,14 +2,14 @@ use std::path::PathBuf;
 
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 pub struct DiffInfo {
     pub head: String,
     pub branches: Vec<String>,
     pub diffs: Vec<FileDiff>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub enum FileDiff {
     Modified(PathBuf),
     Added(PathBuf),
diff --git a/lapce-rpc/src/stdio.rs b/lapce-rpc/src/stdio.rs
index fec4410f19..4d0ebfed43 100644
--- a/lapce-rpc/src/stdio.rs
+++ b/lapce-rpc/src/stdio.rs
@@ -1,25 +1,36 @@
-use anyhow::Result;
-use crossbeam_channel::{Receiver, Sender};
-use serde_json::Value;
 use std::{
     io::{self, BufRead, Write},
     thread,
 };
 
-pub fn stdio_transport<W, R>(
+use anyhow::Result;
+use crossbeam_channel::{Receiver, Sender};
+use serde::{de::DeserializeOwned, Serialize};
+use serde_json::{json, Value};
+
+use crate::{RpcError, RpcMessage, RpcObject};
+
+pub fn stdio_transport<W, R, Req1, Notif1, Resp1, Req2, Notif2, Resp2>(
     mut writer: W,
-    writer_receiver: Receiver<Value>,
+    writer_receiver: Receiver<RpcMessage<Req2, Notif2, Resp2>>,
     mut reader: R,
-    reader_sender: Sender<Value>,
+    reader_sender: Sender<RpcMessage<Req1, Notif1, Resp1>>,
 ) where
     W: 'static + Write + Send,
     R: 'static + BufRead + Send,
+    Req1: 'static + Serialize + DeserializeOwned + Send + Sync,
+    Notif1: 'static + Serialize + DeserializeOwned + Send + Sync,
+    Resp1: 'static + Serialize + DeserializeOwned + Send + Sync,
+    Req2: 'static + Serialize + DeserializeOwned + Send + Sync,
+    Notif2: 'static + Serialize + DeserializeOwned + Send + Sync,
+    Resp2: 'static + Serialize + DeserializeOwned + Send + Sync,
 {
-    thread::spawn(move || -> Result<()> {
-        writer_receiver
-            .into_iter()
-            .try_for_each(|it| write_msg(&mut writer, &it))?;
-        Ok(())
+    thread::spawn(move || {
+        for value in writer_receiver {
+            if write_msg(&mut writer, value).is_err() {
+                return;
+            };
+        }
     });
     thread::spawn(move || -> Result<()> {
         loop {
@@ -29,22 +40,84 @@ pub fn stdio_transport<W, R>(
     });
 }
 
-fn write_msg<W>(out: &mut W, msg: &Value) -> io::Result<()>
+pub fn write_msg<W, Req, Notif, Resp>(
+    out: &mut W,
+    msg: RpcMessage<Req, Notif, Resp>,
+) -> io::Result<()>
 where
     W: Write,
+    Req: Serialize,
+    Notif: Serialize,
+    Resp: Serialize,
 {
-    let msg = format!("{}\n", serde_json::to_string(msg)?);
+    let value = match msg {
+        RpcMessage::Request(id, req) => {
+            let mut msg = serde_json::to_value(&req)?;
+            msg.as_object_mut()
+                .ok_or(io::ErrorKind::NotFound)?
+                .insert("id".into(), id.into());
+            msg
+        }
+        RpcMessage::Response(id, resp) => {
+            json!({
+                "id": id,
+                "result": resp,
+            })
+        }
+        RpcMessage::Notification(n) => serde_json::to_value(n)?,
+        RpcMessage::Error(id, err) => {
+            json!({
+                "id": id,
+                "error": err,
+            })
+        }
+    };
+    let msg = format!("{}\n", serde_json::to_string(&value)?);
     out.write_all(msg.as_bytes())?;
     out.flush()?;
     Ok(())
 }
 
-fn read_msg<R>(inp: &mut R) -> io::Result<Value>
+pub fn read_msg<R, Req, Notif, Resp>(
+    inp: &mut R,
+) -> io::Result<RpcMessage<Req, Notif, Resp>>
 where
     R: BufRead,
+    Req: DeserializeOwned,
+    Notif: DeserializeOwned,
+    Resp: DeserializeOwned,
 {
     let mut buf = String::new();
     let _s = inp.read_line(&mut buf)?;
     let value: Value = serde_json::from_str(&buf)?;
-    Ok(value)
+    let object = RpcObject(value);
+    let is_response = object.is_response();
+    let msg = if is_response {
+        let id = object.get_id().ok_or(io::ErrorKind::NotFound)?;
+        let resp = object
+            .into_response()
+            .map_err(|_| io::ErrorKind::NotFound)?;
+        match resp {
+            Ok(value) => {
+                let resp: Resp = serde_json::from_value(value)?;
+                RpcMessage::Response(id, resp)
+            }
+            Err(value) => {
+                let err: RpcError = serde_json::from_value(value)?;
+                RpcMessage::Error(id, err)
+            }
+        }
+    } else {
+        match object.get_id() {
+            Some(id) => {
+                let req: Req = serde_json::from_value(object.0)?;
+                RpcMessage::Request(id, req)
+            }
+            None => {
+                let notif: Notif = serde_json::from_value(object.0)?;
+                RpcMessage::Notification(notif)
+            }
+        }
+    };
+    Ok(msg)
 }
diff --git a/lapce-rpc/src/style.rs b/lapce-rpc/src/style.rs
index ca94260499..29924e711e 100644
--- a/lapce-rpc/src/style.rs
+++ b/lapce-rpc/src/style.rs
@@ -1,4 +1,4 @@
-use std::{collections::HashMap, sync::Arc};
+use std::{collections::HashMap, path::PathBuf, sync::Arc};
 
 use serde::{Deserialize, Serialize};
 
@@ -11,7 +11,15 @@ pub struct LineStyle {
     pub style: Style,
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Style {
     pub fg_color: Option<String>,
 }
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct SemanticStyles {
+    pub rev: u64,
+    pub path: PathBuf,
+    pub len: usize,
+    pub styles: Vec<LineStyle>,
+}
diff --git a/lapce-ui/Cargo.toml b/lapce-ui/Cargo.toml
index 182711488e..a1afc8b696 100644
--- a/lapce-ui/Cargo.toml
+++ b/lapce-ui/Cargo.toml
@@ -1,117 +1,160 @@
 [package]
 name = "lapce-ui"
-version = "0.1.2"
-authors = ["Dongdong Zhou <dzhou121@gmail.com>"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
 
 [dependencies]
-image = "0.24"
-chrono = "0.4.19"
-log = "0.4.14"
+alacritty_terminal.workspace = true
+anyhow.workspace = true
+chrono.workspace = true
+clap.workspace = true
+hashbrown.workspace = true
+im.workspace = true
+include_dir.workspace = true
+indexmap.workspace = true
+itertools.workspace = true
+log.workspace = true
+once_cell.workspace = true
+rayon.workspace = true
+regex.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+smallvec.workspace = true
+toml_edit.workspace = true
+
+lsp-types.workspace = true
+
+lapce-xi-rope.workspace = true
+
+lapce-core.workspace = true
+lapce-data.workspace = true
+lapce-proxy.workspace = true
+lapce-rpc.workspace = true
+
+druid.workspace = true
+
+image = "0.24.3"
 fern = "0.6.0"
 Inflector = "0.11.4"
-rayon = "1.5.1"
-diff = "0.1.12"
-libloading = "0.7"
-flate2 = "1.0.22"
-hashbrown = "0.11.2"
-sled = "0.34.7"
-base64 = "0.13.0"
-alacritty_terminal = "0.16"
-config = "0.11"
-indexmap = "1.7.0"
-directories = "4.0.1"
-itertools = "0.10.1"
-unicode-width = "0.1.8"
-unicode-segmentation = "1.7.1"
-im = { version = "15.0.0", features = ["serde"] }
-crossbeam-channel = "0.5.0"
-crossbeam-utils = "0.8.4"
-regex = "1.5.6"
-jsonrpc-lite = "0.5.0"
-bit-vec = "0.5.0"
-parking_lot = { version = "0.11.0", features = ["deadlock_detection"] }
-include_dir = "0.6.0"
-anyhow = "1.0.32"
-strum = "0.24.0"
-strum_macros = "0.24"
-lazy_static = "1.4.0"
-serde = "1.0"
-serde_json = "1.0"
-notify = "5.0.0-pre.13"
-xi-rope = { git = "https://github.com/lapce/xi-editor", features = ["serde"] }
-xi-unicode = "0.3.0"
-fuzzy-matcher = "0.3.7"
-lsp-types = { version = "0.89.2", features = ["proposed"] }
-druid = { git = "https://github.com/lapce/druid", branch = "shell_opengl", features = [ "svg", "im", "serde", ] }
-# druid = { path = "../../druid/druid", features = ["svg", "im" , "serde"] }
-toml = { version = "0.5.8", features = ["preserve_order"] }
-structdesc = { git = "https://github.com/lapce/structdesc" }
-lapce-core = { path = "../lapce-core" }
-lapce-data = { path = "../lapce-data" }
-lapce-rpc = { path = "../lapce-rpc" }
+log-panics = { version = "2.1.0", features = ["with-backtrace"] }
+unicode-width = "0.1.10"
+open = "3.0.2" # bump when other deps using windows{,-sys} are bump'd
 
 [target.'cfg(windows)'.build-dependencies]
 winres = "0.1.12"
 
 [features]
-default = ["all-languages"]
+default = ["all-languages", "lapce-data/updater"]
+portable = ["lapce-data/portable"]
+
 # To build lapce with only some of the supported languages, for example:
 #
 #   cargo build --no-default-features -p lapce-ui \
-#     --features lang-rust,lang-toml,lang-md,lang-json
+#     --features lang-rust,lang-toml,lang-markdown,lang-json
 #
 all-languages = [
-    "lang-rust",
-    "lang-go",
-    "lang-javascript",
-    "lang-typescript",
-    "lang-python",
-    "lang-toml",
-    "lang-elixir",
-    "lang-php",
-    "lang-ruby",
+    "lang-bash",
     "lang-c",
+    "lang-clojure",
+    "lang-cmake",
     "lang-cpp",
-    "lang-json",
-    "lang-md",
-    "lang-html",
-    "lang-java",
+    "lang-csharp",
+    "lang-css",
+    "lang-d",
+    "lang-dart",
+    "lang-dockerfile",
+    "lang-elixir",
     "lang-elm",
-    "lang-swift",
-    "lang-ql",
-    "lang-haskell",
-    "lang-ocaml",
+    "lang-erlang",
     "lang-glimmer",
+    "lang-glsl",
+    "lang-go",
+    "lang-hare",
+    "lang-haskell",
     "lang-haxe",
     "lang-hcl",
+    "lang-html",
+    "lang-java",
+    "lang-javascript",
+    "lang-json",
+    "lang-julia",
+    "lang-kotlin",
+    "lang-latex",
+    "lang-lua",
+    "lang-markdown",
+    "lang-nix",
+    "lang-ocaml",
+    "lang-php",
+    "lang-prisma",
+    "lang-protobuf",
+    "lang-python",
+    "lang-ql",
+    "lang-r",
+    "lang-ruby",
+    "lang-rust",
+    "lang-scheme",
     "lang-scss",
-    "lang-hare"
-
+    "lang-sql",
+    "lang-svelte",
+    "lang-swift",
+    "lang-toml",
+    "lang-typescript",
+    "lang-vue",
+    "lang-wgsl",
+    "lang-xml",
+    "lang-yaml",
+    "lang-zig",
 ]
 
-lang-rust = ["lapce-core/lang-rust"]
-lang-go = ["lapce-core/lang-go"]
-lang-javascript= ["lapce-core/lang-javascript"]
-lang-typescript = ["lapce-core/lang-typescript"]
-lang-python = ["lapce-core/lang-python"]
-lang-toml = ["lapce-core/lang-toml"]
-lang-elixir = ["lapce-core/lang-elixir"]
-lang-php = ["lapce-core/lang-php"]
-lang-ruby= ["lapce-core/lang-ruby"]
+lang-bash = ["lapce-core/lang-bash"]
 lang-c = ["lapce-core/lang-c"]
+lang-clojure = ["lapce-core/lang-clojure"]
+lang-cmake = ["lapce-core/lang-cmake"]
 lang-cpp = ["lapce-core/lang-cpp"]
-lang-json= ["lapce-core/lang-json"]
-lang-md = ["lapce-core/lang-md"]
-lang-html = ["lapce-core/lang-html"]
-lang-java = ["lapce-core/lang-java"]
+lang-csharp = ["lapce-core/lang-csharp"]
+lang-css = ["lapce-core/lang-css"]
+lang-d = ["lapce-core/lang-d"]
+lang-dart = ["lapce-core/lang-dart"]
+lang-dockerfile = ["lapce-core/lang-dockerfile"]
+lang-elixir = ["lapce-core/lang-elixir"]
 lang-elm = ["lapce-core/lang-elm"]
-lang-swift = ["lapce-core/lang-swift"]
-lang-ql = ["lapce-core/lang-ql"]
-lang-haskell = ["lapce-core/lang-haskell"]
-lang-ocaml = ["lapce-core/lang-ocaml"]
+lang-erlang = ["lapce-core/lang-erlang"]
 lang-glimmer = ["lapce-core/lang-glimmer"]
+lang-glsl = ["lapce-core/lang-glsl"]
+lang-go = ["lapce-core/lang-go"]
+lang-hare = ["lapce-core/lang-hare"]
+lang-haskell = ["lapce-core/lang-haskell"]
 lang-haxe = ["lapce-core/lang-haxe"]
 lang-hcl = ["lapce-core/lang-hcl"]
+lang-html = ["lapce-core/lang-html"]
+lang-java = ["lapce-core/lang-java"]
+lang-javascript = ["lapce-core/lang-javascript"]
+lang-json = ["lapce-core/lang-json"]
+lang-julia = ["lapce-core/lang-julia"]
+lang-kotlin = ["lapce-core/lang-kotlin"]
+lang-latex = ["lapce-core/lang-latex"]
+lang-lua = ["lapce-core/lang-lua"]
+lang-markdown = ["lapce-core/lang-markdown"]
+lang-nix = ["lapce-core/lang-nix"]
+lang-ocaml = ["lapce-core/lang-ocaml"]
+lang-php = ["lapce-core/lang-php"]
+lang-prisma = ["lapce-core/lang-prisma"]
+lang-protobuf = ["lapce-core/lang-protobuf"]
+lang-python = ["lapce-core/lang-python"]
+lang-ql = ["lapce-core/lang-ql"]
+lang-r = ["lapce-core/lang-r"]
+lang-ruby = ["lapce-core/lang-ruby"]
+lang-rust = ["lapce-core/lang-rust"]
+lang-scheme = ["lapce-core/lang-scheme"]
 lang-scss = ["lapce-core/lang-scss"]
-lang-hare = ["lapce-core/lang-hare"]
\ No newline at end of file
+lang-sql = ["lapce-core/lang-sql"]
+lang-svelte = ["lapce-core/lang-svelte"]
+lang-swift = ["lapce-core/lang-swift"]
+lang-toml = ["lapce-core/lang-toml"]
+lang-typescript = ["lapce-core/lang-typescript"]
+lang-vue = ["lapce-core/lang-vue"]
+lang-wgsl = ["lapce-core/lang-wgsl"]
+lang-xml = ["lapce-core/lang-xml"]
+lang-yaml = ["lapce-core/lang-yaml"]
+lang-zig = ["lapce-core/lang-zig"]
diff --git a/lapce-ui/src/about.rs b/lapce-ui/src/about.rs
new file mode 100644
index 0000000000..ed576956a7
--- /dev/null
+++ b/lapce-ui/src/about.rs
@@ -0,0 +1,499 @@
+use std::sync::Arc;
+
+use druid::{
+    piet::{Text, TextAttribute, TextLayout, TextLayoutBuilder},
+    BoxConstraints, Command, Env, Event, EventCtx, FontWeight, LayoutCtx, LifeCycle,
+    LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect, RenderContext, Size, Target,
+    TextAlignment, UpdateCtx, Widget, WidgetId, WidgetPod,
+};
+use lapce_core::{command::FocusCommand, meta};
+use lapce_data::{
+    about::AboutFocusData,
+    command::{
+        CommandKind, LapceCommand, LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
+    },
+    config::{LapceIcons, LapceTheme},
+    data::LapceTabData,
+};
+
+struct AboutUri {}
+
+impl AboutUri {
+    const LAPCE: &str = "https://lapce.dev";
+    const GITHUB: &str = "https://github.com/lapce/lapce";
+    const MATRIX: &str = "https://matrix.to/#/#lapce-editor:matrix.org";
+    const DISCORD: &str = "https://discord.gg/n8tGJ6Rn6D";
+    const CODICONS: &str = "https://github.com/microsoft/vscode-codicons";
+}
+
+pub struct AboutBox {
+    content: WidgetPod<LapceTabData, AboutBoxContent>,
+}
+
+impl AboutBox {
+    pub fn new(data: &LapceTabData) -> Self {
+        let content = AboutBoxContent::new(data);
+        Self {
+            content: WidgetPod::new(content),
+        }
+    }
+}
+
+impl Widget<LapceTabData> for AboutBox {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        if !data.about.active {
+            return;
+        }
+        self.content.event(ctx, event, data, env);
+        if !event.should_propagate_to_hidden() {
+            ctx.set_handled();
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.content.lifecycle(ctx, event, data, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.content.update(ctx, data, env);
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let self_size = bc.max();
+        let size = self.content.layout(ctx, bc, data, env);
+        let origin = Point::new(
+            (self_size.width - size.width) / 2.0,
+            (self_size.height - size.height) / 2.0,
+        );
+        self.content.set_origin(ctx, data, env, origin);
+
+        self_size
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        if !data.about.active {
+            return;
+        }
+        let rect = ctx.size().to_rect();
+        ctx.fill(
+            rect,
+            &data
+                .config
+                .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW)
+                .clone()
+                .with_alpha(0.5),
+        );
+
+        self.content.paint(ctx, data, env);
+    }
+}
+
+pub struct AboutBoxContent {
+    mouse_pos: Option<Point>,
+    widget_id: WidgetId,
+
+    width: f64,
+    height: f64,
+    padding: f64,
+    svg_size: f64,
+
+    close_rect: Option<Rect>,
+
+    commands: Vec<(Rect, Command)>,
+    mouse_down_point: Option<Point>,
+}
+
+impl AboutBoxContent {
+    pub fn new(data: &LapceTabData) -> Self {
+        Self {
+            mouse_pos: None,
+            widget_id: data.about.widget_id,
+            width: 320.0,
+            height: 384.0,
+            padding: 40.0,
+            svg_size: 80.0,
+            close_rect: None,
+            commands: vec![],
+            mouse_down_point: None,
+        }
+    }
+
+    fn icon_hit_test(&self, mouse_event: &MouseEvent) -> bool {
+        for (rect, _) in self.commands.iter() {
+            if rect.contains(mouse_event.pos) {
+                return true;
+            }
+        }
+        if self
+            .close_rect
+            .map(|c| c.contains(mouse_event.pos))
+            .unwrap_or(false)
+        {
+            return true;
+        }
+        false
+    }
+
+    fn mouse_down(&self, ctx: &mut EventCtx, mouse_event: &MouseEvent) {
+        for (rect, command) in self.commands.iter() {
+            if rect.contains(mouse_event.pos) {
+                ctx.submit_command(command.clone());
+                ctx.set_handled();
+                return;
+            }
+        }
+    }
+}
+
+impl Widget<LapceTabData> for AboutBoxContent {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.widget_id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        match event {
+            Event::KeyDown(key_event) => {
+                let mut focus = AboutFocusData::new(data);
+                Arc::make_mut(&mut data.keypress)
+                    .key_down(ctx, key_event, &mut focus, env);
+            }
+            Event::MouseMove(mouse_event) => {
+                self.mouse_pos = Some(mouse_event.pos);
+                if self.icon_hit_test(mouse_event) {
+                    ctx.set_cursor(&druid::Cursor::Pointer);
+                } else {
+                    ctx.clear_cursor();
+                }
+                ctx.set_handled();
+            }
+            Event::MouseDown(mouse_event) => {
+                self.mouse_down_point = Some(mouse_event.pos);
+                if mouse_event.button.is_left() {
+                    self.mouse_down(ctx, mouse_event);
+                }
+                ctx.request_paint();
+            }
+            Event::MouseUp(mouse_event) => {
+                if self
+                    .close_rect
+                    .zip(self.mouse_down_point)
+                    .map(|(c, m)| c.contains(m) && c.contains(mouse_event.pos))
+                    .unwrap_or(false)
+                {
+                    ctx.submit_command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Focus(FocusCommand::ModalClose),
+                            data: None,
+                        },
+                        Target::Widget(self.widget_id),
+                    ));
+                }
+                self.mouse_down_point = None;
+                ctx.request_paint();
+                ctx.set_handled();
+            }
+            Event::Command(cmd) if cmd.is(LAPCE_COMMAND) => {
+                let command = cmd.get_unchecked(LAPCE_COMMAND);
+                if let CommandKind::Focus(FocusCommand::ModalClose) = &command.kind {
+                    let about = Arc::make_mut(&mut data.about);
+                    about.active = false;
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::Focus,
+                        Target::Widget(*data.focus),
+                    ));
+                    ctx.set_handled();
+                }
+            }
+            Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
+                let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
+                if let LapceUICommand::Focus = &command {
+                    ctx.request_focus();
+                    ctx.set_handled();
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        _ctx: &mut LifeCycleCtx,
+        _event: &LifeCycle,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn update(
+        &mut self,
+        _ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn layout(
+        &mut self,
+        _ctx: &mut LayoutCtx,
+        _bc: &BoxConstraints,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) -> Size {
+        Size::new(self.width, self.height)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+        let rect = ctx.size().to_rect();
+        let shadow_width = data.config.ui.drop_shadow_width() as f64;
+        if shadow_width > 0.0 {
+            ctx.blurred_rect(
+                rect,
+                shadow_width,
+                data.config
+                    .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+            );
+        }
+        ctx.fill(
+            rect,
+            data.config
+                .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+        );
+
+        ctx.draw_svg(
+            &data.config.logo_svg(),
+            Rect::ZERO
+                .with_origin(Point::new(
+                    self.width / 2.0,
+                    self.padding + self.svg_size / 2.0,
+                ))
+                .inflate(self.svg_size / 2.0, self.svg_size / 2.0),
+            Some(data.config.get_color_unchecked(LapceTheme::EDITOR_DIM)),
+        );
+
+        let title_padding = 20.0;
+        let line_gap = 12.0;
+        let mut y = self.padding + self.svg_size + title_padding;
+
+        let title_layout = ctx
+            .text()
+            .new_text_layout("Lapce")
+            .font(
+                data.config.ui.font_family(),
+                data.config.ui.font_size() as f64,
+            )
+            .default_attribute(TextAttribute::Weight(FontWeight::BOLD))
+            .alignment(TextAlignment::Center)
+            .max_width(self.width - self.padding * 2.0)
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+
+        ctx.draw_text(&title_layout, Point::new(self.padding, y));
+        y += title_layout.layout.height() as f64 + line_gap;
+
+        let version_layout = ctx
+            .text()
+            .new_text_layout(format!("Version: {}", *meta::VERSION))
+            .font(
+                data.config.ui.font_family(),
+                data.config.ui.font_size() as f64,
+            )
+            .alignment(TextAlignment::Center)
+            .max_width(self.width - self.padding * 2.0)
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_DIM)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+
+        ctx.draw_text(&version_layout, Point::new(self.padding, y));
+        y += version_layout.size().height + title_padding;
+
+        self.commands.clear();
+
+        for (msg, link) in [
+            ("Website", AboutUri::LAPCE),
+            ("GitHub", AboutUri::GITHUB),
+            ("Discord", AboutUri::DISCORD),
+            ("Matrix", AboutUri::MATRIX),
+        ] {
+            let row_item = ctx
+                .text()
+                .new_text_layout(msg)
+                .font(
+                    data.config.ui.font_family(),
+                    (data.config.ui.font_size()) as f64,
+                )
+                .alignment(TextAlignment::Center)
+                .max_width(self.width - self.padding * 2.0)
+                .text_color(
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_LINK)
+                        .clone(),
+                )
+                .build()
+                .unwrap();
+
+            let site_rect = Size::new(
+                row_item.layout.width() as f64,
+                row_item.layout.height() as f64,
+            )
+            .to_rect()
+            .with_origin(Point::new(
+                self.width / 2.0 + (row_item.layout.width() as f64 / 2.0)
+                    - row_item.layout.width() as f64,
+                y,
+            ));
+
+            self.commands.push((
+                site_rect,
+                Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::OpenURI(link.to_string()),
+                    Target::Auto,
+                ),
+            ));
+
+            ctx.draw_text(&row_item, Point::new(self.padding, y));
+
+            y += row_item.size().height + line_gap;
+        }
+
+        let row_item = ctx
+            .text()
+            .new_text_layout("Attributes")
+            .font(
+                data.config.ui.font_family(),
+                (data.config.ui.font_size()) as f64,
+            )
+            .alignment(TextAlignment::Center)
+            .max_width(self.width - self.padding * 2.0)
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_DIM)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+
+        ctx.draw_text(
+            &row_item,
+            Point::new(
+                self.padding,
+                rect.y1 - (row_item.layout.height() as f64 + line_gap) * 2.0,
+            ),
+        );
+
+        let row_item = ctx
+            .text()
+            .new_text_layout("Codicons (CC-BY-4.0)")
+            .font(
+                data.config.ui.font_family(),
+                (data.config.ui.font_size()) as f64,
+            )
+            .alignment(TextAlignment::Center)
+            .max_width(self.width - self.padding * 2.0)
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_LINK)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+        ctx.draw_text(
+            &row_item,
+            Point::new(
+                self.padding,
+                rect.y1 - row_item.layout.height() as f64 - line_gap,
+            ),
+        );
+
+        let site_rect = Size::new(
+            row_item.layout.width() as f64,
+            row_item.layout.height() as f64,
+        )
+        .to_rect()
+        .with_origin(Point::new(
+            self.width / 2.0 + (row_item.layout.width() as f64 / 2.0)
+                - row_item.layout.width() as f64,
+            rect.y1 - row_item.layout.height() as f64 - line_gap,
+        ));
+
+        self.commands.push((
+            site_rect,
+            Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::OpenURI(AboutUri::CODICONS.to_string()),
+                Target::Auto,
+            ),
+        ));
+
+        let close_rect = Size::new(20.0, 20.0)
+            .to_rect()
+            .with_origin(Point::new(self.width - 20.0, 0.0));
+
+        if self
+            .mouse_pos
+            .map(|m| close_rect.contains(m))
+            .unwrap_or(false)
+        {
+            ctx.fill(
+                close_rect,
+                &data.config.get_hover_color(
+                    data.config
+                        .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+                ),
+            );
+        }
+
+        ctx.draw_svg(
+            &data.config.ui_svg(LapceIcons::WINDOW_CLOSE),
+            close_rect.inflate(-2.5, -2.5),
+            Some(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+            ),
+        );
+
+        self.close_rect = Some(close_rect);
+    }
+}
diff --git a/lapce-ui/src/activity.rs b/lapce-ui/src/activity.rs
deleted file mode 100644
index 8f02efffc6..0000000000
--- a/lapce-ui/src/activity.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-use crate::svg::get_svg;
-use druid::{
-    kurbo::Line, BoxConstraints, Command, Cursor, Env, Event, EventCtx, LayoutCtx,
-    LifeCycle, LifeCycleCtx, PaintCtx, Point, RenderContext, Size, Target,
-    UpdateCtx, Widget,
-};
-use lapce_data::{
-    command::{CommandKind, LapceCommand, LapceWorkbenchCommand, LAPCE_COMMAND},
-    config::LapceTheme,
-    data::LapceTabData,
-    panel::PanelPosition,
-};
-use serde_json::json;
-
-pub struct ActivityBar {}
-
-impl ActivityBar {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-impl Default for ActivityBar {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Widget<LapceTabData> for ActivityBar {
-    fn event(
-        &mut self,
-        ctx: &mut EventCtx,
-        event: &Event,
-        data: &mut LapceTabData,
-        _env: &Env,
-    ) {
-        let width = data.config.ui.activity_width() as f64;
-        match event {
-            Event::MouseDown(mouse) => {
-                if mouse.button.is_left() {
-                    let index = (mouse.pos.y / width) as usize;
-                    if let Some(panel) = data.panels.get_mut(&PanelPosition::LeftTop)
-                    {
-                        if let Some(kind) = panel.widgets.get(index) {
-                            if panel.active == *kind {
-                                ctx.submit_command(Command::new(
-                                    LAPCE_COMMAND,
-                                    LapceCommand {
-                                        kind: CommandKind::Workbench(
-                                            LapceWorkbenchCommand::TogglePanelVisual,
-                                        ),
-                                        data: Some(json!(kind)),
-                                    },
-                                    Target::Widget(data.id),
-                                ));
-                            } else {
-                                ctx.submit_command(Command::new(
-                                    LAPCE_COMMAND,
-                                    LapceCommand {
-                                        kind: CommandKind::Workbench(
-                                            LapceWorkbenchCommand::ShowPanel,
-                                        ),
-                                        data: Some(json!(kind)),
-                                    },
-                                    Target::Widget(data.id),
-                                ));
-                            }
-                        }
-                    }
-                }
-            }
-            Event::MouseMove(mouse) => {
-                let n = data
-                    .panels
-                    .get(&PanelPosition::LeftTop)
-                    .map(|panel| panel.widgets.len())
-                    .unwrap_or(0);
-                if n > 0 && mouse.pos.y < width * n as f64 {
-                    ctx.set_cursor(&Cursor::Pointer);
-                } else {
-                    ctx.clear_cursor();
-                }
-            }
-            _ => {}
-        }
-    }
-
-    fn lifecycle(
-        &mut self,
-        _ctx: &mut LifeCycleCtx,
-        _event: &LifeCycle,
-        _data: &LapceTabData,
-        _env: &Env,
-    ) {
-    }
-
-    fn update(
-        &mut self,
-        _ctx: &mut UpdateCtx,
-        _old_data: &LapceTabData,
-        _data: &LapceTabData,
-        _env: &Env,
-    ) {
-    }
-
-    fn layout(
-        &mut self,
-        _ctx: &mut LayoutCtx,
-        bc: &BoxConstraints,
-        data: &LapceTabData,
-        _env: &Env,
-    ) -> Size {
-        Size::new(data.config.ui.activity_width() as f64, bc.max().height)
-    }
-
-    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
-        let size = ctx.size();
-        let rect = size.to_rect();
-
-        let shadow_width = data.config.ui.drop_shadow_width() as f64;
-        if shadow_width > 0.0 {
-            ctx.blurred_rect(
-                rect,
-                shadow_width,
-                data.config
-                    .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
-            );
-        } else {
-            ctx.stroke(
-                Line::new(
-                    Point::new(rect.x1 + 0.5, rect.y0),
-                    Point::new(rect.x1 + 0.5, rect.y1),
-                ),
-                data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
-                1.0,
-            );
-        }
-
-        ctx.fill(
-            rect,
-            data.config
-                .get_color_unchecked(LapceTheme::ACTIVITY_BACKGROUND),
-        );
-
-        let mut offset = 0.0;
-        let svg_color = data
-            .config
-            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-            .clone();
-        if let Some(panel) = data.panels.get(&PanelPosition::LeftTop) {
-            for kind in panel.widgets.iter() {
-                let svg = get_svg(kind.svg_name()).unwrap();
-                if &panel.active == kind && panel.shown {
-                    ctx.fill(
-                        Size::new(size.width, size.width)
-                            .to_rect()
-                            .with_origin(Point::new(0.0, offset)),
-                        data.config
-                            .get_color_unchecked(LapceTheme::ACTIVITY_CURRENT),
-                    );
-                }
-                let svg_size = 25.0;
-                let rect =
-                    Size::new(svg_size, svg_size)
-                        .to_rect()
-                        .with_origin(Point::new(
-                            (size.width - svg_size) / 2.0,
-                            (size.width - svg_size) / 2.0 + offset,
-                        ));
-                ctx.draw_svg(&svg, rect, Some(&svg_color));
-                offset += size.width;
-            }
-        }
-    }
-}
diff --git a/lapce-ui/src/alert.rs b/lapce-ui/src/alert.rs
index 1767d6deaf..b4bffd7453 100644
--- a/lapce-ui/src/alert.rs
+++ b/lapce-ui/src/alert.rs
@@ -3,8 +3,8 @@ use std::sync::Arc;
 use druid::{
     piet::{PietTextLayout, Text, TextAttribute, TextLayout, TextLayoutBuilder},
     BoxConstraints, Command, Env, Event, EventCtx, FontWeight, LayoutCtx, LifeCycle,
-    LifeCycleCtx, PaintCtx, Point, Rect, RenderContext, Size, Target, TextAlignment,
-    UpdateCtx, Widget, WidgetId, WidgetPod,
+    LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect, RenderContext, Size, Target,
+    TextAlignment, UpdateCtx, Widget, WidgetId, WidgetPod,
 };
 use lapce_core::command::FocusCommand;
 use lapce_data::{
@@ -12,12 +12,10 @@ use lapce_data::{
     command::{
         CommandKind, LapceCommand, LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
     },
-    config::LapceTheme,
+    config::{LapceIcons, LapceTheme},
     data::LapceTabData,
 };
 
-use crate::svg::get_svg;
-
 pub struct AlertBox {
     content: WidgetPod<LapceTabData, AlertBoxContent>,
 }
@@ -141,6 +139,18 @@ impl AlertBoxContent {
             mouse_down_point: Point::ZERO,
         }
     }
+
+    fn icon_hit_test(&self, mouse_event: &MouseEvent) -> bool {
+        for rect in self.buttons.iter() {
+            if rect.contains(mouse_event.pos) {
+                return true;
+            }
+        }
+        if self.cancel_rect.contains(mouse_event.pos) {
+            return true;
+        }
+        false
+    }
 }
 
 impl Widget<LapceTabData> for AlertBoxContent {
@@ -161,6 +171,13 @@ impl Widget<LapceTabData> for AlertBoxContent {
                 Arc::make_mut(&mut data.keypress)
                     .key_down(ctx, key_event, &mut focus, env);
             }
+            Event::MouseMove(mouse_event) => {
+                if self.icon_hit_test(mouse_event) {
+                    ctx.set_cursor(&druid::Cursor::Pointer);
+                } else {
+                    ctx.clear_cursor();
+                }
+            }
             Event::MouseDown(mouse_event) => {
                 self.mouse_down_point = mouse_event.pos;
             }
@@ -210,7 +227,7 @@ impl Widget<LapceTabData> for AlertBoxContent {
                     ctx.submit_command(Command::new(
                         LAPCE_UI_COMMAND,
                         LapceUICommand::Focus,
-                        Target::Widget(data.focus),
+                        Target::Widget(*data.focus),
                     ));
                     ctx.set_handled();
                 }
@@ -346,7 +363,7 @@ impl Widget<LapceTabData> for AlertBoxContent {
                 .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
         );
 
-        let svg = get_svg("warning.svg").unwrap();
+        let svg = data.config.ui_svg(LapceIcons::WARNING);
         ctx.draw_svg(
             &svg,
             self.svg_rect,
@@ -378,7 +395,7 @@ impl Widget<LapceTabData> for AlertBoxContent {
                 .unwrap();
             let text_layout_size = text_layout.size();
             let point = self.buttons[i].center()
-                - (text_layout_size.width / 2.0, text_layout_size.height / 2.0);
+                - (text_layout_size.width / 2.0, text_layout.cap_center());
             ctx.draw_text(&text_layout, point);
         }
 
@@ -403,7 +420,7 @@ impl Widget<LapceTabData> for AlertBoxContent {
             .unwrap();
         let text_layout_size = text_layout.size();
         let cancel_point = self.cancel_rect.center()
-            - (text_layout_size.width / 2.0, text_layout_size.height / 2.0);
+            - (text_layout_size.width / 2.0, text_layout.cap_center());
         ctx.draw_text(&text_layout, cancel_point);
     }
 }
diff --git a/lapce-ui/src/app.rs b/lapce-ui/src/app.rs
index b73b4bdf2d..c1dbd09fcd 100644
--- a/lapce-ui/src/app.rs
+++ b/lapce-ui/src/app.rs
@@ -1,29 +1,91 @@
+#[cfg(target_os = "windows")]
+use std::os::windows::process::CommandExt;
+use std::{path::PathBuf, process::Stdio, sync::Arc};
+
+use clap::Parser;
 use druid::{
-    AppDelegate, AppLauncher, Command, Env, Event, LocalizedString, Point, Size,
-    Widget, WidgetExt, WindowDesc, WindowHandle, WindowId, WindowState,
+    AppDelegate, AppLauncher, Command, Env, Event, LocalizedString, Point, Region,
+    Size, Target, Widget, WidgetExt, WidgetPod, WindowDesc, WindowHandle, WindowId,
+    WindowState,
 };
 #[cfg(target_os = "macos")]
 use druid::{Menu, MenuItem, SysMods};
+#[cfg(target_os = "macos")]
+use lapce_core::command::{EditCommand, FocusCommand};
+use lapce_core::meta;
 use lapce_data::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::Config,
-    data::{LapceData, LapceWindowData, LapceWindowLens},
+    config::LapceConfig,
+    data::{
+        LapceData, LapceTabLens, LapceWindowData, LapceWindowLens, LapceWorkspace,
+        LapceWorkspaceType,
+    },
     db::{TabsInfo, WindowInfo},
 };
 
-use crate::logging::override_log_levels;
-use crate::window::LapceWindow;
+use crate::{
+    logging::override_log_levels,
+    tab::{LapceTabHeader, LAPCE_TAB_META},
+    window::LapceWindow,
+};
 
-#[cfg(target_os = "linux")]
-const LOGO_PNG: &[u8] = include_bytes!("../../extra/images/logo.png");
-#[cfg(target_os = "windows")]
-const LOGO_ICO: &[u8] = include_bytes!("../../extra/windows/lapce.ico");
+#[derive(Parser)]
+#[clap(name = "Lapce")]
+#[clap(version=*meta::VERSION)]
+#[derive(Debug)]
+struct Cli {
+    /// Launch new window even if Lapce is already running
+    #[clap(short, long, action)]
+    new: bool,
+    /// Don't return instantly when opened in terminal
+    #[clap(short, long, action)]
+    wait: bool,
+    paths: Vec<PathBuf>,
+}
 
-pub fn build_window(data: &LapceWindowData) -> impl Widget<LapceData> {
+pub fn build_window(data: &mut LapceWindowData) -> impl Widget<LapceData> {
     LapceWindow::new(data).lens(LapceWindowLens(data.window_id))
 }
 
 pub fn launch() {
+    // if PWD is not set, then we are not being launched via a terminal
+    #[cfg(any(target_os = "macos", target_os = "linux"))]
+    if std::env::var("PWD").is_err() {
+        load_shell_env();
+    }
+
+    let cli = Cli::parse();
+
+    // small hack to unblock terminal if launched from it
+    if !cli.wait {
+        let mut args = std::env::args().collect::<Vec<_>>();
+        args.push("--wait".to_string());
+        let mut cmd = std::process::Command::new(&args[0]);
+        #[cfg(target_os = "windows")]
+        cmd.creation_flags(0x08000000); // CREATE_NO_WINDOW
+        if let Err(why) = cmd
+            .args(&args[1..])
+            .stderr(Stdio::null())
+            .stdout(Stdio::null())
+            .spawn()
+        {
+            eprintln!("Failed to launch lapce: {why}");
+        };
+        return;
+    }
+    let pwd = std::env::current_dir().unwrap_or_default();
+    let paths: Vec<PathBuf> = cli
+        .paths
+        .iter()
+        .map(|p| pwd.join(p).canonicalize().unwrap_or_default())
+        .collect();
+    if !cli.new && LapceData::try_open_in_existing_process(&paths).is_ok() {
+        return;
+    }
+
+    #[cfg(feature = "updater")]
+    lapce_data::update::cleanup();
+
     let mut log_dispatch = fern::Dispatch::new()
         .format(|out, message, record| {
             out.finish(format_args!(
@@ -34,26 +96,49 @@ pub fn launch() {
                 message
             ))
         })
-        .level(if cfg!(debug_assertions) {
-            log::LevelFilter::Warn
-        } else {
-            log::LevelFilter::Off
-        })
-        .chain(std::io::stderr());
+        .level(log::LevelFilter::Debug)
+        .chain(override_log_levels(
+            fern::Dispatch::new()
+                .level(if cfg!(debug_assertions) {
+                    log::LevelFilter::Warn
+                } else {
+                    log::LevelFilter::Off
+                })
+                .chain(std::io::stderr()),
+        ));
 
-    if let Some(log_file) = Config::log_file().and_then(|f| fern::log_file(f).ok()) {
-        log_dispatch = log_dispatch.chain(log_file);
+    let log_file = LapceConfig::log_file();
+    if let Some(log_file) = log_file.clone().and_then(|f| fern::log_file(f).ok()) {
+        log_dispatch = log_dispatch.chain(
+            fern::Dispatch::new()
+                .level(log::LevelFilter::Debug)
+                .level_for("lapce_data::keypress::key_down", log::LevelFilter::Off)
+                .level_for("sled", log::LevelFilter::Off)
+                .level_for("tracing", log::LevelFilter::Off)
+                .level_for("druid::core", log::LevelFilter::Off)
+                .level_for("druid::window", log::LevelFilter::Off)
+                .level_for("druid::box_constraints", log::LevelFilter::Off)
+                .level_for("cranelift_codegen", log::LevelFilter::Off)
+                .level_for("wasmtime_cranelift", log::LevelFilter::Off)
+                .level_for("regalloc", log::LevelFilter::Off)
+                .level_for("hyper::proto", log::LevelFilter::Off)
+                .chain(log_file),
+        );
     }
 
-    log_dispatch = override_log_levels(log_dispatch);
     match log_dispatch.apply() {
         Ok(()) => (),
         Err(e) => eprintln!("Initialising logging failed {e:?}"),
     }
 
+    log_panics::Config::new()
+        .backtrace_mode(log_panics::BacktraceMode::Resolved)
+        .install_panic_hook();
+
     let mut launcher = AppLauncher::new().delegate(LapceAppDelegate::new());
-    let data = LapceData::load(launcher.get_external_handle());
-    for (_window_id, window_data) in data.windows.iter() {
+    let mut data = LapceData::load(launcher.get_external_handle(), paths, log_file);
+
+    for (_window_id, window_data) in data.windows.iter_mut() {
         let root = build_window(window_data);
         let window = new_window_desc(
             window_data.window_id,
@@ -61,6 +146,7 @@ pub fn launch() {
             window_data.size,
             window_data.pos,
             window_data.maximised,
+            &window_data.config,
         );
         launcher = launcher.with_window(window);
     }
@@ -75,14 +161,48 @@ fn new_window_desc<W, T: druid::Data>(
     size: Size,
     pos: Point,
     maximised: bool,
+    config: &Arc<LapceConfig>,
 ) -> WindowDesc<T>
 where
     W: Widget<T> + 'static,
 {
+    // Check if the window would spawn in point (x: 0, y: 0)
+    // (initial coordinates of top left corner on primary screen)
+    // and isn't maximised, then calculate point to spawn center of
+    // editor in center of primary screen
+    let pos = if pos.x == 0.0 && pos.y == 0.0 && !maximised {
+        let screens = druid::Screen::get_monitors();
+        let mut screens = screens.iter().filter(|f| f.is_primary());
+        // Get actual workspace rectangle excluding taskbars/menus
+        match screens.next() {
+            Some(screen) => {
+                let screen_center_pos = screen.virtual_work_rect().center();
+                // Position our window centered, not in center point
+                Point::new(
+                    screen_center_pos.x - size.width / 2.0,
+                    screen_center_pos.y - size.height / 2.0,
+                )
+            }
+            None => {
+                log::error!("No primary display found. Are you running lapce in console-only/SSH/WSL?");
+                pos
+            }
+        }
+    } else {
+        pos
+    };
     let mut desc = WindowDesc::new_with_id(window_id, root)
         .title(LocalizedString::new("Lapce").with_placeholder("Lapce"))
+        .with_min_size(Size::new(384.0, 384.0))
         .window_size(size)
         .set_position(pos);
+
+    if cfg!(not(target_os = "macos")) {
+        desc = desc.show_titlebar(!config.core.custom_titlebar);
+    } else {
+        desc = desc.show_titlebar(false);
+    }
+
     if maximised {
         desc = desc.set_window_state(WindowState::Maximized);
     }
@@ -92,7 +212,7 @@ where
     }
 
     #[cfg(target_os = "macos")]
-    if true {
+    {
         desc = macos_window_desc(desc);
     }
 
@@ -104,19 +224,15 @@ fn window_icon() -> Option<druid::Icon> {
     None
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(not(target_os = "macos"))]
 fn window_icon() -> Option<druid::Icon> {
-    let image = image::load_from_memory(LOGO_PNG)
-        .expect("Invalid Icon")
-        .into_rgba8();
-    let (width, height) = image.dimensions();
-    let rgba = image.into_raw();
-    Some(druid::Icon::from_rgba(rgba, width, height).expect("Failed to open icon"))
-}
+    #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
+    const LOGO: &[u8] = include_bytes!("../../extra/images/logo.png");
 
-#[cfg(target_os = "windows")]
-fn window_icon() -> Option<druid::Icon> {
-    let image = image::load_from_memory(LOGO_ICO)
+    #[cfg(target_os = "windows")]
+    const LOGO: &[u8] = include_bytes!("../../extra/windows/lapce.ico");
+
+    let image = image::load_from_memory(LOGO)
         .expect("Invalid Icon")
         .into_rgba8();
     let (width, height) = image.dimensions();
@@ -126,32 +242,310 @@ fn window_icon() -> Option<druid::Icon> {
 
 #[cfg(target_os = "macos")]
 fn macos_window_desc<T: druid::Data>(desc: WindowDesc<T>) -> WindowDesc<T> {
-    desc.show_titlebar(false).menu(|_, _, _| {
-        Menu::new("Lapce").entry(
-            Menu::new("")
-                .entry(MenuItem::new("About Lapce"))
-                .separator()
-                .entry(
-                    MenuItem::new("Hide Lapce")
-                        .command(druid::commands::HIDE_APPLICATION)
-                        .hotkey(SysMods::Cmd, "h"),
-                )
-                .separator()
-                .entry(
-                    MenuItem::new("Quit Lapce")
-                        .command(druid::commands::QUIT_APP)
-                        .hotkey(SysMods::Cmd, "q"),
-                ),
-        )
+    use lapce_data::command::{
+        CommandKind, LapceCommand, LapceWorkbenchCommand, LAPCE_COMMAND,
+    };
+
+    desc.menu(|_, _, _| {
+        let settings = Menu::new("Settings...")
+            .entry(
+                MenuItem::new("Open Settings")
+                    .command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Workbench(
+                                LapceWorkbenchCommand::OpenSettings,
+                            ),
+                            data: None,
+                        },
+                        Target::Auto,
+                    ))
+                    .hotkey(SysMods::Cmd, ","),
+            )
+            // MacOS doesn't like Cmd K Cmd S in its native spot for keyboard shortcuts
+            // so do what VSCode does and put it in the title
+            //
+            // \u{2318} is the Unicode  the Command symbol on MacOS
+            .entry(
+                MenuItem::new("Open Keyboard Shortcuts [\u{2318}K \u{2318}S]")
+                    .command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Workbench(
+                                LapceWorkbenchCommand::OpenKeyboardShortcuts,
+                            ),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )),
+            );
+        Menu::new("Lapce")
+            .entry(
+                Menu::new("")
+                    .entry(MenuItem::new("About Lapce").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Workbench(
+                                LapceWorkbenchCommand::ShowAbout,
+                            ),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .separator()
+                    .entry(settings)
+                    .separator()
+                    .entry(
+                        MenuItem::new("Hide Lapce")
+                            .command(druid::commands::HIDE_APPLICATION)
+                            .hotkey(SysMods::Cmd, "h"),
+                    )
+                    .entry(
+                        MenuItem::new("Hide Others")
+                            .command(druid::commands::HIDE_OTHERS)
+                            .hotkey(SysMods::AltCmd, "h"),
+                    )
+                    .entry(
+                        MenuItem::new("Show All").command(druid::commands::SHOW_ALL),
+                    )
+                    .separator()
+                    .entry(
+                        MenuItem::new("Quit Lapce")
+                            .command(druid::commands::QUIT_APP)
+                            .hotkey(SysMods::Cmd, "q"),
+                    ),
+            )
+            .separator()
+            .entry(
+                Menu::new("File")
+                    .entry(MenuItem::new("New File").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Workbench(
+                                LapceWorkbenchCommand::NewFile,
+                            ),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .separator()
+                    .entry(MenuItem::new("Open").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Workbench(
+                                LapceWorkbenchCommand::OpenFile,
+                            ),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .entry(MenuItem::new("Open Folder").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Workbench(
+                                LapceWorkbenchCommand::OpenFolder,
+                            ),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .separator()
+                    .entry(MenuItem::new("Save").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Focus(FocusCommand::Save),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .entry(MenuItem::new("Save All").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Workbench(
+                                LapceWorkbenchCommand::SaveAll,
+                            ),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .separator()
+                    .entry(MenuItem::new("Close Folder").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Workbench(
+                                LapceWorkbenchCommand::CloseFolder,
+                            ),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .entry(MenuItem::new("Close Window").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Workbench(
+                                LapceWorkbenchCommand::CloseWindow,
+                            ),
+                            data: None,
+                        },
+                        Target::Auto,
+                    ))),
+            )
+            .entry(
+                Menu::new("Edit")
+                    .entry(MenuItem::new("Cut").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Edit(EditCommand::ClipboardCut),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .entry(MenuItem::new("Copy").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Edit(EditCommand::ClipboardCopy),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .entry(MenuItem::new("Paste").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Edit(EditCommand::ClipboardPaste),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .separator()
+                    .entry(MenuItem::new("Undo").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Edit(EditCommand::Undo),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .entry(MenuItem::new("Redo").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Edit(EditCommand::Redo),
+                            data: None,
+                        },
+                        Target::Auto,
+                    )))
+                    .separator()
+                    .entry(MenuItem::new("Find").command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Focus(FocusCommand::Search),
+                            data: None,
+                        },
+                        Target::Auto,
+                    ))),
+            )
     })
 }
 
+/// Uses a login shell to load the correct shell environment for the current user.
+#[cfg(any(target_os = "macos", target_os = "linux"))]
+fn load_shell_env() {
+    use std::process::Command;
+
+    let shell = match std::env::var("SHELL") {
+        Ok(s) => s,
+        Err(_) => {
+            // Shell variable is not set, so we can't determine the correct shell executable.
+            // Silently failing, since logger is not set up yet.
+            return;
+        }
+    };
+
+    let mut command = Command::new(shell);
+
+    command.args(["--login"]).args(["-c", "printenv"]);
+
+    let env = match command.output() {
+        Ok(output) => String::from_utf8(output.stdout).unwrap_or_default(),
+
+        Err(_) => {
+            // sliently ignoring since logger is not yet available
+            return;
+        }
+    };
+
+    env.split('\n')
+        .filter_map(|line| line.split_once('='))
+        .for_each(|(key, value)| {
+            std::env::set_var(key, value);
+        })
+}
+
+/// The delegate handler for Top-Level Druid events (terminate, new window, etc.)
 struct LapceAppDelegate {}
 
 impl LapceAppDelegate {
     pub fn new() -> Self {
         Self {}
     }
+
+    fn new_window(
+        window_id: &WindowId,
+        ctx: &mut druid::DelegateCtx,
+        data: &mut LapceData,
+    ) {
+        let (size, pos, current_panels) = data
+            .windows
+            .get(window_id)
+            // If maximised, use default dimensions instead
+            .filter(|win| !win.maximised)
+            .map(|win| {
+                (
+                    win.size,
+                    win.pos + (50.0, 50.0),
+                    win.tabs.get(&win.active_id).map(|tab| (*tab.panel).clone()),
+                )
+            })
+            .unwrap_or_else(|| {
+                data.db
+                    .get_last_window_info()
+                    .map(|i| (i.size, i.pos, None))
+                    .unwrap_or_else(|_| {
+                        (Size::new(800.0, 600.0), Point::new(0.0, 0.0), None)
+                    })
+            });
+        let info = WindowInfo {
+            size,
+            pos,
+            maximised: false,
+            tabs: TabsInfo {
+                active_tab: 0,
+                workspaces: vec![],
+            },
+        };
+        let mut window_data = LapceWindowData::new(
+            data.keypress.clone(),
+            data.latest_release.clone(),
+            data.update_in_process,
+            data.log_file.clone(),
+            current_panels,
+            data.panel_orders.clone(),
+            ctx.get_external_handle(),
+            &info,
+            data.db.clone(),
+        );
+        let root = build_window(&mut window_data);
+        let window_id = window_data.window_id;
+        data.windows.insert(window_id, window_data.clone());
+        let desc = new_window_desc(
+            window_id,
+            root,
+            info.size,
+            info.pos,
+            info.maximised,
+            &window_data.config,
+        );
+        ctx.new_window(desc);
+    }
 }
 
 impl Default for LapceAppDelegate {
@@ -163,16 +557,31 @@ impl Default for LapceAppDelegate {
 impl AppDelegate<LapceData> for LapceAppDelegate {
     fn event(
         &mut self,
-        _ctx: &mut druid::DelegateCtx,
+        ctx: &mut druid::DelegateCtx,
         _window_id: WindowId,
         event: druid::Event,
         data: &mut LapceData,
         _env: &Env,
     ) -> Option<Event> {
-        if let Event::ApplicationWillTerminate = event {
-            let _ = data.db.save_app(data);
-            return None;
-        }
+        match event {
+            Event::ApplicationWillTerminate => {
+                let _ = data.db.save_app(data);
+                return None;
+            }
+            Event::ApplicationShouldHandleReopen(has_visible_windows) => {
+                if !has_visible_windows {
+                    // Create new window immediately
+                    let new_window_id = WindowId::next();
+                    Self::new_window(&new_window_id, ctx, data);
+                }
+                return None;
+            }
+            Event::WindowGotFocus(window_id) => {
+                data.active_window = Arc::new(window_id);
+                return Some(event);
+            }
+            _ => {}
+        };
         Some(event)
     }
 
@@ -199,43 +608,213 @@ impl AppDelegate<LapceData> for LapceAppDelegate {
         data: &mut LapceData,
         _env: &Env,
     ) -> druid::Handled {
-        if let Some(LapceUICommand::NewWindow(from_window_id)) =
-            cmd.get(LAPCE_UI_COMMAND)
-        {
-            let (size, pos) = data
-                .windows
-                .get(from_window_id)
-                // If maximised, use default dimensions instead
-                .filter(|win| !win.maximised)
-                .map(|win| (win.size, win.pos + (50.0, 50.0)))
-                .unwrap_or((Size::new(800.0, 600.0), Point::new(0.0, 0.0)));
-            let info = WindowInfo {
-                size,
-                pos,
-                maximised: false,
-                tabs: TabsInfo {
-                    active_tab: 0,
-                    workspaces: vec![],
-                },
-            };
-            let window_data = LapceWindowData::new(
-                data.keypress.clone(),
-                ctx.get_external_handle(),
-                &info,
-                data.db.clone(),
-            );
-            let root = build_window(&window_data);
-            let window_id = window_data.window_id;
-            data.windows.insert(window_id, window_data);
-            let desc = new_window_desc(
-                window_id,
-                root,
-                info.size,
-                info.pos,
-                info.maximised,
-            );
-            ctx.new_window(desc);
-            return druid::Handled::Yes;
+        match cmd {
+            cmd if cmd.is(LAPCE_TAB_META) => {
+                let meta = cmd.get_unchecked(LAPCE_TAB_META).take().unwrap();
+
+                let (size, pos) = data
+                    .windows
+                    .get(&meta.data.window_id)
+                    .map(|win| (win.size, win.pos + (50.0, 50.0)))
+                    .unwrap_or((Size::new(800.0, 600.0), Point::new(0.0, 0.0)));
+                let info = WindowInfo {
+                    size,
+                    pos,
+                    maximised: false,
+                    tabs: TabsInfo {
+                        active_tab: 0,
+                        workspaces: vec![],
+                    },
+                };
+                let mut window_data = LapceWindowData::new(
+                    data.keypress.clone(),
+                    data.latest_release.clone(),
+                    data.update_in_process,
+                    data.log_file.clone(),
+                    None,
+                    data.panel_orders.clone(),
+                    ctx.get_external_handle(),
+                    &info,
+                    data.db.clone(),
+                );
+
+                let mut tab = meta.data;
+                tab.window_id = Arc::new(window_data.window_id);
+
+                let tab_id = tab.id;
+                window_data.tabs_order = Arc::new(vec![tab_id]);
+                window_data.active_id = Arc::new(tab_id);
+                window_data.tabs.clear();
+                window_data.tabs.insert(tab_id, tab);
+
+                let window_widget = LapceWindow {
+                    mouse_pos: Point::ZERO,
+                    tabs: vec![meta.widget],
+                    tab_headers: [tab_id]
+                        .iter()
+                        .map(|tab_id| {
+                            let tab_header =
+                                LapceTabHeader::new().lens(LapceTabLens(*tab_id));
+                            WidgetPod::new(tab_header)
+                        })
+                        .collect(),
+                    draggable_area: Region::EMPTY,
+                    tab_header_cmds: Vec::new(),
+                    mouse_down_cmd: None,
+                    #[cfg(not(target_os = "macos"))]
+                    holding_click_rect: None,
+                };
+                let window_id = window_data.window_id;
+                let root = window_widget.lens(LapceWindowLens(window_id));
+                data.windows.insert(window_id, window_data.clone());
+                let desc = new_window_desc(
+                    window_id,
+                    root,
+                    info.size,
+                    info.pos,
+                    info.maximised,
+                    &window_data.config,
+                );
+                ctx.new_window(desc);
+                return druid::Handled::Yes;
+            }
+            cmd if cmd.is(LAPCE_UI_COMMAND) => {
+                let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
+                match command {
+                    LapceUICommand::UpdateLatestRelease(release) => {
+                        *Arc::make_mut(&mut data.latest_release) =
+                            Some(release.clone());
+                        return druid::Handled::Yes;
+                    }
+                    LapceUICommand::UpdateStarted => {
+                        data.update_in_process = true;
+                    }
+                    LapceUICommand::UpdateFailed => {
+                        data.update_in_process = false;
+                    }
+                    LapceUICommand::RestartToUpdate(process_path, release) => {
+                        let _ = data.db.save_app(data);
+                        let process_path = process_path.clone();
+                        let release = release.clone();
+                        let event_sink = ctx.get_external_handle();
+                        std::thread::spawn(move || {
+                            let do_update = || -> anyhow::Result<()> {
+                                log::info!("start to down new versoin");
+                                let src =
+                                    lapce_data::update::download_release(&release)?;
+
+                                log::info!("start to extract");
+                                let path = lapce_data::update::extract(
+                                    &src,
+                                    &process_path,
+                                )?;
+
+                                log::info!("now restart {path:?}");
+                                lapce_data::update::restart(&path)?;
+
+                                Ok(())
+                            };
+
+                            let _ = event_sink.submit_command(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::UpdateStarted,
+                                Target::Global,
+                            );
+                            if let Err(err) = do_update() {
+                                log::error!("Failed to update: {err}");
+                                let _ = event_sink.submit_command(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::UpdateFailed,
+                                    Target::Global,
+                                );
+                            }
+                        });
+                        return druid::Handled::Yes;
+                    }
+                    LapceUICommand::OpenPaths {
+                        window_tab_id,
+                        folders,
+                        files,
+                    } => {
+                        if let Some((window_id, tab_id)) = window_tab_id {
+                            if let Some(window_data) = data.windows.get(window_id) {
+                                if let Some(tab_data) = window_data.tabs.get(tab_id)
+                                {
+                                    for folder in folders {
+                                        ctx.submit_command(Command::new(
+                                            LAPCE_UI_COMMAND,
+                                            LapceUICommand::ShowWindow,
+                                            Target::Window(*window_id),
+                                        ));
+                                        let workspace = LapceWorkspace {
+                                            kind: tab_data.workspace.kind.clone(),
+                                            path: Some(folder.to_path_buf()),
+                                            last_open: 0,
+                                        };
+                                        ctx.submit_command(Command::new(
+                                            LAPCE_UI_COMMAND,
+                                            LapceUICommand::NewTab(Some(workspace)),
+                                            Target::Window(*window_id),
+                                        ));
+                                    }
+                                    for file in files {
+                                        ctx.submit_command(Command::new(
+                                            LAPCE_UI_COMMAND,
+                                            LapceUICommand::OpenFile(
+                                                file.to_path_buf(),
+                                                false,
+                                            ),
+                                            Target::Widget(*tab_id),
+                                        ));
+                                    }
+                                    return druid::Handled::Yes;
+                                }
+                            }
+                        }
+
+                        ctx.submit_command(Command::new(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::ShowWindow,
+                            Target::Window(*data.active_window),
+                        ));
+                        for folder in folders {
+                            let workspace = LapceWorkspace {
+                                kind: LapceWorkspaceType::Local,
+                                path: Some(folder.to_path_buf()),
+                                last_open: 0,
+                            };
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::NewTab(Some(workspace)),
+                                Target::Window(*data.active_window),
+                            ));
+                        }
+                        for file in files {
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::OpenFile(file.to_path_buf(), false),
+                                Target::Window(*data.active_window),
+                            ));
+                        }
+                        return druid::Handled::Yes;
+                    }
+                    LapceUICommand::NewWindow(from_window_id) => {
+                        Self::new_window(from_window_id, ctx, data);
+                        return druid::Handled::Yes;
+                    }
+                    LapceUICommand::CloseWindow(window_id) => {
+                        ctx.submit_command(Command::new(
+                            druid::commands::CLOSE_WINDOW,
+                            (),
+                            Target::Window(*window_id),
+                        ));
+                        let _ = data.db.save_app(data);
+                        return druid::Handled::Yes;
+                    }
+                    _ => (),
+                }
+            }
+            _ => (),
         }
         druid::Handled::No
     }
diff --git a/lapce-ui/src/button.rs b/lapce-ui/src/button.rs
new file mode 100644
index 0000000000..071f08150d
--- /dev/null
+++ b/lapce-ui/src/button.rs
@@ -0,0 +1,171 @@
+//! This button code is adapted from druid's button widget
+
+use druid::{
+    debug_state::DebugState,
+    theme,
+    widget::{Click, ControllerHost, Label, LabelText},
+    Affine, BoxConstraints, Cursor, Data, Env, Event, EventCtx, FontDescriptor,
+    Insets, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, RenderContext, Size,
+    UpdateCtx, Widget,
+};
+use lapce_data::{
+    config::{LapceConfig, LapceTheme},
+    data::LapceTabData,
+};
+
+// the minimum padding added to a button.
+// NOTE: these values are chosen to match the existing look of TextBox; these
+// should be reevaluated at some point.
+const LABEL_INSETS: Insets = Insets::uniform_xy(8., 2.);
+
+/// A button with a text label.
+pub struct Button {
+    label: Label<LapceTabData>,
+    label_size: Size,
+}
+
+impl Button {
+    /// Create a new button with a text label.
+    pub fn new(
+        data: &LapceTabData,
+        text: impl Into<LabelText<LapceTabData>>,
+    ) -> Button {
+        Button::from_label(data, Label::new(text))
+    }
+
+    /// Create a new button with the provided [`Label`].
+    pub fn from_label(
+        data: &LapceTabData,
+        mut label: Label<LapceTabData>,
+    ) -> Button {
+        update_label(&data.config, &mut label);
+        Button {
+            label,
+            label_size: Size::ZERO,
+        }
+    }
+
+    /// Provide a closure to be called when this button is clicked.
+    pub fn on_click(
+        self,
+        f: impl Fn(&mut EventCtx, &mut LapceTabData, &Env) + 'static,
+    ) -> ControllerHost<Self, Click<LapceTabData>> {
+        ControllerHost::new(self, Click::new(f))
+    }
+}
+
+impl Widget<LapceTabData> for Button {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        _data: &mut LapceTabData,
+        _env: &Env,
+    ) {
+        match event {
+            Event::MouseDown(_) => {
+                if !ctx.is_disabled() {
+                    ctx.set_active(true);
+                    ctx.request_paint();
+                }
+            }
+            Event::MouseMove(_) => ctx.set_cursor(&Cursor::Pointer),
+            Event::MouseUp(_) => {
+                if ctx.is_active() && !ctx.is_disabled() {
+                    ctx.request_paint();
+                }
+                ctx.set_active(false);
+            }
+            _ => (),
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        if let LifeCycle::HotChanged(_) | LifeCycle::DisabledChanged(_) = event {
+            ctx.request_paint();
+        }
+        self.label.lifecycle(ctx, event, data, env)
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        if !old_data.config.same(&data.config) {
+            update_label(&data.config, &mut self.label);
+        }
+        self.label.update(ctx, old_data, data, env)
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let padding = Size::new(LABEL_INSETS.x_value(), LABEL_INSETS.y_value());
+        let label_bc = bc.shrink(padding).loosen();
+        self.label_size = self.label.layout(ctx, &label_bc, data, env);
+        // HACK: to make sure we look okay at default sizes when beside a textbox,
+        // we make sure we will have at least the same height as the default textbox.
+        let min_height = env.get(theme::BORDERED_WIDGET_HEIGHT);
+        let baseline = self.label.baseline_offset();
+        ctx.set_baseline_offset(baseline + LABEL_INSETS.y1);
+
+        bc.constrain(Size::new(
+            self.label_size.width + padding.width,
+            (self.label_size.height + padding.height).max(min_height),
+        ))
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let size = ctx.size();
+        let stroke_width = 1.0;
+
+        let rounded_rect = size
+            .to_rect()
+            .inset(-stroke_width / 2.0)
+            .to_rounded_rect(env.get(theme::BUTTON_BORDER_RADIUS));
+
+        ctx.stroke(
+            rounded_rect,
+            data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+            stroke_width,
+        );
+
+        let label_offset = (size.to_vec2() - self.label_size.to_vec2()) / 2.0;
+
+        ctx.with_save(|ctx| {
+            ctx.transform(Affine::translate(label_offset));
+            self.label.paint(ctx, data, env);
+        });
+    }
+
+    fn debug_state(&self, _data: &LapceTabData) -> DebugState {
+        DebugState {
+            display_name: self.short_type_name().to_string(),
+            main_value: self.label.text().to_string(),
+            ..Default::default()
+        }
+    }
+}
+
+fn update_label(config: &LapceConfig, label: &mut Label<LapceTabData>) {
+    label.set_text_size(config.ui.font_size() as f64);
+    label.set_font(FontDescriptor::new(config.ui.font_family()));
+    label.set_text_color(
+        config
+            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+            .clone(),
+    );
+}
diff --git a/lapce-ui/src/completion.rs b/lapce-ui/src/completion.rs
index 1b33e15298..621f230ed2 100644
--- a/lapce-ui/src/completion.rs
+++ b/lapce-ui/src/completion.rs
@@ -1,201 +1,60 @@
-use std::{cmp::Ordering, fmt::Display, sync::Arc};
+use std::sync::Arc;
 
-use anyhow::Error;
 use druid::{
     piet::{Text, TextAttribute, TextLayoutBuilder},
-    BoxConstraints, Command, Data, Env, Event, EventCtx, FontFamily, FontWeight,
-    LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, Point, Rect, RenderContext, Size,
-    Target, UpdateCtx, Widget, WidgetId, WidgetPod,
+    theme, BoxConstraints, Command, Data, Env, Event, EventCtx, FontDescriptor,
+    FontFamily, FontWeight, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, Point,
+    Rect, RenderContext, Size, Target, UpdateCtx, Widget, WidgetId, WidgetPod,
 };
-use itertools::Itertools;
 use lapce_data::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
     completion::{CompletionData, CompletionStatus, ScoredCompletionItem},
     config::LapceTheme,
     data::LapceTabData,
+    document::BufferContent,
+    list::ListData,
+    markdown::{
+        layout_content::{
+            layout_content_clean_up, layouts_from_contents, LayoutContent,
+        },
+        parse_documentation,
+    },
 };
-use lsp_types::CompletionItem;
-use regex::Regex;
-use std::str::FromStr;
 
 use crate::{
+    list::{List, ListPaint},
     scroll::{LapceIdentityWrapper, LapceScroll},
-    svg::completion_svg,
 };
 
-#[derive(Debug)]
-struct Snippet {
-    elements: Vec<SnippetElement>,
-}
-
-impl Snippet {
-    fn extract_elements(
-        s: &str,
-        pos: usize,
-        escs: Vec<&str>,
-        loose_escs: Vec<&str>,
-    ) -> (Vec<SnippetElement>, usize) {
-        let mut elements = Vec::new();
-        let mut pos = pos;
-        loop {
-            if s.len() == pos {
-                break;
-            } else if let Some((ele, end)) = Self::extract_tabstop(s, pos) {
-                elements.push(ele);
-                pos = end;
-            } else if let Some((ele, end)) = Self::extract_placeholder(s, pos) {
-                elements.push(ele);
-                pos = end;
-            } else if let Some((ele, end)) =
-                Self::extract_text(s, pos, escs.clone(), loose_escs.clone())
-            {
-                elements.push(ele);
-                pos = end;
-            } else {
-                break;
-            }
-        }
-        (elements, pos)
-    }
-
-    fn extract_tabstop(s: &str, pos: usize) -> Option<(SnippetElement, usize)> {
-        for re in &[
-            Regex::new(r#"^\$(\d+)"#).unwrap(),
-            Regex::new(r#"^\$\{(\d+)\}"#).unwrap(),
-        ] {
-            if let Some(caps) = re.captures(&s[pos..]) {
-                let end = pos + re.find(&s[pos..])?.end();
-                let m = caps.get(1)?;
-                let n = m.as_str().parse::<usize>().ok()?;
-                return Some((SnippetElement::Tabstop(n), end));
-            }
-        }
-
-        None
-    }
-
-    fn extract_placeholder(s: &str, pos: usize) -> Option<(SnippetElement, usize)> {
-        let re = Regex::new(r#"^\$\{(\d+):(.*?)\}"#).unwrap();
-        let end = pos + re.find(&s[pos..])?.end();
-
-        let caps = re.captures(&s[pos..])?;
-
-        let tab = caps.get(1)?.as_str().parse::<usize>().ok()?;
-
-        let m = caps.get(2)?;
-        let content = m.as_str();
-        if content.is_empty() {
-            return Some((
-                SnippetElement::PlaceHolder(
-                    tab,
-                    vec![SnippetElement::Text("".to_string())],
-                ),
-                end,
-            ));
-        }
-        let (els, pos) =
-            Self::extract_elements(s, pos + m.start(), vec!["$", "}", "\\"], vec![]);
-        Some((SnippetElement::PlaceHolder(tab, els), pos + 1))
-    }
-
-    fn extract_text(
-        s: &str,
-        pos: usize,
-        escs: Vec<&str>,
-        loose_escs: Vec<&str>,
-    ) -> Option<(SnippetElement, usize)> {
-        let mut s = &s[pos..];
-        let mut ele = "".to_string();
-        let mut end = pos;
-
-        while !s.is_empty() {
-            if s.len() >= 2 {
-                let esc = &s[..2];
-                let mut new_escs = escs.clone();
-                new_escs.extend_from_slice(&loose_escs);
-
-                if new_escs
-                    .iter()
-                    .map(|e| format!("\\{}", e))
-                    .any(|x| x == *esc)
-                {
-                    ele = ele + &s[1..2].to_string();
-                    end += 2;
-                    s = &s[2..];
-                    continue;
-                }
-            }
-            if escs.contains(&&s[0..1]) {
-                break;
-            }
-            ele = ele + &s[0..1].to_string();
-            end += 1;
-            s = &s[1..];
-        }
-        if ele.is_empty() {
-            return None;
-        }
-        Some((SnippetElement::Text(ele), end))
-    }
-}
-
-impl FromStr for Snippet {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let (elements, _) = Self::extract_elements(s, 0, vec!["$", "\\"], vec!["}"]);
-        Ok(Snippet { elements })
-    }
-}
-
-impl Display for Snippet {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let text = self.elements.iter().map(|e| e.to_string()).join("");
-        f.write_str(&text)
-    }
-}
-
-#[derive(Debug)]
-enum SnippetElement {
-    Text(String),
-    PlaceHolder(usize, Vec<SnippetElement>),
-    Tabstop(usize),
-}
-
-impl Display for SnippetElement {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match &self {
-            SnippetElement::Text(text) => f.write_str(text),
-            SnippetElement::PlaceHolder(tab, elements) => {
-                let elements = elements.iter().map(|e| e.to_string()).join("");
-                write!(f, "${{{}:{}}}", tab, elements)
-            }
-            SnippetElement::Tabstop(tab) => write!(f, "${}", tab),
-        }
-    }
-}
-
 pub struct CompletionContainer {
     id: WidgetId,
     scroll_id: WidgetId,
     completion: WidgetPod<
+        ListData<ScoredCompletionItem, ()>,
+        List<ScoredCompletionItem, ()>,
+    >,
+    completion_content_size: Size,
+    documentation: WidgetPod<
         LapceTabData,
-        LapceIdentityWrapper<LapceScroll<LapceTabData, Completion>>,
+        LapceIdentityWrapper<LapceScroll<LapceTabData, CompletionDocumentation>>,
     >,
-    content_size: Size,
+    documentation_content_size: Size,
 }
 
 impl CompletionContainer {
     pub fn new(data: &CompletionData) -> Self {
-        let completion = LapceIdentityWrapper::wrap(
-            LapceScroll::new(Completion::new()).vertical(),
-            data.scroll_id,
+        let completion = List::new(data.scroll_id);
+        let completion_doc = LapceIdentityWrapper::wrap(
+            LapceScroll::new(CompletionDocumentation::new()).vertical(),
+            data.documentation_scroll_id,
         );
         Self {
             id: data.id,
             completion: WidgetPod::new(completion),
             scroll_id: data.scroll_id,
-            content_size: Size::ZERO,
+            completion_content_size: Size::ZERO,
+            documentation: WidgetPod::new(completion_doc),
+            documentation_content_size: Size::ZERO,
         }
     }
 
@@ -205,20 +64,29 @@ impl CompletionContainer {
         data: &LapceTabData,
         env: &Env,
     ) {
-        let width = ctx.size().width;
-        let line_height = data.config.editor.line_height as f64;
-        let rect = Size::new(width, line_height)
-            .to_rect()
-            .with_origin(Point::new(
-                0.0,
-                data.completion.index as f64 * line_height,
-            ));
-        if self
-            .completion
-            .widget_mut()
-            .inner_mut()
-            .scroll_to_visible(rect, env)
-        {
+        self.completion.widget_mut().ensure_item_visible(
+            ctx,
+            &data
+                .completion
+                .completion_list
+                .clone_with(data.config.clone()),
+            env,
+        );
+    }
+
+    /// Like [`Self::ensure_item_visible`] but instead making so that it is at the very top of the display
+    /// rather than just scrolling the minimal distance to make it visible.
+    pub fn ensure_item_top_visible(
+        &mut self,
+        ctx: &mut EventCtx,
+        data: &LapceTabData,
+    ) {
+        let line_height = data.completion.completion_list.line_height() as f64;
+        let point = Point::new(
+            0.0,
+            data.completion.completion_list.selected_index as f64 * line_height,
+        );
+        if self.completion.widget_mut().scroll_to(point) {
             ctx.submit_command(Command::new(
                 LAPCE_UI_COMMAND,
                 LapceUICommand::ResetFade,
@@ -226,6 +94,43 @@ impl CompletionContainer {
             ));
         }
     }
+
+    fn update_documentation(&mut self, ctx: &mut EventCtx, data: &mut LapceTabData) {
+        if data.completion.status == CompletionStatus::Inactive {
+            return;
+        }
+
+        let documentation = if data.config.editor.completion_show_documentation {
+            let current_item = (!data.completion.is_empty())
+                .then(|| data.completion.current_item())
+                .flatten();
+
+            current_item.and_then(|item| item.item.documentation.as_ref())
+        } else {
+            None
+        };
+
+        let content = documentation
+            .map(|doc| parse_documentation(doc, &data.config))
+            .unwrap_or_default();
+
+        let doc = self.documentation.widget_mut().inner_mut().child_mut();
+
+        layout_content_clean_up(&mut doc.doc_content, data);
+        doc.doc_content = layouts_from_contents(ctx, data, content.iter());
+
+        let font = FontDescriptor::new(data.config.ui.hover_font_family())
+            .with_size(data.config.ui.hover_font_size() as f64);
+        let text_color = data
+            .config
+            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+            .clone();
+
+        for content in &mut doc.doc_content {
+            content.set_font(font.clone());
+            content.set_text_color(text_color.clone());
+        }
+    }
 }
 
 impl Widget<LapceTabData> for CompletionContainer {
@@ -244,18 +149,26 @@ impl Widget<LapceTabData> for CompletionContainer {
             Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
                 let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
                 match command {
-                    LapceUICommand::UpdateCompletion(request_id, input, resp) => {
-                        let completion = Arc::make_mut(&mut data.completion);
-                        completion.receive(
-                            *request_id,
-                            input.to_owned(),
-                            resp.to_owned(),
-                        );
+                    LapceUICommand::RefreshCompletionDocumentation => {
+                        self.update_documentation(ctx, data);
+                        ctx.request_layout();
                     }
-                    LapceUICommand::CancelCompletion(request_id) => {
-                        if data.completion.request_id == *request_id {
-                            let completion = Arc::make_mut(&mut data.completion);
-                            completion.cancel();
+                    LapceUICommand::ListItemSelected => {
+                        if let Some(editor) = data
+                            .main_split
+                            .active
+                            .and_then(|active| data.main_split.editors.get(&active))
+                            .cloned()
+                        {
+                            let mut editor_data =
+                                data.editor_view_content(editor.view_id);
+                            let doc = editor_data.doc.clone();
+                            editor_data.completion_item_select(ctx);
+                            data.update_from_editor_buffer_data(
+                                editor_data,
+                                &editor,
+                                &doc,
+                            );
                         }
                     }
                     _ => {}
@@ -263,7 +176,30 @@ impl Widget<LapceTabData> for CompletionContainer {
             }
             _ => {}
         }
-        self.completion.event(ctx, event, data, env);
+
+        let completion = Arc::make_mut(&mut data.completion);
+        completion.completion_list.update_data(data.config.clone());
+        self.completion
+            .event(ctx, event, &mut completion.completion_list, env);
+
+        if let Some(editor) = data
+            .main_split
+            .active
+            .and_then(|active| data.main_split.editors.get(&active))
+            .cloned()
+        {
+            if let BufferContent::File(path) = &editor.content {
+                if let Some(doc) = data.main_split.open_docs.get_mut(path) {
+                    completion.update_document_completion(
+                        &editor,
+                        doc,
+                        &data.config,
+                    );
+                }
+            }
+        }
+
+        self.documentation.event(ctx, event, data, env);
     }
 
     fn lifecycle(
@@ -273,7 +209,16 @@ impl Widget<LapceTabData> for CompletionContainer {
         data: &LapceTabData,
         env: &Env,
     ) {
-        self.completion.lifecycle(ctx, event, data, env);
+        self.completion.lifecycle(
+            ctx,
+            event,
+            &data
+                .completion
+                .completion_list
+                .clone_with(data.config.clone()),
+            env,
+        );
+        self.documentation.lifecycle(ctx, event, data, env);
     }
 
     fn update(
@@ -302,60 +247,109 @@ impl Widget<LapceTabData> for CompletionContainer {
             {
                 ctx.request_layout();
             }
-        }
 
-        if old_data.completion.input != data.completion.input
-            || old_data.completion.request_id != data.completion.request_id
-            || old_data.completion.status != data.completion.status
-            || !old_data
-                .completion
-                .current_items()
-                .same(data.completion.current_items())
-            || !old_data
-                .completion
-                .filtered_items
-                .same(&data.completion.filtered_items)
-        {
-            ctx.request_layout();
-        }
+            let completion_list_changed = !completion
+                .completion_list
+                .same(&old_completion.completion_list);
+            if old_data.completion.input != data.completion.input
+                || old_data.completion.request_id != data.completion.request_id
+                || old_data.completion.status != data.completion.status
+                || completion_list_changed
+            {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::RefreshCompletionDocumentation,
+                    Target::Widget(self.id),
+                ));
+            }
 
-        if (old_completion.status == CompletionStatus::Inactive
-            && completion.status != CompletionStatus::Inactive)
-            || (old_completion.input != completion.input)
-        {
-            ctx.submit_command(Command::new(
-                LAPCE_UI_COMMAND,
-                LapceUICommand::ResetFade,
-                Target::Widget(self.scroll_id),
-            ));
-        }
+            if (old_completion.status == CompletionStatus::Inactive
+                && completion.status != CompletionStatus::Inactive)
+                || (old_completion.input != completion.input)
+            {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::ResetFade,
+                    Target::Widget(self.scroll_id),
+                ));
+            }
+
+            if self
+                .documentation
+                .widget_mut()
+                .inner_mut()
+                .child_mut()
+                .needs_rebuild_after_update(ctx)
+            {
+                ctx.request_layout();
+            }
 
-        if old_completion.index != completion.index {
-            self.ensure_item_visible(ctx, data, env);
-            ctx.request_paint();
+            self.completion.update(
+                ctx,
+                &data
+                    .completion
+                    .completion_list
+                    .clone_with(data.config.clone()),
+                env,
+            );
         }
     }
 
     fn layout(
         &mut self,
         ctx: &mut LayoutCtx,
-        _bc: &BoxConstraints,
+        bc: &BoxConstraints,
         data: &LapceTabData,
         env: &Env,
     ) -> Size {
-        let size = data.completion.size;
-        let bc = BoxConstraints::new(Size::ZERO, size);
-        self.content_size = self.completion.layout(ctx, &bc, data, env);
-        self.completion.set_origin(ctx, data, env, Point::ZERO);
-        ctx.set_paint_insets((10.0, 10.0, 10.0, 10.0));
-        size
+        // TODO: Let this be configurable
+        let width = 400.0;
+
+        let bc = BoxConstraints::tight(Size::new(width, bc.max().height));
+
+        let completion_list = data
+            .completion
+            .completion_list
+            .clone_with(data.config.clone());
+        self.completion_content_size =
+            self.completion.layout(ctx, &bc, &completion_list, env);
+        self.completion
+            .set_origin(ctx, &completion_list, env, Point::ZERO);
+
+        // Position the documentation over the current completion item to the right
+        let bc = BoxConstraints::new(Size::ZERO, data.completion.documentation_size);
+        self.documentation_content_size =
+            self.documentation.layout(ctx, &bc, data, env);
+        self.documentation.set_origin(
+            ctx,
+            data,
+            env,
+            Point::new(self.completion_content_size.width, 0.0),
+        );
+
+        Size::new(
+            self.completion_content_size.width
+                + self.documentation_content_size.width,
+            self.completion_content_size
+                .height
+                .max(self.documentation_content_size.height),
+        )
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
         if data.completion.status != CompletionStatus::Inactive
             && data.completion.len() > 0
         {
-            let rect = self.content_size.to_rect();
+            let rect = self.completion_content_size.to_rect();
+
+            // Draw the background
+            ctx.fill(
+                rect,
+                data.config
+                    .get_color_unchecked(LapceTheme::COMPLETION_BACKGROUND),
+            );
+
+            // Draw the shadow
             let shadow_width = data.config.ui.drop_shadow_width() as f64;
             if shadow_width > 0.0 {
                 ctx.blurred_rect(
@@ -371,26 +365,122 @@ impl Widget<LapceTabData> for CompletionContainer {
                     1.0,
                 );
             }
-            self.completion.paint(ctx, data, env);
+
+            // Draw the completion list over the background
+            self.completion.paint(
+                ctx,
+                &data
+                    .completion
+                    .completion_list
+                    .clone_with(data.config.clone()),
+                env,
+            );
+
+            // Draw the documentation to the side
+            self.documentation.paint(ctx, data, env);
         }
     }
 }
 
-pub struct Completion {}
+impl<D: Data> ListPaint<D> for ScoredCompletionItem {
+    fn paint(
+        &self,
+        ctx: &mut PaintCtx,
+        data: &ListData<Self, D>,
+        _env: &Env,
+        line: usize,
+    ) {
+        let size = ctx.size();
+        let line_height = data.line_height() as f64;
+        if line == data.selected_index {
+            ctx.fill(
+                Rect::ZERO
+                    .with_origin(Point::new(0.0, line as f64 * line_height))
+                    .with_size(Size::new(size.width, line_height)),
+                data.config
+                    .get_color_unchecked(LapceTheme::COMPLETION_CURRENT),
+            );
+        }
 
-impl Completion {
-    pub fn new() -> Self {
-        Self {}
+        if let Some((svg, color)) = data.config.completion_svg(self.item.kind) {
+            let color = color.unwrap_or_else(|| {
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                    .clone()
+            });
+            let rect = Size::new(line_height, line_height)
+                .to_rect()
+                .with_origin(Point::new(0.0, line_height * line as f64));
+            ctx.fill(rect, &color.clone().with_alpha(0.3));
+
+            let width = 16.0;
+            let height = 16.0;
+            let rect = Size::new(width, height).to_rect().with_origin(Point::new(
+                (line_height - width) / 2.0,
+                (line_height - height) / 2.0 + line_height * line as f64,
+            ));
+            ctx.draw_svg(&svg, rect, Some(&color));
+        }
+
+        let focus_color = data.config.get_color_unchecked(LapceTheme::EDITOR_FOCUS);
+        let content = self.item.label.as_str();
+
+        let mut text_layout = ctx
+            .text()
+            .new_text_layout(content.to_string())
+            .font(
+                FontFamily::new_unchecked(data.config.editor.font_family.clone()),
+                data.config.editor.font_size as f64,
+            )
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                    .clone(),
+            );
+        for i in &self.indices {
+            let i = *i;
+            text_layout = text_layout.range_attribute(
+                i..i + 1,
+                TextAttribute::TextColor(focus_color.clone()),
+            );
+            text_layout = text_layout
+                .range_attribute(i..i + 1, TextAttribute::Weight(FontWeight::BOLD));
+        }
+        let text_layout = text_layout.build().unwrap();
+        let y = line_height * line as f64 + text_layout.y_offset(line_height);
+        let point = Point::new(line_height + 5.0, y);
+        ctx.draw_text(&text_layout, point);
     }
 }
 
-impl Default for Completion {
-    fn default() -> Self {
-        Self::new()
-    }
+struct CompletionDocumentation {
+    doc_content: Vec<LayoutContent>,
 }
+impl CompletionDocumentation {
+    const STARTING_Y: f64 = 5.0;
+    const STARTING_X: f64 = 10.0;
+
+    fn new() -> CompletionDocumentation {
+        Self {
+            doc_content: Vec::new(),
+        }
+    }
+
+    fn has_text(&self) -> bool {
+        !self.doc_content.is_empty()
+    }
+
+    fn needs_rebuild_after_update(&mut self, ctx: &mut UpdateCtx) -> bool {
+        for content in &mut self.doc_content {
+            if content.needs_rebuild_after_update(ctx) {
+                return true;
+            }
+        }
 
-impl Widget<LapceTabData> for Completion {
+        false
+    }
+}
+impl Widget<LapceTabData> for CompletionDocumentation {
     fn event(
         &mut self,
         _ctx: &mut EventCtx,
@@ -416,192 +506,69 @@ impl Widget<LapceTabData> for Completion {
         _data: &LapceTabData,
         _env: &Env,
     ) {
+        // This is managed by the completion container
     }
 
     fn layout(
         &mut self,
-        _ctx: &mut LayoutCtx,
+        ctx: &mut LayoutCtx,
         bc: &BoxConstraints,
         data: &LapceTabData,
-        _env: &Env,
+        env: &Env,
     ) -> Size {
-        let line_height = data.config.editor.line_height as f64;
-        let height = data.completion.len();
-        let height = height as f64 * line_height;
-        Size::new(bc.max().width, height)
+        if !self.has_text() {
+            return Size::ZERO;
+        }
+
+        let width = bc.max().width;
+        let max_width = width
+            - CompletionDocumentation::STARTING_X
+            - env.get(theme::SCROLLBAR_WIDTH)
+            - env.get(theme::SCROLLBAR_PAD);
+
+        let mut max_layout_width = 0.0;
+        let mut height = 0.0;
+        for layout in self.doc_content.iter_mut() {
+            layout.set_max_width(&data.images, max_width);
+            layout.rebuild_if_needed(ctx.text(), env);
+            let layout_size = layout.size(&data.images, &data.config);
+            if layout_size.width > max_layout_width {
+                max_layout_width = layout_size.width;
+            }
+
+            height += layout_size.height;
+        }
+
+        Size::new(width, height + CompletionDocumentation::STARTING_Y * 2.0)
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
-        if data.completion.status == CompletionStatus::Inactive {
+        if data.completion.status == CompletionStatus::Inactive || !self.has_text() {
             return;
         }
-        let line_height = data.config.editor.line_height as f64;
-        let rect = ctx.region().bounding_box();
-        let size = ctx.size();
 
-        let _input = &data.completion.input;
-        let items: &Vec<ScoredCompletionItem> = data.completion.current_items();
+        let rect = ctx.region().bounding_box();
 
+        // Draw the background
         ctx.fill(
             rect,
             data.config
-                .get_color_unchecked(LapceTheme::COMPLETION_BACKGROUND),
+                .get_color_unchecked(LapceTheme::HOVER_BACKGROUND),
         );
 
-        let start_line = (rect.y0 / line_height).floor() as usize;
-        let end_line = (rect.y1 / line_height).ceil() as usize;
-
-        for line in start_line..end_line {
-            if line >= items.len() {
-                break;
-            }
-
-            if line == data.completion.index {
-                ctx.fill(
-                    Rect::ZERO
-                        .with_origin(Point::new(0.0, line as f64 * line_height))
-                        .with_size(Size::new(size.width, line_height)),
-                    data.config
-                        .get_color_unchecked(LapceTheme::COMPLETION_CURRENT),
-                );
-            }
-
-            let item = &items[line];
-
-            let y = line_height * line as f64 + 5.0;
-
-            if let Some((svg, color)) = completion_svg(item.item.kind, &data.config)
-            {
-                let color = color.unwrap_or_else(|| {
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                        .clone()
-                });
-                let rect = Size::new(line_height, line_height)
-                    .to_rect()
-                    .with_origin(Point::new(0.0, line_height * line as f64));
-                ctx.fill(rect, &color.clone().with_alpha(0.3));
-
-                let width = 16.0;
-                let height = 16.0;
-                let rect =
-                    Size::new(width, height).to_rect().with_origin(Point::new(
-                        (line_height - width) / 2.0,
-                        (line_height - height) / 2.0 + line_height * line as f64,
-                    ));
-                ctx.draw_svg(&svg, rect, Some(&color));
-            }
-
-            let focus_color =
-                data.config.get_color_unchecked(LapceTheme::EDITOR_FOCUS);
-            let content = item.item.label.as_str();
-            let point = Point::new(line_height + 5.0, y);
-
-            let mut text_layout = ctx
-                .text()
-                .new_text_layout(content.to_string())
-                .font(
-                    FontFamily::new_unchecked(
-                        data.config.editor.font_family.clone(),
-                    ),
-                    data.config.editor.font_size as f64,
-                )
-                .text_color(
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                        .clone(),
-                );
-            for i in &item.indices {
-                let i = *i;
-                text_layout = text_layout.range_attribute(
-                    i..i + 1,
-                    TextAttribute::TextColor(focus_color.clone()),
-                );
-                text_layout = text_layout.range_attribute(
-                    i..i + 1,
-                    TextAttribute::Weight(FontWeight::BOLD),
-                );
-            }
-            let text_layout = text_layout.build().unwrap();
-            ctx.draw_text(&text_layout, point);
-        }
-    }
-}
+        let origin = Point::new(Self::STARTING_X, Self::STARTING_Y);
 
-#[derive(Clone)]
-pub struct CompletionState {
-    pub widget_id: WidgetId,
-    pub items: Vec<ScoredCompletionItem>,
-    pub input: String,
-    pub offset: usize,
-    pub index: usize,
-    pub scroll_offset: f64,
-}
+        let mut start_height = 0.0;
+        for layout in self.doc_content.iter_mut() {
+            layout.draw(
+                ctx,
+                &data.images,
+                &data.config,
+                origin + (0.0, start_height),
+            );
 
-impl CompletionState {
-    pub fn new() -> CompletionState {
-        CompletionState {
-            widget_id: WidgetId::next(),
-            items: Vec::new(),
-            input: "".to_string(),
-            offset: 0,
-            index: 0,
-            scroll_offset: 0.0,
+            let height = layout.size(&data.images, &data.config).height;
+            start_height += height;
         }
     }
-
-    pub fn len(&self) -> usize {
-        self.items.iter().filter(|i| i.score != 0).count()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn current_items(&self) -> Vec<&ScoredCompletionItem> {
-        self.items.iter().filter(|i| i.score != 0).collect()
-    }
-
-    pub fn clear(&mut self) {
-        self.input = "".to_string();
-        self.items = Vec::new();
-        self.offset = 0;
-        self.index = 0;
-        self.scroll_offset = 0.0;
-    }
-
-    pub fn cancel(&mut self, ctx: &mut EventCtx) {
-        self.clear();
-        self.request_paint(ctx);
-    }
-
-    pub fn request_paint(&self, ctx: &mut EventCtx) {
-        ctx.submit_command(Command::new(
-            LAPCE_UI_COMMAND,
-            LapceUICommand::RequestPaint,
-            Target::Widget(self.widget_id),
-        ));
-    }
-
-    pub fn update(&mut self, input: String, completion_items: Vec<CompletionItem>) {
-        self.items = completion_items
-            .iter()
-            .enumerate()
-            .map(|(index, item)| ScoredCompletionItem {
-                item: item.to_owned(),
-                score: -1 - index as i64,
-                label_score: -1 - index as i64,
-                indices: Vec::new(),
-            })
-            .collect();
-        self.items
-            .sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(Ordering::Less));
-        self.input = input;
-    }
-}
-
-impl Default for CompletionState {
-    fn default() -> Self {
-        Self::new()
-    }
 }
diff --git a/lapce-ui/src/diff.rs b/lapce-ui/src/diff.rs
new file mode 100644
index 0000000000..a5df3e25ac
--- /dev/null
+++ b/lapce-ui/src/diff.rs
@@ -0,0 +1,295 @@
+use crate::tab::LapceIcon;
+use druid::{
+    piet::{Text, TextLayoutBuilder},
+    BoxConstraints, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
+    LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect, RenderContext, Size, Target,
+    UpdateCtx, Widget, WidgetId,
+};
+use lapce_core::{buffer::DiffLines, command::FocusCommand};
+use lapce_data::{
+    command::{CommandKind, LapceCommand, LAPCE_COMMAND},
+    config::{LapceIcons, LapceTheme},
+    data::EditorView,
+    data::LapceTabData,
+};
+use std::ops::Range;
+
+// Diff tool box
+pub struct DiffBox {
+    parent_view_id: WidgetId,
+    result_width: f64,
+    icons: Vec<LapceIcon>,
+    mouse_pos: Point,
+}
+
+impl DiffBox {
+    pub fn new(parent_view_id: WidgetId) -> Self {
+        let icons = vec![
+            LapceIcon {
+                icon: LapceIcons::SEARCH_BACKWARD,
+                rect: Rect::ZERO,
+                command: Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Focus(FocusCommand::PreviousDiff),
+                        data: None,
+                    },
+                    Target::Widget(parent_view_id),
+                ),
+            },
+            LapceIcon {
+                icon: LapceIcons::SEARCH_FORWARD,
+                rect: Rect::ZERO,
+                command: Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Focus(FocusCommand::NextDiff),
+                        data: None,
+                    },
+                    Target::Widget(parent_view_id),
+                ),
+            },
+        ];
+        Self {
+            parent_view_id,
+            result_width: 75.0,
+            icons,
+            mouse_pos: Point::ZERO,
+        }
+    }
+
+    fn mouse_down(&self, ctx: &mut EventCtx, mouse_event: &MouseEvent) {
+        for icon in self.icons.iter() {
+            if icon.rect.contains(mouse_event.pos) {
+                ctx.submit_command(icon.command.clone());
+            }
+        }
+    }
+
+    fn icon_hit_test(&self, mouse_event: &MouseEvent) -> bool {
+        for icon in self.icons.iter() {
+            if icon.rect.contains(mouse_event.pos) {
+                return true;
+            }
+        }
+        false
+    }
+}
+
+impl Widget<LapceTabData> for DiffBox {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        _env: &Env,
+    ) {
+        let editor_data = data.editor_view_content(self.parent_view_id);
+        match &editor_data.editor.view {
+            EditorView::Diff(_) => {}
+            _ => {
+                return;
+            }
+        }
+        match event {
+            Event::MouseMove(mouse_event) => {
+                ctx.set_handled();
+                self.mouse_pos = mouse_event.pos;
+                if self.icon_hit_test(mouse_event) {
+                    ctx.set_cursor(&druid::Cursor::Pointer);
+                } else {
+                    ctx.clear_cursor();
+                }
+            }
+            Event::MouseDown(mouse_event) => {
+                ctx.set_handled();
+                self.mouse_down(ctx, mouse_event);
+            }
+            _ => {}
+        }
+    }
+
+    fn layout(
+        &mut self,
+        _ctx: &mut LayoutCtx,
+        _bc: &BoxConstraints,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) -> Size {
+        let icons_len = self.icons.len() as f64;
+        let height = 35.0;
+        let width = self.result_width + height * icons_len;
+
+        for (i, icon) in self.icons.iter_mut().enumerate() {
+            icon.rect = Size::new(height, height)
+                .to_rect()
+                .with_origin(Point::new(i as f64 * height, 0.0))
+                .inflate(-5.0, -5.0);
+        }
+
+        Size::new(width, height)
+    }
+
+    fn lifecycle(
+        &mut self,
+        _ctx: &mut LifeCycleCtx,
+        _event: &LifeCycle,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn update(
+        &mut self,
+        _ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+        let editor_data = data.editor_view_content(self.parent_view_id);
+        match &editor_data.editor.view {
+            EditorView::Diff(_) => {}
+            _ => {
+                return;
+            }
+        }
+
+        let rect = ctx.size().to_rect();
+        ctx.with_save(|ctx| {
+            ctx.clip(rect.inset((100.0, 0.0, 100.0, 100.0)));
+            let shadow_width = data.config.ui.drop_shadow_width() as f64;
+            if shadow_width > 0.0 {
+                ctx.blurred_rect(
+                    rect,
+                    shadow_width,
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                );
+            } else {
+                ctx.stroke(
+                    rect.inflate(0.5, 0.5),
+                    data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                    1.0,
+                );
+            }
+        });
+        ctx.fill(
+            rect,
+            data.config
+                .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+        );
+
+        let mut diff_blocks = Vec::new();
+        // find all diff blocks, ignore Both and Skip
+        if let Some(history) = editor_data.doc.get_history("head") {
+            for (i, change) in history.changes().iter().enumerate() {
+                match change {
+                    DiffLines::Left(_) => {
+                        if let Some(next) = history.changes().get(i + 1) {
+                            match next {
+                                DiffLines::Right(_) => {}
+                                DiffLines::Left(_) => {}
+                                DiffLines::Both(_, r) => {
+                                    diff_blocks.push(Range {
+                                        start: r.start,
+                                        end: r.start,
+                                    });
+                                }
+                                DiffLines::Skip(_, r) => {
+                                    diff_blocks.push(Range {
+                                        start: r.start,
+                                        end: r.start,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    DiffLines::Both(_, _) => {}
+                    DiffLines::Skip(_, _) => {}
+                    DiffLines::Right(r) => {
+                        diff_blocks.push(Range {
+                            start: r.start,
+                            end: r.start,
+                        });
+                    }
+                }
+            }
+        }
+        let mut index = 0;
+        let buffer = editor_data.doc.buffer();
+        let line = buffer.line_of_offset(editor_data.editor.cursor.offset());
+        let count = diff_blocks.len();
+        if count > 0 {
+            // find the block where the cursor in
+            let mut prev_end = 0;
+            for (i, block) in diff_blocks.iter().enumerate() {
+                if (i == 0 && line < block.start)
+                    || (i == count - 1 && line > block.end - 1)
+                    || (line >= block.start && line < block.end)
+                {
+                    index = i + 1;
+                    break;
+                }
+                if line < block.start {
+                    let half = (block.start + prev_end) / 2;
+                    if line > half {
+                        index = i + 1;
+                        break;
+                    } else {
+                        index = i;
+                        break;
+                    }
+                }
+                prev_end = block.end;
+            }
+        }
+
+        let text_layout = ctx
+            .text()
+            .new_text_layout(format!("{index}/{count}"))
+            .font(
+                data.config.ui.font_family(),
+                data.config.ui.font_size() as f64,
+            )
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                    .clone(),
+            )
+            .max_width(self.result_width)
+            .build()
+            .unwrap();
+        ctx.draw_text(
+            &text_layout,
+            Point::new(
+                10.0 + 35.0 * self.icons.len() as f64,
+                text_layout.y_offset(35.0),
+            ),
+        );
+
+        for icon in self.icons.iter() {
+            if icon.rect.contains(self.mouse_pos) {
+                ctx.fill(
+                    icon.rect,
+                    &data.config.get_hover_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+                    ),
+                );
+            }
+
+            let svg = data.config.ui_svg(icon.icon);
+            ctx.draw_svg(
+                &svg,
+                icon.rect.inflate(-7.0, -7.0),
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                ),
+            );
+        }
+    }
+}
diff --git a/lapce-ui/src/dropdown.rs b/lapce-ui/src/dropdown.rs
new file mode 100644
index 0000000000..6f77951155
--- /dev/null
+++ b/lapce-ui/src/dropdown.rs
@@ -0,0 +1,326 @@
+use druid::{
+    piet::{Text, TextLayoutBuilder},
+    BoxConstraints, Command, Data, Env, Event, EventCtx, LayoutCtx, LifeCycle,
+    LifeCycleCtx, PaintCtx, Point, RenderContext, Size, Target, UpdateCtx, Widget,
+    WidgetId, WidgetPod,
+};
+use lapce_data::{
+    command::{LapceUICommand, LAPCE_UI_COMMAND},
+    config::{LapceIcons, LapceTheme},
+    dropdown::DropdownData,
+    list::ListData,
+};
+
+use crate::list::{List, ListPaint};
+
+pub const DROPDOWN_SIZE: Size = Size::new(300.0, 30.0);
+
+pub struct DropdownSelector<
+    T: Clone + DropdownPaint<D> + PartialEq + 'static,
+    D: Data,
+> {
+    widget_id: WidgetId,
+
+    dropdown_list: WidgetPod<DropdownData<T, D>, DropdownList<T, D>>,
+}
+impl<T: Clone + DropdownPaint<D> + PartialEq + 'static, D: Data> Default
+    for DropdownSelector<T, D>
+{
+    fn default() -> Self {
+        let dropdown_list = WidgetPod::new(DropdownList::default());
+
+        Self {
+            widget_id: WidgetId::next(),
+
+            dropdown_list,
+        }
+    }
+}
+impl<T: Clone + DropdownPaint<D> + PartialEq + 'static, D: Data>
+    Widget<DropdownData<T, D>> for DropdownSelector<T, D>
+{
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.widget_id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut DropdownData<T, D>,
+        env: &Env,
+    ) {
+        if event.should_propagate_to_hidden() || data.list_active {
+            self.dropdown_list.event(ctx, event, data, env);
+        }
+
+        // TODO: Hover event should highlight it and change the cursor
+        if let Event::MouseUp(_) = event {
+            if data.list_active {
+                data.hide();
+            } else {
+                data.show();
+            }
+
+            ctx.request_focus();
+            ctx.request_layout();
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &DropdownData<T, D>,
+        env: &Env,
+    ) {
+        self.dropdown_list.lifecycle(ctx, event, data, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &DropdownData<T, D>,
+        data: &DropdownData<T, D>,
+        env: &Env,
+    ) {
+        if data.list_active != old_data.list_active {
+            ctx.request_layout();
+        }
+
+        if data.list_active {
+            self.dropdown_list.update(ctx, data, env);
+        }
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        _bc: &BoxConstraints,
+        data: &DropdownData<T, D>,
+        env: &Env,
+    ) -> Size {
+        let list_size = if data.list_active {
+            let height = data.list.config.editor.line_height() as f64 * 10.0;
+            let bc = BoxConstraints::tight(Size::new(DROPDOWN_SIZE.width, height));
+            let list_size = self.dropdown_list.layout(ctx, &bc, data, env);
+            let list_origin = Point::new(0.0, DROPDOWN_SIZE.height);
+            self.dropdown_list.set_origin(ctx, data, env, list_origin);
+
+            list_size
+        } else {
+            Size::ZERO
+        };
+
+        Size::new(
+            DROPDOWN_SIZE.width.max(list_size.width),
+            DROPDOWN_SIZE.height + list_size.height,
+        )
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &DropdownData<T, D>, env: &Env) {
+        let svg_size = data.list.config.ui.icon_size() as f64;
+        let svg_y = (DROPDOWN_SIZE.height - svg_size) / 2.0;
+        ctx.draw_svg(
+            &data.list.config.ui_svg(LapceIcons::DROPDOWN_ARROW),
+            Size::new(svg_size, svg_size)
+                .to_rect()
+                .with_origin(Point::new(1.0, svg_y)),
+            Some(
+                data.list
+                    .config
+                    .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+            ),
+        );
+
+        ctx.stroke(
+            Size::new(DROPDOWN_SIZE.width - 1.0, DROPDOWN_SIZE.height)
+                .to_rect()
+                .with_origin(Point::new(1.0, 0.0)),
+            data.list
+                .config
+                .get_color_unchecked(LapceTheme::LAPCE_BORDER),
+            1.0,
+        );
+
+        if let Some(item) = data.get_active_item() {
+            let origin = Point::new(svg_size * 1.5, 0.0);
+            item.paint_active(ctx, data, env, origin);
+        }
+
+        if data.list_active {
+            self.dropdown_list.paint(ctx, data, env);
+        }
+    }
+}
+
+pub struct DropdownList<T: Clone + DropdownPaint<D> + PartialEq + 'static, D: Data> {
+    widget_id: WidgetId,
+    list: WidgetPod<ListData<T, D>, List<T, D>>,
+}
+impl<T: Clone + DropdownPaint<D> + PartialEq + 'static, D: Data> Default
+    for DropdownList<T, D>
+{
+    fn default() -> Self {
+        let widget_id = WidgetId::next();
+        let scroll_id = WidgetId::next();
+        let list = WidgetPod::new(List::new(scroll_id));
+        Self { widget_id, list }
+    }
+}
+impl<T: Clone + DropdownPaint<D> + PartialEq + 'static, D: Data>
+    Widget<DropdownData<T, D>> for DropdownList<T, D>
+{
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.widget_id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut DropdownData<T, D>,
+        env: &Env,
+    ) {
+        // The caller should call `update_data` on the DropdownData before passing it to us
+        // and the DropdownData updating also updates the list
+        self.list.event(ctx, event, &mut data.list, env);
+
+        match event {
+            Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
+                let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
+                let pre_active_idx = data.active_item_index;
+                match command {
+                    LapceUICommand::Hide => {
+                        // TODO: Should we have an option on the dropdown for whether we should
+                        // update the current active item when the dropdown is hidden (rather
+                        // than typical selection)?
+                        data.update_active_item();
+                        data.hide();
+                        ctx.request_layout();
+                    }
+                    LapceUICommand::ListItemSelected => {
+                        data.update_active_item();
+                        data.hide();
+                        ctx.request_layout();
+                    }
+                    _ => {}
+                }
+
+                if pre_active_idx != data.active_item_index {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::DropdownItemSelected,
+                        Target::Widget(data.list.parent),
+                    ));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &DropdownData<T, D>,
+        env: &Env,
+    ) {
+        if let LifeCycle::FocusChanged(focus) = event {
+            if !focus {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::Hide,
+                    Target::Widget(self.widget_id),
+                ));
+            }
+        }
+
+        self.list.lifecycle(ctx, event, &data.list, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        _old_data: &DropdownData<T, D>,
+        data: &DropdownData<T, D>,
+        env: &Env,
+    ) {
+        self.list.update(ctx, &data.list, env);
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &DropdownData<T, D>,
+        env: &Env,
+    ) -> Size {
+        let list_size = if data.list_active {
+            self.list.layout(ctx, bc, &data.list, env)
+        } else {
+            Size::ZERO
+        };
+
+        self.list.set_origin(ctx, &data.list, env, Point::ZERO);
+
+        ctx.set_paint_insets(4000.0);
+
+        list_size
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &DropdownData<T, D>, env: &Env) {
+        if data.list_active {
+            let rect = ctx.size().to_rect();
+            ctx.fill(
+                rect,
+                data.list
+                    .config
+                    .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+            );
+            self.list.paint(ctx, &data.list, env);
+        }
+    }
+}
+
+pub trait DropdownPaint<D: Data>: ListPaint<D> {
+    /// Paint the active item (aka the item displayed within the button itself)
+    fn paint_active(
+        &self,
+        ctx: &mut PaintCtx,
+        data: &DropdownData<Self, D>,
+        env: &Env,
+        origin: Point,
+    );
+}
+
+impl<D: Data> DropdownPaint<D> for String {
+    fn paint_active(
+        &self,
+        ctx: &mut PaintCtx,
+        data: &DropdownData<Self, D>,
+        _env: &Env,
+        origin: Point,
+    ) {
+        let line_height = data.list.config.ui.list_line_height() as f64;
+        let text_layout = ctx
+            .text()
+            .new_text_layout(self.clone())
+            .font(
+                data.list.config.ui.font_family(),
+                data.list.config.ui.font_size() as f64,
+            )
+            .text_color(
+                data.list
+                    .config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+
+        let point =
+            Point::new(1.0 + origin.x, text_layout.y_offset(line_height) + origin.y);
+        ctx.draw_text(&text_layout, point);
+    }
+}
diff --git a/lapce-ui/src/editor.rs b/lapce-ui/src/editor.rs
index 99e7c3b845..fd63ddfb2e 100644
--- a/lapce-ui/src/editor.rs
+++ b/lapce-ui/src/editor.rs
@@ -1,39 +1,39 @@
-use std::time::Duration;
-use std::{iter::Iterator, sync::Arc};
+use std::{collections::HashMap, iter::Iterator, sync::Arc, time::Duration};
 
-use druid::TimerToken;
 use druid::{
     kurbo::{BezPath, Line},
     piet::{PietText, PietTextLayout, Text, TextLayout as _, TextLayoutBuilder},
     BoxConstraints, Color, Command, Env, Event, EventCtx, InternalLifeCycle,
-    LayoutCtx, LifeCycle, LifeCycleCtx, MouseButton, MouseEvent, PaintCtx, Point,
-    Rect, RenderContext, Size, Target, UpdateCtx, Widget, WidgetId,
+    LayoutCtx, LifeCycle, LifeCycleCtx, Modifiers, MouseButton, MouseEvent,
+    PaintCtx, Point, Rect, RenderContext, Size, Target, TimerToken, UpdateCtx,
+    Widget, WidgetId,
 };
-use lapce_core::buffer::DiffLines;
-use lapce_core::command::EditCommand;
 use lapce_core::{
-    command::FocusCommand,
+    buffer::DiffLines,
+    command::{EditCommand, FocusCommand},
     cursor::{ColPosition, CursorMode},
     mode::{Mode, VisualMode},
-    movement::Movement,
 };
-use lapce_data::command::CommandKind;
-use lapce_data::data::{EditorView, LapceData};
-use lapce_data::document::{BufferContent, LocalBufferKind};
-use lapce_data::keypress::KeyPressFocus;
-use lapce_data::menu::MenuKind;
 use lapce_data::{
     command::{
-        LapceCommand, LapceUICommand, LapceWorkbenchCommand, LAPCE_UI_COMMAND,
+        CommandKind, LapceCommand, LapceUICommand, LapceWorkbenchCommand,
+        LAPCE_UI_COMMAND,
     },
-    config::{Config, LapceTheme},
-    data::{LapceTabData, PanelData, PanelKind},
+    config::{LapceConfig, LapceTheme},
+    data::{EditorView, LapceData, LapceTabData},
+    document::{BufferContent, LocalBufferKind},
     editor::{LapceEditorBufferData, Syntax},
-    menu::MenuItem,
-    panel::PanelPosition,
+    history::DocumentHistory,
+    hover::HoverStatus,
+    keypress::KeyPressFocus,
+    menu::{MenuItem, MenuKind},
+    palette::{PaletteStatus, PaletteType},
+    panel::{PanelData, PanelKind},
+    selection_range::SyntaxSelectionRanges,
 };
 use lsp_types::{CodeActionOrCommand, DiagnosticSeverity};
 
+pub mod bread_crumb;
 pub mod container;
 pub mod gutter;
 pub mod header;
@@ -42,12 +42,25 @@ pub mod tab_header;
 pub mod tab_header_content;
 pub mod view;
 
+struct ScreenLines {
+    lines: Vec<usize>,
+    info: HashMap<usize, LineInfo>,
+}
+
+struct LineInfo {
+    font_size: usize,
+    x: f64,
+    y: f64,
+    line_height: f64,
+}
+
 pub struct LapceEditor {
     view_id: WidgetId,
     editor_id: WidgetId,
     placeholder: Option<String>,
 
     mouse_pos: Point,
+    mouse_mods: Modifiers,
     /// A timer for listening for when the user has hovered for long enough to trigger showing
     /// of hover info (if there is any)
     mouse_hover_timer: TimerToken,
@@ -61,6 +74,7 @@ impl LapceEditor {
             editor_id,
             placeholder: None,
             mouse_pos: Point::ZERO,
+            mouse_mods: Modifiers::empty(),
             mouse_hover_timer: TimerToken::INVALID,
             drag_timer: TimerToken::INVALID,
         }
@@ -84,13 +98,13 @@ impl LapceEditor {
         &mut self,
         ctx: &mut EventCtx,
         editor_data: &LapceEditorBufferData,
-        config: &Config,
+        config: &LapceConfig,
     ) -> bool {
         if !ctx.is_active() {
             return false;
         }
 
-        let line_height = config.editor.line_height as f64;
+        let line_height = config.editor.line_height() as f64;
         let scroll_offset = editor_data.editor.scroll_offset;
         let size = *editor_data.editor.size.borrow();
 
@@ -144,8 +158,9 @@ impl LapceEditor {
         &mut self,
         ctx: &mut EventCtx,
         mouse_pos: Point,
+        mods: Modifiers,
         editor_data: &mut LapceEditorBufferData,
-        config: &Config,
+        config: &LapceConfig,
     ) {
         let mouse_actually_moved = self.mouse_pos != mouse_pos;
         self.mouse_pos = mouse_pos;
@@ -162,11 +177,11 @@ impl LapceEditor {
                 ctx.text(),
                 editor_data.get_mode(),
                 mouse_pos,
-                config.editor.font_size,
+                &editor_data.editor.view,
                 config,
             );
             let editor = Arc::make_mut(&mut editor_data.editor);
-            editor.cursor.set_offset(new_offset, true, false);
+            editor.cursor.set_offset(new_offset, true, mods.alt());
             return;
         }
 
@@ -174,13 +189,14 @@ impl LapceEditor {
             ctx.text(),
             Mode::Insert,
             mouse_pos,
-            config.editor.font_size,
+            &editor_data.editor.view,
             config,
         );
         let within_scroll = self.mouse_within_scroll(editor_data, mouse_pos);
         if !editor_data.check_hover(ctx, offset, is_inside, within_scroll)
             && is_inside
             && within_scroll
+            && !editor_data.rename.mouse_within
         {
             self.mouse_hover_timer = ctx.request_timer(
                 Duration::from_millis(config.editor.hover_delay),
@@ -193,29 +209,42 @@ impl LapceEditor {
         &mut self,
         ctx: &mut EventCtx,
         mouse_event: &MouseEvent,
-        editor_data: &mut LapceEditorBufferData,
-        config: &Config,
-    ) {
+        data: &mut LapceTabData,
+        env: &Env,
+    ) -> LapceEditorBufferData {
+        let mut editor_data = data.editor_view_content(self.view_id);
+
         ctx.set_handled();
         match mouse_event.button {
             MouseButton::Left => {
-                self.left_click(ctx, mouse_event, editor_data, config);
+                self.left_click(ctx, mouse_event, &mut editor_data, &data.config);
                 editor_data.get_code_actions(ctx);
                 editor_data.cancel_completion();
                 // TODO: Don't cancel over here, because it would good to allow the user to
-                // select text inside the hover data
+                // select text inside the hover/signature data
+                editor_data.cancel_signature();
                 editor_data.cancel_hover();
             }
             MouseButton::Right => {
                 self.mouse_hover_timer = TimerToken::INVALID;
-                self.right_click(ctx, editor_data, mouse_event, config);
+                self.right_click(ctx, &mut editor_data, mouse_event, &data.config);
                 editor_data.get_code_actions(ctx);
                 editor_data.cancel_completion();
+                editor_data.cancel_signature();
                 editor_data.cancel_hover();
             }
-            MouseButton::Middle => {}
-            _ => (),
+            _ => {
+                let mut keypress = data.keypress.clone();
+                let _ = Arc::make_mut(&mut keypress).key_down(
+                    ctx,
+                    mouse_event,
+                    &mut editor_data,
+                    env,
+                );
+            }
         }
+
+        editor_data
     }
 
     fn left_click(
@@ -223,7 +252,7 @@ impl LapceEditor {
         ctx: &mut EventCtx,
         mouse_event: &MouseEvent,
         editor_data: &mut LapceEditorBufferData,
-        config: &Config,
+        config: &LapceConfig,
     ) {
         match mouse_event.count {
             1 => {
@@ -244,13 +273,13 @@ impl LapceEditor {
         ctx: &mut EventCtx,
         editor_data: &mut LapceEditorBufferData,
         mouse_event: &MouseEvent,
-        config: &Config,
+        config: &LapceConfig,
     ) {
         let (offset, _) = editor_data.doc.offset_of_point(
             ctx.text(),
             editor_data.get_mode(),
             mouse_event.pos,
-            config.editor.font_size,
+            &editor_data.editor.view,
             config,
         );
 
@@ -263,46 +292,109 @@ impl LapceEditor {
             editor_data.single_click(ctx, mouse_event, config);
         }
 
-        let menu_items = vec![
-            MenuKind::Item(MenuItem {
-                desc: None,
-                command: LapceCommand {
-                    kind: CommandKind::Focus(FocusCommand::GotoDefinition),
-                    data: None,
-                },
-            }),
-            MenuKind::Item(MenuItem {
-                desc: None,
-                command: LapceCommand {
-                    kind: CommandKind::Workbench(
-                        LapceWorkbenchCommand::PaletteCommand,
-                    ),
-                    data: None,
-                },
-            }),
-            MenuKind::Separator,
-            MenuKind::Item(MenuItem {
-                desc: None,
-                command: LapceCommand {
-                    kind: CommandKind::Edit(EditCommand::ClipboardCut),
-                    data: None,
-                },
-            }),
-            MenuKind::Item(MenuItem {
-                desc: None,
-                command: LapceCommand {
-                    kind: CommandKind::Edit(EditCommand::ClipboardCopy),
-                    data: None,
-                },
-            }),
-            MenuKind::Item(MenuItem {
-                desc: None,
-                command: LapceCommand {
-                    kind: CommandKind::Edit(EditCommand::ClipboardPaste),
-                    data: None,
-                },
-            }),
-        ];
+        let menu_items = if let BufferContent::File(_) = editor_data.doc.content() {
+            vec![
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Focus(FocusCommand::GotoDefinition),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Focus(FocusCommand::GotoTypeDefinition),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+                MenuKind::Separator,
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Focus(FocusCommand::Rename),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+                MenuKind::Separator,
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Edit(EditCommand::ClipboardCut),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Edit(EditCommand::ClipboardCopy),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Edit(EditCommand::ClipboardPaste),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+                MenuKind::Separator,
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Workbench(
+                            LapceWorkbenchCommand::PaletteCommand,
+                        ),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+            ]
+        } else {
+            vec![
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Edit(EditCommand::ClipboardCut),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Edit(EditCommand::ClipboardCopy),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Edit(EditCommand::ClipboardPaste),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+                MenuKind::Separator,
+                MenuKind::Item(MenuItem {
+                    desc: None,
+                    command: LapceCommand {
+                        kind: CommandKind::Workbench(
+                            LapceWorkbenchCommand::PaletteCommand,
+                        ),
+                        data: None,
+                    },
+                    enabled: true,
+                }),
+            ]
+        };
 
         ctx.submit_command(Command::new(
             LAPCE_UI_COMMAND,
@@ -318,16 +410,16 @@ impl LapceEditor {
         data: &LapceEditorBufferData,
         text: &mut PietText,
         editor_size: Size,
-        panels: &im::HashMap<PanelPosition, Arc<PanelData>>,
+        panel: &PanelData,
         env: &Env,
     ) -> Size {
-        let line_height = data.config.editor.line_height as f64;
+        let line_height = data.config.editor.line_height() as f64;
         let width = data.config.editor_char_width(text);
         match &data.editor.content {
             BufferContent::File(_)
             | BufferContent::Scratch(..)
             | BufferContent::Local(LocalBufferKind::Empty) => {
-                if data.editor.code_lens {
+                if data.editor.is_code_lens() {
                     if let Some(syntax) = data.doc.syntax() {
                         let height =
                             syntax.lens.height_of_line(syntax.lens.len() + 1);
@@ -380,6 +472,7 @@ impl LapceEditor {
                 } else {
                     Size::new(
                         (width * data.doc.buffer().max_len() as f64)
+                            .max(data.doc.text_layouts.borrow().max_width)
                             .max(editor_size.width),
                         if data.config.editor.scroll_beyond_last_line {
                             (line_height * data.doc.buffer().num_lines() as f64
@@ -394,34 +487,26 @@ impl LapceEditor {
                 }
             }
             BufferContent::Local(LocalBufferKind::SourceControl) => {
-                for (pos, panels) in panels.iter() {
-                    for panel_kind in panels.widgets.iter() {
-                        if panel_kind == &PanelKind::SourceControl {
-                            return match pos {
-                                PanelPosition::BottomLeft
-                                | PanelPosition::BottomRight => {
-                                    let width = 200.0;
-                                    Size::new(width, editor_size.height)
-                                }
-                                _ => {
-                                    let height = 100.0f64;
-                                    let height = height.max(
-                                        line_height
-                                            * data.doc.buffer().num_lines() as f64,
-                                    );
-                                    Size::new(
-                                        (width * data.doc.buffer().max_len() as f64)
-                                            .max(editor_size.width),
-                                        height,
-                                    )
-                                }
-                            };
-                        }
-                    }
+                let is_bottom = panel
+                    .panel_position(&PanelKind::SourceControl)
+                    .map(|(_, pos)| pos.is_bottom())
+                    .unwrap_or(false);
+                if is_bottom {
+                    let width = 200.0;
+                    Size::new(width, editor_size.height)
+                } else {
+                    let height = 100.0f64;
+                    let height = height
+                        .max(line_height * data.doc.buffer().num_lines() as f64);
+                    Size::new(
+                        (width * data.doc.buffer().max_len() as f64)
+                            .max(editor_size.width),
+                        height,
+                    )
                 }
-                Size::ZERO
             }
-            _ => Size::new(
+            // Almost the same as the general case below but with less vertical padding
+            BufferContent::Local(LocalBufferKind::PathName) => Size::new(
                 editor_size.width.max(
                     data.doc
                         .get_text_layout(
@@ -430,41 +515,45 @@ impl LapceEditor {
                             data.config.editor.font_size,
                             &data.config,
                         )
+                        .text
                         .size()
                         .width,
                 ),
                 env.get(LapceTheme::INPUT_LINE_HEIGHT)
-                    + env.get(LapceTheme::INPUT_LINE_PADDING) * 2.0,
+                    + env.get(LapceTheme::INPUT_LINE_PADDING),
+            ),
+            _ => Size::new(
+                editor_size.width.max(
+                    data.doc
+                        .get_text_layout(
+                            text,
+                            0,
+                            data.config.editor.font_size,
+                            &data.config,
+                        )
+                        .text
+                        .size()
+                        .width,
+                ),
+                if data.editor.content.is_palette() {
+                    env.get(LapceTheme::PALETTE_INPUT_LINE_HEIGHT)
+                        + env.get(LapceTheme::PALETTE_INPUT_LINE_PADDING) * 2.0
+                } else {
+                    env.get(LapceTheme::INPUT_LINE_HEIGHT)
+                        + env.get(LapceTheme::INPUT_LINE_PADDING) * 2.0
+                },
             ),
         }
     }
 
-    pub fn paint_code_lens_content(
-        data: &LapceEditorBufferData,
+    fn code_lens_lines(
         ctx: &mut PaintCtx,
-        is_focused: bool,
-    ) {
-        let rect = ctx.region().bounding_box();
-        let ref_text_layout = ctx
-            .text()
-            .new_text_layout("W")
-            .font(
-                data.config.editor.font_family(),
-                data.config.editor.font_size as f64,
-            )
-            .build()
-            .unwrap();
-        let char_width = ref_text_layout.size().width;
-        let y_shift = (data.config.editor.line_height as f64
-            - ref_text_layout.size().height)
-            / 2.0;
-        let small_char_width = data
-            .config
-            .char_width(ctx.text(), data.config.editor.code_lens_font_size as f64);
-
+        data: &LapceEditorBufferData,
+        _env: &Env,
+    ) -> ScreenLines {
         let empty_lens = Syntax::lens_from_normal_lines(
             data.doc.buffer().len(),
-            data.config.editor.line_height,
+            data.config.editor.line_height(),
             data.config.editor.code_lens_font_size,
             &[],
         );
@@ -474,14 +563,17 @@ impl LapceEditor {
             &empty_lens
         };
 
-        let cursor_line = data.doc.buffer().line_of_offset(
-            data.editor.cursor.offset().min(data.doc.buffer().len()),
-        );
+        let normal_font_size = data.config.editor.font_size;
+        let small_font_size = data.config.editor.code_lens_font_size;
+
+        let rect = ctx.region().bounding_box();
         let last_line = data.doc.buffer().line_of_offset(data.doc.buffer().len());
         let start_line =
             lens.line_of_height(rect.y0.floor() as usize).min(last_line);
         let end_line = lens
-            .line_of_height(rect.y1.ceil() as usize + data.config.editor.line_height)
+            .line_of_height(
+                rect.y1.ceil() as usize + data.config.editor.line_height(),
+            )
             .min(last_line);
         let start_offset = data.doc.buffer().offset_of_line(start_line);
         let end_offset = data.doc.buffer().offset_of_line(end_line + 1);
@@ -489,346 +581,318 @@ impl LapceEditor {
             data.doc.buffer().text().lines(start_offset..end_offset);
 
         let mut y = lens.height_of_line(start_line) as f64;
+        let mut lines = Vec::new();
+        let mut info = HashMap::new();
         for (line, line_height) in lens.iter_chunks(start_line..end_line + 1) {
             if let Some(line_content) = lines_iter.next() {
-                let is_small = line_height < data.config.editor.line_height;
-
+                let is_small = line_height < data.config.editor.line_height();
                 let mut x = 0.0;
+
                 if is_small {
+                    let mut col = 0usize;
                     for ch in line_content.chars() {
-                        if ch == ' ' {
-                            x += char_width - small_char_width;
-                        } else if ch == '\t' {
-                            x += (char_width - small_char_width)
-                                * data.config.editor.tab_width as f64;
+                        if ch == ' ' || ch == '\t' {
+                            col += 1;
                         } else {
                             break;
                         }
                     }
+
+                    let normal_text_layout = data.doc.get_text_layout(
+                        ctx.text(),
+                        line,
+                        normal_font_size,
+                        &data.config,
+                    );
+                    let small_text_layout = data.doc.get_text_layout(
+                        ctx.text(),
+                        line,
+                        small_font_size,
+                        &data.config,
+                    );
+
+                    if col > 0 {
+                        x = normal_text_layout
+                            .text
+                            .hit_test_text_position(col)
+                            .point
+                            .x
+                            - small_text_layout
+                                .text
+                                .hit_test_text_position(col)
+                                .point
+                                .x;
+                    }
                 }
 
-                Self::paint_cursor_on_line(
-                    data,
-                    ctx,
-                    is_focused,
-                    cursor_line,
-                    line,
-                    x,
-                    y,
-                    if is_small {
-                        small_char_width
-                    } else {
-                        char_width
-                    },
-                    line_height as f64,
-                );
-                let text_layout = data.doc.get_text_layout(
-                    ctx.text(),
+                let line_height = line_height as f64;
+
+                lines.push(line);
+                info.insert(
                     line,
-                    if is_small {
-                        data.config.editor.code_lens_font_size
-                    } else {
-                        data.config.editor.font_size
+                    LineInfo {
+                        font_size: if is_small {
+                            data.config.editor.code_lens_font_size
+                        } else {
+                            data.config.editor.font_size
+                        },
+                        x,
+                        y,
+                        line_height,
                     },
-                    &data.config,
-                );
-                ctx.draw_text(
-                    &text_layout,
-                    Point::new(x, if is_small { y } else { y + y_shift }),
                 );
-                y += line_height as f64;
+                y += line_height;
             }
         }
+        ScreenLines { lines, info }
     }
 
-    fn paint_content(
-        &mut self,
-        data: &LapceEditorBufferData,
+    fn content_history_lines(
         ctx: &mut PaintCtx,
-        is_focused: bool,
+        data: &LapceEditorBufferData,
+        history: &DocumentHistory,
         env: &Env,
-    ) {
+    ) -> ScreenLines {
         let line_height = Self::line_height(data, env);
-        let line_padding = Self::line_padding(data, env);
-
         let font_size = if data.editor.content.is_input() {
             env.get(LapceTheme::INPUT_FONT_SIZE) as usize
         } else {
             data.config.editor.font_size
         };
 
-        let text_layout = ctx
-            .text()
-            .new_text_layout("W")
-            .font(data.config.editor.font_family(), font_size as f64)
-            .build()
-            .unwrap();
-        let char_width = text_layout.size().width;
-        let y_shift = (line_height - text_layout.size().height) / 2.0;
-
-        //if data.editor.content.is_input()
-        //    || (data.editor.compare.is_none() && !data.editor.code_lens)
-        //{
-        // Self::paint_cursor(
-        //     data,
-        //     ctx,
-        //     is_focused,
-        //     self.placeholder.as_ref(),
-        //     char_width,
-        //     env,
-        // );
-        // Self::paint_find(data, ctx, char_width, env);
-        //}
         let self_size = ctx.size();
         let rect = ctx.region().bounding_box();
         let start_line = (rect.y0 / line_height).floor() as usize;
         let end_line = (rect.y1 / line_height).ceil() as usize;
 
-        if !data.editor.content.is_input() && data.editor.code_lens {
-            Self::paint_code_lens_content(data, ctx, is_focused);
-        } else if let EditorView::Diff(version) = &data.editor.view {
-            if let Some(history) = data.doc.get_history(version) {
-                let cursor_line = data
-                    .doc
-                    .buffer()
-                    .line_of_offset(data.editor.cursor.offset());
-                let mut line = 0;
-                for change in history.changes().iter() {
-                    match change {
-                        DiffLines::Left(range) => {
-                            let len = range.len();
-                            line += len;
-
-                            if line < start_line {
-                                continue;
-                            }
-                            ctx.fill(
-                                Size::new(self_size.width, line_height * len as f64)
-                                    .to_rect()
-                                    .with_origin(Point::new(
-                                        0.0,
-                                        line_height * (line - len) as f64,
-                                    )),
-                                data.config.get_color_unchecked(
-                                    LapceTheme::SOURCE_CONTROL_REMOVED,
-                                ),
-                            );
-                            for l in line - len..line {
-                                if l < start_line {
-                                    continue;
-                                }
-                                let actual_line = l - (line - len) + range.start;
-                                let text_layout = history.get_text_layout(
-                                    ctx.text(),
-                                    actual_line,
-                                    &data.config,
-                                );
-                                ctx.draw_text(
-                                    &text_layout,
-                                    Point::new(
-                                        0.0,
-                                        line_height * l as f64 + y_shift,
-                                    ),
-                                );
+        let mut line = 0;
+        let mut lines = Vec::new();
+        let mut info = HashMap::new();
+        for change in history.changes().iter() {
+            match change {
+                DiffLines::Left(range) => {
+                    let len = range.len();
+                    line += len;
 
-                                if l > end_line {
-                                    break;
-                                }
-                            }
+                    if line < start_line {
+                        continue;
+                    }
+                    ctx.fill(
+                        Size::new(self_size.width, line_height * len as f64)
+                            .to_rect()
+                            .with_origin(Point::new(
+                                0.0,
+                                line_height * (line - len) as f64,
+                            )),
+                        data.config
+                            .get_color_unchecked(LapceTheme::SOURCE_CONTROL_REMOVED),
+                    );
+                    for l in line - len..line {
+                        if l < start_line {
+                            continue;
                         }
-                        DiffLines::Skip(left, right) => {
-                            let rect = Size::new(self_size.width, line_height)
-                                .to_rect()
-                                .with_origin(Point::new(
-                                    0.0,
-                                    line_height * line as f64,
-                                ));
-                            ctx.fill(
-                                rect,
-                                data.config.get_color_unchecked(
-                                    LapceTheme::PANEL_BACKGROUND,
-                                ),
-                            );
-                            ctx.stroke(
-                                rect,
-                                data.config.get_color_unchecked(
-                                    LapceTheme::EDITOR_FOREGROUND,
-                                ),
-                                1.0,
-                            );
-                            let text_layout = ctx
-                                .text()
-                                .new_text_layout(format!(
-                                    " -{}, +{}",
-                                    left.end + 1,
-                                    right.end + 1
-                                ))
-                                .font(
-                                    data.config.editor.font_family(),
-                                    font_size as f64,
-                                )
-                                .text_color(
-                                    data.config
-                                        .get_color_unchecked(
-                                            LapceTheme::EDITOR_FOREGROUND,
-                                        )
-                                        .clone(),
-                                )
-                                .build()
-                                .unwrap();
-                            ctx.draw_text(
-                                &text_layout,
-                                Point::new(0.0, line_height * line as f64 + y_shift),
-                            );
-                            line += 1;
+                        let actual_line = l - (line - len) + range.start;
+                        let text_layout = history.get_text_layout(
+                            ctx.text(),
+                            actual_line,
+                            &data.config,
+                        );
+                        ctx.draw_text(
+                            &text_layout.text,
+                            Point::new(
+                                0.0,
+                                line_height * l as f64
+                                    + text_layout.text.y_offset(line_height),
+                            ),
+                        );
+
+                        if l > end_line {
+                            break;
                         }
-                        DiffLines::Both(_left, right) => {
-                            let len = right.len();
-                            line += len;
-                            if line < start_line {
-                                continue;
-                            }
-                            for l in line - len..line {
-                                if l < start_line {
-                                    continue;
-                                }
-                                let rope_line = l - (line - len) + right.start;
-                                Self::paint_cursor_on_line(
-                                    data,
-                                    ctx,
-                                    is_focused,
-                                    cursor_line,
-                                    rope_line,
-                                    0.0,
-                                    l as f64 * line_height,
-                                    char_width,
-                                    line_height,
-                                );
-                                let text_layout = data.doc.get_text_layout(
-                                    ctx.text(),
-                                    rope_line,
-                                    font_size,
-                                    &data.config,
-                                );
-                                ctx.draw_text(
-                                    &text_layout,
-                                    Point::new(
-                                        0.0,
-                                        line_height * l as f64 + y_shift,
-                                    ),
-                                );
-                                if l > end_line {
-                                    break;
-                                }
-                            }
+                    }
+                }
+                DiffLines::Skip(left, right) => {
+                    let rect = Size::new(self_size.width, line_height)
+                        .to_rect()
+                        .with_origin(Point::new(0.0, line_height * line as f64));
+                    ctx.fill(
+                        rect,
+                        data.config
+                            .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+                    );
+                    ctx.stroke(
+                        rect,
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                        1.0,
+                    );
+                    let text_layout = ctx
+                        .text()
+                        .new_text_layout(format!(
+                            " -{}, +{}",
+                            left.end + 1,
+                            right.end + 1
+                        ))
+                        .font(data.config.editor.font_family(), font_size as f64)
+                        .text_color(
+                            data.config
+                                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                                .clone(),
+                        )
+                        .build()
+                        .unwrap();
+                    ctx.draw_text(
+                        &text_layout,
+                        Point::new(
+                            0.0,
+                            line_height * line as f64
+                                + text_layout.y_offset(line_height),
+                        ),
+                    );
+                    line += 1;
+                }
+                DiffLines::Both(_left, right) => {
+                    let len = right.len();
+                    line += len;
+                    if line < start_line {
+                        continue;
+                    }
+                    for l in line - len..line {
+                        if l < start_line {
+                            continue;
                         }
-                        DiffLines::Right(range) => {
-                            let len = range.len();
-                            line += len;
-
-                            if line < start_line {
-                                continue;
-                            }
+                        let rope_line = l - (line - len) + right.start;
 
-                            ctx.fill(
-                                Size::new(
-                                    self_size.width,
-                                    line_height * range.len() as f64,
-                                )
-                                .to_rect()
-                                .with_origin(
-                                    Point::new(
-                                        0.0,
-                                        line_height * (line - range.len()) as f64,
-                                    ),
-                                ),
-                                data.config.get_color_unchecked(
-                                    LapceTheme::SOURCE_CONTROL_ADDED,
-                                ),
-                            );
+                        lines.push(rope_line);
+                        info.insert(
+                            rope_line,
+                            LineInfo {
+                                font_size,
+                                x: 0.0,
+                                y: l as f64 * line_height,
+                                line_height,
+                            },
+                        );
 
-                            for l in line - len..line {
-                                if l < start_line {
-                                    continue;
-                                }
-                                let rope_line = l - (line - len) + range.start;
-                                Self::paint_cursor_on_line(
-                                    data,
-                                    ctx,
-                                    is_focused,
-                                    cursor_line,
-                                    rope_line,
-                                    0.0,
-                                    l as f64 * line_height,
-                                    char_width,
-                                    line_height,
-                                );
-                                let text_layout = data.doc.get_text_layout(
-                                    ctx.text(),
-                                    rope_line,
-                                    font_size,
-                                    &data.config,
-                                );
-                                ctx.draw_text(
-                                    &text_layout,
-                                    Point::new(
-                                        0.0,
-                                        line_height * l as f64 + y_shift,
-                                    ),
-                                );
-                                if l > end_line {
-                                    break;
-                                }
-                            }
+                        if l > end_line {
+                            break;
                         }
                     }
                 }
-            }
-            return;
-        } else {
-            let last_line = data.doc.buffer().last_line();
+                DiffLines::Right(range) => {
+                    let len = range.len();
+                    line += len;
 
-            Self::paint_cursor(
-                data,
-                ctx,
-                is_focused,
-                self.placeholder.as_ref(),
-                char_width,
-                font_size,
-                env,
-            );
-            Self::paint_find(data, ctx, char_width, env);
+                    if line < start_line {
+                        continue;
+                    }
 
-            for line in start_line..end_line + 1 {
-                if line > last_line {
-                    break;
-                }
+                    ctx.fill(
+                        Size::new(self_size.width, line_height * range.len() as f64)
+                            .to_rect()
+                            .with_origin(Point::new(
+                                0.0,
+                                line_height * (line - range.len()) as f64,
+                            )),
+                        data.config
+                            .get_color_unchecked(LapceTheme::SOURCE_CONTROL_ADDED),
+                    );
 
-                let text_layout = data.doc.get_text_layout(
-                    ctx.text(),
-                    line,
-                    font_size,
-                    &data.config,
-                );
-                ctx.draw_text(
-                    &text_layout,
-                    Point::new(
-                        0.0,
-                        line_height * line as f64
-                            + (line_height - text_layout.size().height) / 2.0
-                            + line_padding,
-                    ),
-                );
+                    for l in line - len..line {
+                        if l < start_line {
+                            continue;
+                        }
+                        let rope_line = l - (line - len) + range.start;
+
+                        lines.push(rope_line);
+                        info.insert(
+                            rope_line,
+                            LineInfo {
+                                font_size,
+                                x: 0.0,
+                                y: l as f64 * line_height,
+                                line_height,
+                            },
+                        );
+
+                        if l > end_line {
+                            break;
+                        }
+                    }
+                }
             }
         }
+        ScreenLines { lines, info }
+    }
 
-        Self::paint_snippet(data, ctx);
-        Self::paint_diagnostics(data, ctx);
-        if data.doc.buffer().is_empty() {
-            if let Some(placeholder) = self.placeholder.as_ref() {
-                let text_layout = ctx
-                    .text()
-                    .new_text_layout(placeholder.to_string())
+    fn paint_content(
+        &mut self,
+        data: &LapceEditorBufferData,
+        ctx: &mut PaintCtx,
+        is_focused: bool,
+        env: &Env,
+    ) {
+        if data.editor.content.is_palette()
+            && data.palette.status == PaletteStatus::Inactive
+        {
+            // Don't draw anything if palette is inactive
+            return;
+        }
+
+        let font_size = if data.editor.content.is_input() {
+            env.get(LapceTheme::INPUT_FONT_SIZE) as usize
+        } else {
+            data.config.editor.font_size
+        };
+
+        let line_padding = Self::line_padding(data, env);
+        let line_height = Self::line_height(data, env);
+        let screen_lines = match &data.editor.view {
+            EditorView::Normal => {
+                let rect = ctx.region().bounding_box();
+                let start_line = (rect.y0 / line_height).floor() as usize;
+                let end_line = (rect.y1 / line_height).ceil() as usize;
+
+                let mut lines = Vec::new();
+                let mut info = HashMap::new();
+                for line in start_line..end_line + 1 {
+                    lines.push(line);
+                    info.insert(
+                        line,
+                        LineInfo {
+                            font_size,
+                            x: 0.0,
+                            y: line as f64 * line_height + line_padding,
+                            line_height,
+                        },
+                    );
+                }
+                ScreenLines { lines, info }
+            }
+            EditorView::Diff(version) => {
+                if let Some(history) = data.doc.get_history(version) {
+                    Self::content_history_lines(ctx, data, history, env)
+                } else {
+                    return;
+                }
+            }
+            EditorView::Lens => Self::code_lens_lines(ctx, data, env),
+        };
+
+        Self::paint_current_line(ctx, data, &screen_lines);
+        Self::paint_cursor_new(ctx, data, &screen_lines, is_focused, env);
+        Self::paint_find(ctx, data, &screen_lines);
+        Self::paint_text(ctx, data, &screen_lines);
+        Self::paint_diagnostics(ctx, data, &screen_lines);
+        Self::paint_snippet(ctx, data, &screen_lines);
+        Self::highlight_scope_and_brackets(ctx, data, &screen_lines);
+        Self::paint_sticky_headers(ctx, data, env);
+
+        if data.doc.buffer().is_empty() {
+            if let Some(placeholder) = self.placeholder.as_ref() {
+                let text_layout = ctx
+                    .text()
+                    .new_text_layout(placeholder.to_string())
                     .font(
                         data.config.ui.font_family(),
                         data.config.ui.font_size() as f64,
@@ -840,887 +904,1351 @@ impl LapceEditor {
                     )
                     .build()
                     .unwrap();
-                ctx.draw_text(&text_layout, Point::new(0.0, y_shift));
+                ctx.draw_text(
+                    &text_layout,
+                    Point::new(
+                        0.0,
+                        text_layout
+                            .y_offset(data.config.editor.line_height() as f64),
+                    ),
+                );
+            } else if let BufferContent::Local(LocalBufferKind::Palette) =
+                data.editor.content
+            {
+                let text = match data.palette.palette_type {
+                    PaletteType::SshHost => Some("select or enter your ssh connection like [user@]host[:port]"),
+                    _ => None,
+                };
+                if let Some(text) = text {
+                    let text_layout = ctx
+                        .text()
+                        .new_text_layout(text)
+                        .font(data.config.ui.font_family(), font_size as f64)
+                        .text_color(
+                            data.config
+                                .get_color_unchecked(LapceTheme::EDITOR_DIM)
+                                .clone(),
+                        )
+                        .build()
+                        .unwrap();
+                    ctx.draw_text(
+                        &text_layout,
+                        Point::new(
+                            0.0,
+                            line_padding + text_layout.y_offset(line_height),
+                        ),
+                    );
+                }
             }
         }
     }
 
-    #[allow(clippy::too_many_arguments)]
-    fn paint_cursor_on_line(
+    fn paint_text(
+        ctx: &mut PaintCtx,
         data: &LapceEditorBufferData,
+        screen_lines: &ScreenLines,
+    ) {
+        let self_size = ctx.size();
+
+        let tab_text = ctx
+            .text()
+            .new_text_layout("→")
+            .font(
+                data.config.editor.font_family(),
+                data.config.editor.font_size as f64,
+            )
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_VISIBLE_WHITESPACE)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+        let tab_text_shift =
+            tab_text.y_offset(data.config.editor.line_height() as f64);
+        let space_text = ctx
+            .text()
+            .new_text_layout("·")
+            .font(
+                data.config.editor.font_family(),
+                data.config.editor.font_size as f64,
+            )
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_VISIBLE_WHITESPACE)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+        let space_text_shift =
+            tab_text.y_offset(data.config.editor.line_height() as f64);
+
+        let tab_width = data.config.tab_width(
+            ctx.text(),
+            data.config.editor.font_family(),
+            data.config.editor.font_size,
+        );
+        let indent_unit = data.doc.buffer().indent_unit();
+        let indent_text = ctx
+            .text()
+            .new_text_layout(format!("{indent_unit}a"))
+            .font(
+                data.config.editor.font_family(),
+                data.config.editor.font_size as f64,
+            )
+            .set_tab_width(tab_width)
+            .build()
+            .unwrap();
+        let indent_text_width = indent_text
+            .hit_test_text_position(indent_unit.len())
+            .point
+            .x;
+
+        for line in &screen_lines.lines {
+            let line = *line;
+            let last_line = data.doc.buffer().last_line();
+            if line > last_line {
+                break;
+            }
+
+            let info = screen_lines.info.get(&line).unwrap();
+            let text_layout = data.doc.get_text_layout(
+                ctx.text(),
+                line,
+                info.font_size,
+                &data.config,
+            );
+            let y = info.y + text_layout.text.y_offset(info.line_height);
+            let height = text_layout.text.size().height;
+            for (x0, x1, style) in text_layout.extra_style.iter() {
+                if let Some(bg) = &style.bg_color {
+                    let x1 = x1.unwrap_or(self_size.width);
+                    ctx.fill(
+                        Rect::new(*x0 + info.x, y, x1 + info.x, y + height),
+                        bg,
+                    );
+                }
+                if let Some(under_line) = &style.under_line {
+                    let x1 = x1.unwrap_or(self_size.width);
+                    let line = Line::new(
+                        Point::new(*x0, y + height),
+                        Point::new(x1, y + height),
+                    );
+                    ctx.stroke(line, under_line, 1.0);
+                }
+            }
+
+            if !data.editor.content.is_special()
+                && info.font_size == data.config.editor.font_size
+            {
+                if let Some(whitespaces) = &text_layout.whitespaces {
+                    for (c, (x0, _x1)) in whitespaces.iter() {
+                        match *c {
+                            '\t' => {
+                                ctx.draw_text(
+                                    &tab_text,
+                                    Point::new(*x0, info.y + tab_text_shift),
+                                );
+                            }
+                            ' ' => {
+                                ctx.draw_text(
+                                    &space_text,
+                                    Point::new(*x0, info.y + space_text_shift),
+                                );
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+                if data.config.editor.show_indent_guide {
+                    let mut x = 0.0;
+                    while x + 1.0 < text_layout.indent {
+                        ctx.stroke(
+                            Line::new(
+                                Point::new(x, info.y),
+                                Point::new(x, info.y + info.line_height),
+                            ),
+                            data.config.get_color_unchecked(
+                                LapceTheme::EDITOR_INDENT_GUIDE,
+                            ),
+                            1.0,
+                        );
+                        x += indent_text_width;
+                    }
+                }
+            }
+
+            ctx.draw_text(&text_layout.text, Point::new(info.x, y));
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn paint_cursor_caret(
         ctx: &mut PaintCtx,
-        is_focused: bool,
-        cursor_line: usize,
-        actual_line: usize,
-        x_shift: f64,
+        data: &LapceEditorBufferData,
+        offset: usize,
+        font_size: usize,
+        x: f64,
         y: f64,
-        char_width: f64,
         line_height: f64,
+        char_width: f64,
+        block: bool,
+    ) {
+        let (line, col) = data.doc.buffer().offset_to_line_col(offset);
+        let phantom_text = data.doc.line_phantom_text(&data.config, line);
+
+        // Shift it by the inlay hints
+        let col = if block {
+            phantom_text.col_after(col, true)
+        } else {
+            phantom_text.col_after(col, false)
+        };
+
+        let col = data
+            .doc
+            .ime_text()
+            .map(|_| {
+                let (ime_line, _, shift) = data.doc.ime_pos();
+                if ime_line == line {
+                    col + shift
+                } else {
+                    col
+                }
+            })
+            .unwrap_or(col);
+
+        let x0 = data
+            .doc
+            .line_point_of_line_col(ctx.text(), line, col, font_size, &data.config)
+            .x;
+        if block {
+            let right_offset = data.doc.buffer().move_right(offset, Mode::Insert, 1);
+            let (_, right_col) = data.doc.buffer().offset_to_line_col(right_offset);
+            let right_col = phantom_text.col_after(right_col, false);
+            let x1 = data
+                .doc
+                .line_point_of_line_col(
+                    ctx.text(),
+                    line,
+                    right_col,
+                    font_size,
+                    &data.config,
+                )
+                .x;
+            let char_width = if x1 > x0 { x1 - x0 } else { char_width };
+            ctx.fill(
+                Rect::ZERO
+                    .with_origin(Point::new(x0 + x, y))
+                    .with_size(Size::new(char_width, line_height)),
+                data.config.get_color_unchecked(LapceTheme::EDITOR_CARET),
+            );
+        } else {
+            let x0 = data
+                .doc
+                .line_point_of_line_col(
+                    ctx.text(),
+                    line,
+                    col,
+                    font_size,
+                    &data.config,
+                )
+                .x;
+            ctx.stroke(
+                Line::new(
+                    Point::new(x0 + x, y),
+                    Point::new(x0 + x, y + line_height),
+                ),
+                data.config.get_color_unchecked(LapceTheme::EDITOR_CARET),
+                2.0,
+            )
+        }
+    }
+
+    fn paint_current_line(
+        ctx: &mut PaintCtx,
+        data: &LapceEditorBufferData,
+        screen_lines: &ScreenLines,
+    ) {
+        if data.editor.content.is_input() {
+            return;
+        }
+        let self_size = ctx.size();
+        match &data.editor.cursor.mode {
+            CursorMode::Normal(offset) => {
+                let (cursor_line, _) = data.doc.buffer().offset_to_line_col(*offset);
+                if let Some(info) = screen_lines.info.get(&cursor_line) {
+                    ctx.fill(
+                        Rect::ZERO
+                            .with_origin(Point::new(0.0, info.y))
+                            .with_size(Size::new(self_size.width, info.line_height)),
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
+                    );
+                }
+            }
+            CursorMode::Visual { .. } => {}
+            CursorMode::Insert(selection) => {
+                if screen_lines.lines.is_empty() {
+                    return;
+                }
+                let start_line = *screen_lines.lines.first().unwrap();
+                let end_line = *screen_lines.lines.last().unwrap();
+                let start = data.doc.buffer().offset_of_line(start_line);
+                let end = data.doc.buffer().offset_of_line(end_line + 1);
+                let regions = selection.regions_in_range(start, end);
+                for region in regions {
+                    let cursor_offset = region.end;
+                    let (cursor_line, _) =
+                        data.doc.buffer().offset_to_line_col(cursor_offset);
+                    if let Some(info) = screen_lines.info.get(&cursor_line) {
+                        ctx.fill(
+                            Rect::ZERO
+                                .with_origin(Point::new(0.0, info.y))
+                                .with_size(Size::new(
+                                    self_size.width,
+                                    info.line_height,
+                                )),
+                            data.config.get_color_unchecked(
+                                LapceTheme::EDITOR_CURRENT_LINE,
+                            ),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    fn paint_cursor_new(
+        ctx: &mut PaintCtx,
+        data: &LapceEditorBufferData,
+        screen_lines: &ScreenLines,
+        is_focused: bool,
+        _env: &Env,
     ) {
+        let char_width = data.config.editor_char_width(ctx.text());
+
         match &data.editor.cursor.mode {
-            CursorMode::Normal(_) => {}
+            CursorMode::Normal(offset) => {
+                if is_focused {
+                    let (cursor_line, _) =
+                        data.doc.buffer().offset_to_line_col(*offset);
+                    if let Some(info) = screen_lines.info.get(&cursor_line) {
+                        Self::paint_cursor_caret(
+                            ctx,
+                            data,
+                            *offset,
+                            info.font_size,
+                            info.x,
+                            info.y,
+                            info.line_height,
+                            char_width,
+                            true,
+                        );
+                    }
+                }
+            }
             CursorMode::Visual { start, end, mode } => {
+                if screen_lines.lines.is_empty() {
+                    return;
+                }
+
                 let (start_line, start_col) =
                     data.doc.buffer().offset_to_line_col(*start.min(end));
                 let (end_line, end_col) =
                     data.doc.buffer().offset_to_line_col(*start.max(end));
-                if actual_line < start_line || actual_line > end_line {
-                    return;
-                }
-
-                let left_col = match mode {
-                    VisualMode::Normal => {
-                        if start_line == actual_line {
-                            start_col
-                        } else {
-                            0
-                        }
+                let (cursor_line, _) = data.doc.buffer().offset_to_line_col(*end);
+                for line in &screen_lines.lines {
+                    let line = *line;
+                    if line < start_line {
+                        continue;
                     }
-                    VisualMode::Linewise => 0,
-                    VisualMode::Blockwise => {
-                        let max_col =
-                            data.doc.buffer().line_end_col(actual_line, false);
-                        let left = start_col.min(end_col);
-                        if left > max_col {
-                            return;
-                        }
-                        left
+
+                    if line > end_line {
+                        break;
                     }
-                };
 
-                let right_col = match mode {
-                    VisualMode::Normal => {
-                        if actual_line == end_line {
+                    let info = screen_lines.info.get(&line).unwrap();
+                    let left_col = match mode {
+                        VisualMode::Normal => {
+                            if start_line == line {
+                                start_col
+                            } else {
+                                0
+                            }
+                        }
+                        VisualMode::Linewise => 0,
+                        VisualMode::Blockwise => {
                             let max_col =
-                                data.doc.buffer().line_end_col(actual_line, true);
-                            (end_col + 1).min(max_col)
-                        } else {
-                            data.doc.buffer().line_end_col(actual_line, true) + 1
+                                data.doc.buffer().line_end_col(line, false);
+                            let left = start_col.min(end_col);
+                            if left > max_col {
+                                continue;
+                            }
+                            left
                         }
+                    };
+
+                    let (right_col, line_end) = match mode {
+                        VisualMode::Normal => {
+                            if line == end_line {
+                                let max_col =
+                                    data.doc.buffer().line_end_col(line, true);
+
+                                let end_offset = data.doc.buffer().move_right(
+                                    *start.max(end),
+                                    Mode::Visual,
+                                    1,
+                                );
+                                let (_, end_col) =
+                                    data.doc.buffer().offset_to_line_col(end_offset);
+
+                                (end_col.min(max_col), false)
+                            } else {
+                                (data.doc.buffer().line_end_col(line, true), true)
+                            }
+                        }
+                        VisualMode::Linewise => {
+                            (data.doc.buffer().line_end_col(line, true), true)
+                        }
+                        VisualMode::Blockwise => {
+                            let max_col = data.doc.buffer().line_end_col(line, true);
+                            let right = match data.editor.cursor.horiz.as_ref() {
+                                Some(&ColPosition::End) => max_col,
+                                _ => {
+                                    let end_offset = data.doc.buffer().move_right(
+                                        *start.max(end),
+                                        Mode::Visual,
+                                        1,
+                                    );
+                                    let (_, end_col) = data
+                                        .doc
+                                        .buffer()
+                                        .offset_to_line_col(end_offset);
+                                    end_col.max(start_col).min(max_col)
+                                }
+                            };
+                            (right, false)
+                        }
+                    };
+
+                    let phantom_text =
+                        data.doc.line_phantom_text(&data.config, line);
+                    let left_col = phantom_text.col_after(left_col, false);
+                    let right_col = phantom_text.col_after(right_col, false);
+                    let x0 = data
+                        .doc
+                        .line_point_of_line_col(
+                            ctx.text(),
+                            line,
+                            left_col,
+                            info.font_size,
+                            &data.config,
+                        )
+                        .x;
+                    let mut x1 = data
+                        .doc
+                        .line_point_of_line_col(
+                            ctx.text(),
+                            line,
+                            right_col,
+                            info.font_size,
+                            &data.config,
+                        )
+                        .x;
+                    if line_end {
+                        x1 += char_width;
                     }
-                    VisualMode::Linewise => {
-                        data.doc.buffer().line_end_col(actual_line, true) + 1
-                    }
-                    VisualMode::Blockwise => {
-                        let max_col =
-                            data.doc.buffer().line_end_col(actual_line, true);
-                        let right = match data.editor.cursor.horiz.as_ref() {
-                            Some(&ColPosition::End) => max_col,
-                            _ => (end_col.max(start_col) + 1).min(max_col),
-                        };
-                        right
-                    }
-                };
 
-                let x0 = left_col as f64 * char_width + x_shift;
-                let x1 = right_col as f64 * char_width + x_shift;
-                let y0 = y;
-                let y1 = y0 + line_height;
-                ctx.fill(
-                    Rect::new(x0, y0, x1, y1),
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_SELECTION),
-                );
+                    let y0 = info.y;
+                    let y1 = info.y + info.line_height;
+                    ctx.fill(
+                        Rect::new(x0 + info.x, y0, x1 + info.x, y1),
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_SELECTION),
+                    );
+                    if is_focused && line == cursor_line {
+                        Self::paint_cursor_caret(
+                            ctx,
+                            data,
+                            *end,
+                            info.font_size,
+                            info.x,
+                            info.y,
+                            info.line_height,
+                            char_width,
+                            true,
+                        );
+                    }
+                }
             }
             CursorMode::Insert(selection) => {
-                let start_offset = data.doc.buffer().offset_of_line(actual_line);
-                let end_offset = data.doc.buffer().offset_of_line(actual_line + 1);
-                let regions = selection.regions_in_range(start_offset, end_offset);
+                if screen_lines.lines.is_empty() {
+                    return;
+                }
+                let start_line = *screen_lines.lines.first().unwrap();
+                let end_line = *screen_lines.lines.last().unwrap();
+                let start = data.doc.buffer().offset_of_line(start_line);
+                let end = data.doc.buffer().offset_of_line(end_line + 1);
+                let regions = selection.regions_in_range(start, end);
                 for region in regions {
-                    if region.is_caret() {
-                        let caret_actual_line =
-                            data.doc.buffer().line_of_offset(region.end());
-                        if caret_actual_line == actual_line {
-                            let size = ctx.size();
+                    let cursor_offset = region.end;
+                    let (cursor_line, _) =
+                        data.doc.buffer().offset_to_line_col(cursor_offset);
+                    let start = region.start;
+                    let end = region.end;
+                    let (start_line, start_col) =
+                        data.doc.buffer().offset_to_line_col(start.min(end));
+                    let (end_line, end_col) =
+                        data.doc.buffer().offset_to_line_col(start.max(end));
+                    for line in &screen_lines.lines {
+                        let line = *line;
+                        if line < start_line {
+                            continue;
+                        }
+
+                        if line > end_line {
+                            break;
+                        }
+
+                        let info = screen_lines.info.get(&line).unwrap();
+                        let left_col = match line {
+                            _ if line == start_line => start_col,
+                            _ => 0,
+                        };
+                        let (right_col, line_end) = match line {
+                            _ if line == end_line => {
+                                let max_col =
+                                    data.doc.buffer().line_end_col(line, true);
+                                (end_col.min(max_col), false)
+                            }
+                            _ => (data.doc.buffer().line_end_col(line, true), true),
+                        };
+
+                        let phantom_text =
+                            data.doc.line_phantom_text(&data.config, line);
+
+                        // Shift it by the inlay hints
+                        let left_col = phantom_text.col_after(left_col, false);
+                        let right_col = phantom_text.col_after(right_col, false);
+
+                        let x0 = data
+                            .doc
+                            .line_point_of_line_col(
+                                ctx.text(),
+                                line,
+                                left_col,
+                                info.font_size,
+                                &data.config,
+                            )
+                            .x;
+                        let mut x1 = data
+                            .doc
+                            .line_point_of_line_col(
+                                ctx.text(),
+                                line,
+                                right_col,
+                                info.font_size,
+                                &data.config,
+                            )
+                            .x;
+                        if line_end {
+                            x1 += char_width;
+                        }
+
+                        let y0 = info.y;
+                        let y1 = y0 + info.line_height;
+                        if start != end {
                             ctx.fill(
-                                Rect::ZERO
-                                    .with_origin(Point::new(0.0, y))
-                                    .with_size(Size::new(size.width, line_height)),
+                                Rect::new(x0 + info.x, y0, x1 + info.x, y1),
                                 data.config.get_color_unchecked(
-                                    LapceTheme::EDITOR_CURRENT_LINE,
+                                    LapceTheme::EDITOR_SELECTION,
                                 ),
                             );
                         }
+                        if is_focused && line == cursor_line {
+                            Self::paint_cursor_caret(
+                                ctx,
+                                data,
+                                cursor_offset,
+                                info.font_size,
+                                info.x,
+                                info.y,
+                                info.line_height,
+                                char_width,
+                                false,
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn paint_find(
+        ctx: &mut PaintCtx,
+        data: &LapceEditorBufferData,
+        screen_lines: &ScreenLines,
+    ) {
+        if data.editor.content.is_search() {
+            return;
+        }
+        if !data.find.visual {
+            return;
+        }
+
+        if screen_lines.lines.is_empty() {
+            return;
+        }
+        let start_line = *screen_lines.lines.first().unwrap();
+        let end_line = *screen_lines.lines.last().unwrap();
+        let start = data.doc.buffer().offset_of_line(start_line);
+        let end = data.doc.buffer().offset_of_line(end_line + 1);
+
+        let cursor_offset = data.editor.cursor.offset();
+
+        // Update the find with the whole document, so the count will be accurate in the widget
+        data.doc
+            .update_find(&data.find, 0, data.doc.buffer().last_line());
+        if data.find.search_string.is_some() {
+            for region in data
+                .doc
+                .find
+                .borrow()
+                .occurrences()
+                .regions_in_range(start, end)
+            {
+                let start = region.min();
+                let end = region.max();
+                let active = start <= cursor_offset && cursor_offset <= end;
+                let (start_line, start_col) =
+                    data.doc.buffer().offset_to_line_col(start);
+                let (end_line, end_col) = data.doc.buffer().offset_to_line_col(end);
+                for line in &screen_lines.lines {
+                    let line = *line;
+                    if line < start_line {
+                        continue;
+                    }
+                    if line > end_line {
+                        break;
+                    }
+
+                    let info = screen_lines.info.get(&line).unwrap();
+
+                    let left_col = if line == start_line { start_col } else { 0 };
+                    let right_col = if line == end_line {
+                        end_col
                     } else {
-                        let start = region.start();
-                        let end = region.end();
-                        let (start_line, start_col) =
-                            data.doc.buffer().offset_to_line_col(start.min(end));
-                        let (end_line, end_col) =
-                            data.doc.buffer().offset_to_line_col(start.max(end));
-                        let left_col = match actual_line {
-                            _ if actual_line == start_line => start_col,
-                            _ => 0,
-                        };
-                        let right_col = match actual_line {
-                            _ if actual_line == end_line => {
-                                let max_col = data
-                                    .doc
-                                    .buffer()
-                                    .line_end_col(actual_line, true);
-                                end_col.min(max_col)
-                            }
-                            _ => data.doc.buffer().line_end_col(actual_line, true),
-                        };
-                        let x0 = left_col as f64 * char_width + x_shift;
-                        let x1 = right_col as f64 * char_width + x_shift;
-                        let y0 = y;
-                        let y1 = y0 + line_height;
+                        data.doc.buffer().line_end_col(line, true) + 1
+                    };
+
+                    let phantom_text =
+                        data.doc.line_phantom_text(&data.config, line);
+                    let left_col = phantom_text.col_at(left_col);
+                    let right_col = phantom_text.col_at(right_col);
+
+                    let text_layout = data.doc.get_text_layout(
+                        ctx.text(),
+                        line,
+                        info.font_size,
+                        &data.config,
+                    );
+                    let x0 =
+                        text_layout.text.hit_test_text_position(left_col).point.x;
+                    let x1 =
+                        text_layout.text.hit_test_text_position(right_col).point.x;
+                    let y0 = info.y;
+                    let y1 = info.y + info.line_height;
+                    let rect = Rect::new(x0 + info.x, y0, x1 + info.x, y1);
+                    if active {
                         ctx.fill(
-                            Rect::new(x0, y0, x1, y1),
-                            data.config
-                                .get_color_unchecked(LapceTheme::EDITOR_SELECTION),
+                            rect,
+                            &data
+                                .config
+                                .get_color_unchecked(LapceTheme::EDITOR_CARET)
+                                .clone()
+                                .with_alpha(0.5),
                         );
                     }
+                    ctx.stroke(
+                        rect,
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                        1.0,
+                    );
                 }
-                for region in regions {
-                    if is_focused {
-                        let (caret_actual_line, col) =
-                            data.doc.buffer().offset_to_line_col(region.end());
-                        if caret_actual_line == actual_line {
-                            let x = col as f64 * char_width + x_shift;
-                            ctx.stroke(
-                                Line::new(
-                                    Point::new(x, y),
-                                    Point::new(x, y + line_height),
-                                ),
-                                data.config
-                                    .get_color_unchecked(LapceTheme::EDITOR_CARET),
-                                2.0,
-                            )
+            }
+        }
+    }
+
+    fn paint_sticky_headers(
+        ctx: &mut PaintCtx,
+        data: &LapceEditorBufferData,
+        env: &Env,
+    ) {
+        if !data.config.editor.sticky_header {
+            return;
+        }
+
+        if !data.editor.content.is_file() {
+            return;
+        }
+
+        let mut info = data.editor.sticky_header.borrow_mut();
+        info.lines.clear();
+        info.height = 0.0;
+        info.last_y_diff = 0.0;
+
+        if !data.editor.view.is_normal() {
+            return;
+        }
+
+        let line_height = Self::line_height(data, env);
+        let size = ctx.size();
+        let rect = ctx.region().bounding_box();
+        let x0 = rect.x0;
+        let y0 = rect.y0;
+        let start_line = (rect.y0 / line_height).floor() as usize;
+        let y_diff = y0 - start_line as f64 * line_height;
+        let mut last_sticky_should_scroll = false;
+
+        let mut sticky_lines = Vec::new();
+        if let Some(lines) = data.doc.sticky_headers(start_line) {
+            let total_lines = lines.len();
+            if total_lines > 0 {
+                let line = start_line + total_lines;
+                if let Some(new_lines) = data.doc.sticky_headers(line) {
+                    if new_lines.len() > total_lines {
+                        sticky_lines = new_lines;
+                    } else {
+                        sticky_lines = lines;
+                        last_sticky_should_scroll = new_lines.len() < total_lines;
+                        if new_lines.len() < total_lines {
+                            if let Some(new_new_lines) =
+                                data.doc.sticky_headers(start_line + total_lines - 1)
+                            {
+                                if new_new_lines.len() < total_lines {
+                                    sticky_lines.pop();
+                                    last_sticky_should_scroll = false;
+                                }
+                            } else {
+                                sticky_lines.pop();
+                                last_sticky_should_scroll = false;
+                            }
                         }
                     }
+                } else {
+                    sticky_lines = lines;
+                    last_sticky_should_scroll = true;
                 }
             }
         }
-        if cursor_line == actual_line {
-            if let CursorMode::Normal(_) = &data.editor.cursor.mode {
-                let size = ctx.size();
-                ctx.fill(
-                    Rect::ZERO
-                        .with_origin(Point::new(0.0, y))
-                        .with_size(Size::new(size.width, line_height)),
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
+
+        let total_sticky_lines = sticky_lines.len();
+
+        let paint_last_line = total_sticky_lines > 0
+            && (last_sticky_should_scroll
+                || y_diff != 0.0
+                || start_line + total_sticky_lines - 1
+                    != *sticky_lines.last().unwrap());
+
+        // Fix up the line count in case we don't need to paint the last one.
+        let total_sticky_lines = if paint_last_line {
+            total_sticky_lines
+        } else {
+            total_sticky_lines.saturating_sub(1)
+        };
+
+        if total_sticky_lines == 0 {
+            return;
+        }
+
+        let scroll_offset = if last_sticky_should_scroll {
+            y_diff
+        } else {
+            0.0
+        };
+
+        // Clear background
+        let area_height =
+            total_sticky_lines as f64 * line_height - scroll_offset + 1.0;
+        let sticky_area_rect = Size::new(size.width, area_height)
+            .to_rect()
+            .with_origin(Point::new(0.0, y0));
+
+        ctx.fill(
+            sticky_area_rect,
+            data.config
+                .get_color_unchecked(LapceTheme::EDITOR_STICKY_HEADER_BACKGROUND),
+        );
+
+        // Paint lines
+        for (i, line) in sticky_lines.iter().copied().enumerate() {
+            let y_diff = if i == total_sticky_lines - 1 {
+                scroll_offset
+            } else {
+                0.0
+            };
+
+            ctx.with_save(|ctx| {
+                let line_area_rect = Size::new(size.width, line_height - y_diff)
+                    .to_rect()
+                    .with_origin(Point::new(0.0, y0 + line_height * i as f64));
+
+                ctx.clip(line_area_rect);
+
+                let text_layout = data.doc.get_text_layout(
+                    ctx.text(),
+                    line,
+                    data.config.editor.font_size,
+                    &data.config,
                 );
-            }
-            match &data.editor.cursor.mode {
-                CursorMode::Normal(_) | CursorMode::Visual { .. } => {
-                    if is_focused {
-                        let x0 = data
-                            .doc
-                            .point_of_offset(
-                                ctx.text(),
-                                data.editor.cursor.offset(),
-                                data.config.editor.font_size,
-                                &data.config,
-                            )
-                            .x;
-                        let (right_offset, _) = data.doc.move_offset(
-                            ctx.text(),
-                            data.editor.cursor.offset(),
-                            None,
-                            1,
-                            &Movement::Right,
-                            Mode::Insert,
-                            data.config.editor.font_size,
-                            &data.config,
-                        );
-                        let x1 = data
-                            .doc
-                            .point_of_offset(
-                                ctx.text(),
-                                right_offset,
-                                data.config.editor.font_size,
-                                &data.config,
-                            )
-                            .x;
-                        let cursor_width =
-                            if x1 > x0 { x1 - x0 } else { char_width };
-                        ctx.fill(
-                            Rect::ZERO
-                                .with_origin(Point::new(x0 + x_shift, y))
-                                .with_size(Size::new(cursor_width, line_height)),
-                            data.config
-                                .get_color_unchecked(LapceTheme::EDITOR_CARET),
-                        );
-                    }
-                }
-                CursorMode::Insert(_) => {}
-            }
+                let y = y0
+                    + line_height * i as f64
+                    + text_layout.text.y_offset(line_height)
+                    - y_diff;
+                ctx.draw_text(&text_layout.text, Point::new(x0, y));
+            });
         }
+
+        info.last_y_diff = scroll_offset;
+        info.height = area_height;
+        info.lines = sticky_lines;
     }
 
-    fn paint_cursor(
-        data: &LapceEditorBufferData,
+    fn paint_snippet(
         ctx: &mut PaintCtx,
-        is_focused: bool,
-        placeholder: Option<&String>,
-        width: f64,
-        font_size: usize,
-        env: &Env,
+        data: &LapceEditorBufferData,
+        screen_lines: &ScreenLines,
     ) {
-        let line_height = Self::line_height(data, env);
-        let line_padding = Self::line_padding(data, env);
-        let start_line =
-            (data.editor.scroll_offset.y / line_height).floor() as usize;
-        let end_line = ((data.editor.size.borrow().height
-            + data.editor.scroll_offset.y)
-            / line_height)
-            .ceil() as usize;
-        match &data.editor.cursor.mode {
-            CursorMode::Normal(offset) => {
-                let line = data.doc.buffer().line_of_offset(*offset);
-                Self::paint_cursor_line(data, ctx, line, is_focused, placeholder);
-
-                if is_focused {
-                    let x0 = data
-                        .doc
-                        .point_of_offset(
-                            ctx.text(),
-                            *offset,
-                            font_size,
-                            &data.config,
-                        )
-                        .x;
-                    let (right_offset, _) = data.doc.move_offset(
-                        ctx.text(),
-                        *offset,
-                        None,
-                        1,
-                        &Movement::Right,
-                        Mode::Insert,
-                        data.config.editor.font_size,
-                        &data.config,
-                    );
-                    let x1 = data
-                        .doc
-                        .point_of_offset(
-                            ctx.text(),
-                            right_offset,
-                            font_size,
-                            &data.config,
-                        )
-                        .x;
-                    let char_width = if x1 > x0 { x1 - x0 } else { width };
-                    ctx.fill(
-                        Rect::ZERO
-                            .with_origin(Point::new(
-                                x0,
-                                line as f64 * line_height + line_padding,
-                            ))
-                            .with_size(Size::new(char_width, line_height)),
-                        data.config.get_color_unchecked(LapceTheme::EDITOR_CARET),
-                    );
-                }
-            }
-            CursorMode::Visual { start, end, mode } => {
-                let paint_start_line = start_line;
-                let paint_end_line = end_line;
+        if let Some(snippet) = data.editor.snippet.as_ref() {
+            for (_, (start, end)) in snippet {
                 let (start_line, start_col) =
                     data.doc.buffer().offset_to_line_col(*start.min(end));
                 let (end_line, end_col) =
                     data.doc.buffer().offset_to_line_col(*start.max(end));
-                for line in paint_start_line..paint_end_line {
-                    if line < start_line || line > end_line {
+
+                for line in &screen_lines.lines {
+                    let line = *line;
+                    if line < start_line {
                         continue;
                     }
-                    let left_col = match mode {
-                        VisualMode::Normal => match line {
-                            _ if line == start_line => start_col,
-                            _ => 0,
-                        },
-                        VisualMode::Linewise => 0,
-                        VisualMode::Blockwise => {
-                            let max_col =
-                                data.doc.buffer().line_end_col(line, false);
-                            let left = start_col.min(end_col);
-                            if left > max_col {
-                                continue;
-                            }
-                            left
-                        }
-                    };
+                    if line > end_line {
+                        break;
+                    }
 
-                    let (right_col, line_end) = match mode {
-                        VisualMode::Normal => match line {
-                            _ if line == end_line => {
-                                let max_col =
-                                    data.doc.buffer().line_end_col(line, true);
-                                ((end_col + 1).min(max_col), false)
-                            }
-                            _ => (data.doc.buffer().line_end_col(line, true), true),
-                        },
-                        VisualMode::Linewise => {
-                            (data.doc.buffer().line_end_col(line, true), true)
-                        }
-                        VisualMode::Blockwise => {
+                    let info = screen_lines.info.get(&line).unwrap();
+
+                    let left_col = match line {
+                        _ if line == start_line => start_col,
+                        _ => 0,
+                    };
+                    let right_col = match line {
+                        _ if line == end_line => {
                             let max_col = data.doc.buffer().line_end_col(line, true);
-                            let right = match data.editor.cursor.horiz.as_ref() {
-                                Some(&ColPosition::End) => max_col,
-                                _ => (end_col.max(start_col) + 1).min(max_col),
-                            };
-                            (right, false)
+                            end_col.min(max_col)
                         }
+                        _ => data.doc.buffer().line_end_col(line, true),
                     };
 
+                    let phantom_text =
+                        data.doc.line_phantom_text(&data.config, line);
+                    let left_col = phantom_text.col_at(left_col);
+                    let right_col = phantom_text.col_at(right_col);
+
                     let x0 = data
                         .doc
-                        .point_of_line_col(
+                        .line_point_of_line_col(
                             ctx.text(),
                             line,
                             left_col,
-                            font_size,
+                            info.font_size,
                             &data.config,
                         )
                         .x;
-                    let mut x1 = data
+                    let x1 = data
                         .doc
-                        .point_of_line_col(
+                        .line_point_of_line_col(
                             ctx.text(),
                             line,
                             right_col,
-                            font_size,
+                            info.font_size,
                             &data.config,
                         )
                         .x;
-                    if line_end {
-                        x1 += width;
+                    let y0 = info.y;
+                    let y1 = info.y + info.line_height;
+                    ctx.stroke(
+                        Rect::new(x0 + info.x, y0, x1 + info.x, y1)
+                            .inflate(1.0, -0.5),
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                        1.0,
+                    );
+                }
+            }
+        }
+    }
+
+    fn paint_diagnostics(
+        ctx: &mut PaintCtx,
+        data: &LapceEditorBufferData,
+        screen_lines: &ScreenLines,
+    ) {
+        if screen_lines.lines.is_empty() {
+            return;
+        }
+
+        let mut current = None;
+        let cursor_offset = data.editor.cursor.offset();
+        if let Some(diagnostics) = data.diagnostics() {
+            for diagnostic in diagnostics.iter() {
+                let start = diagnostic.diagnostic.range.start;
+                let end = diagnostic.diagnostic.range.end;
+                let start_offset = diagnostic.range.0;
+                if start_offset == cursor_offset {
+                    current = Some(diagnostic.clone());
+                }
+                for line in &screen_lines.lines {
+                    let line = *line;
+                    if line < start.line as usize {
+                        continue;
                     }
+                    if line > end.line as usize {
+                        break;
+                    }
+
+                    let info = screen_lines.info.get(&line).unwrap();
+
+                    let phantom_text =
+                        data.doc.line_phantom_text(&data.config, line);
+
+                    let text_layout = data.doc.get_text_layout(
+                        ctx.text(),
+                        line,
+                        info.font_size,
+                        &data.config,
+                    );
+                    let x0 = if line == start.line as usize {
+                        let col = phantom_text.col_at(start.character as usize);
+                        text_layout.text.hit_test_text_position(col).point.x
+                    } else {
+                        let (_, col) = data.doc.buffer().offset_to_line_col(
+                            data.doc
+                                .buffer()
+                                .first_non_blank_character_on_line(line),
+                        );
+                        let col = phantom_text.col_at(col);
+                        text_layout.text.hit_test_text_position(col).point.x
+                    };
+                    let x1 = if line == end.line as usize {
+                        let col = phantom_text.col_at(end.character as usize);
+                        text_layout.text.hit_test_text_position(col).point.x
+                    } else {
+                        let col = data.doc.buffer().line_end_col(line, false) + 1;
+                        let col = phantom_text.col_at(col);
+                        text_layout.text.hit_test_text_position(col).point.x
+                    };
+                    let scale =
+                        info.font_size as f64 / data.config.editor.font_size as f64;
+                    let y0 = info.y + info.line_height - 4.0 * scale;
+
+                    let severity = diagnostic
+                        .diagnostic
+                        .severity
+                        .unwrap_or(DiagnosticSeverity::INFORMATION);
+                    let color = match severity {
+                        DiagnosticSeverity::ERROR => {
+                            data.config.get_color_unchecked(LapceTheme::LAPCE_ERROR)
+                        }
+                        DiagnosticSeverity::WARNING => {
+                            data.config.get_color_unchecked(LapceTheme::LAPCE_WARN)
+                        }
+                        _ => data.config.get_color_unchecked(LapceTheme::LAPCE_WARN),
+                    };
+                    Self::paint_wave_line(
+                        ctx,
+                        Point::new(x0 + info.x, y0),
+                        x1 - x0,
+                        scale,
+                        color,
+                    );
+                }
+            }
+        }
 
-                    let y0 = line as f64 * line_height + line_padding;
-                    let y1 = y0 + line_height;
+        if let Some(diagnostic) = current {
+            let start = diagnostic.diagnostic.range.start;
+            if let Some(info) = screen_lines.info.get(&(start.line as usize)) {
+                if data.editor.cursor.is_normal() {
+                    let text_layout = ctx
+                        .text()
+                        .new_text_layout(diagnostic.diagnostic.message.clone())
+                        .font(
+                            data.config.ui.font_family(),
+                            data.config.ui.font_size() as f64,
+                        )
+                        .text_color(
+                            data.config
+                                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                                .clone(),
+                        )
+                        .max_width(data.editor.size.borrow().width - 20.0)
+                        .build()
+                        .unwrap();
+                    let text_size = text_layout.size();
+                    let mut text_height = text_size.height;
+
+                    let related = diagnostic
+                        .diagnostic
+                        .related_information
+                        .map(|related| {
+                            related
+                                .iter()
+                                .map(|i| {
+                                    let text_layout = ctx
+                                        .text()
+                                        .new_text_layout(i.message.clone())
+                                        .font(
+                                            data.config.ui.font_family(),
+                                            data.config.ui.font_size() as f64,
+                                        )
+                                        .text_color(
+                                            data.config
+                                                .get_color_unchecked(
+                                                    LapceTheme::EDITOR_FOREGROUND,
+                                                )
+                                                .clone(),
+                                        )
+                                        .max_width(
+                                            data.editor.size.borrow().width - 20.0,
+                                        )
+                                        .build()
+                                        .unwrap();
+                                    text_height += 10.0 + text_layout.size().height;
+                                    text_layout
+                                })
+                                .collect::<Vec<PietTextLayout>>()
+                        })
+                        .unwrap_or_else(Vec::new);
+
+                    let rect = Rect::ZERO
+                        .with_origin(Point::new(0.0, info.y + info.line_height))
+                        .with_size(Size::new(
+                            data.editor.size.borrow().width,
+                            text_height + 20.0,
+                        ));
                     ctx.fill(
-                        Rect::new(x0, y0, x1, y1),
+                        rect,
                         data.config
                             .get_color_unchecked(LapceTheme::EDITOR_SELECTION),
                     );
 
-                    if is_focused {
-                        let line = data.doc.buffer().line_of_offset(*end);
-
-                        let x0 = data
-                            .doc
-                            .point_of_offset(
-                                ctx.text(),
-                                *end,
-                                font_size,
-                                &data.config,
-                            )
-                            .x;
-                        let (right_offset, _) = data.doc.move_offset(
-                            ctx.text(),
-                            *end,
-                            None,
-                            1,
-                            &Movement::Right,
-                            Mode::Insert,
-                            data.config.editor.font_size,
-                            &data.config,
-                        );
-                        let x1 = data
-                            .doc
-                            .point_of_offset(
-                                ctx.text(),
-                                right_offset,
-                                font_size,
-                                &data.config,
-                            )
-                            .x;
-                        let char_width = if x1 > x0 { x1 - x0 } else { width };
-                        ctx.fill(
-                            Rect::ZERO
-                                .with_origin(Point::new(
-                                    x0,
-                                    line as f64 * line_height + line_padding,
-                                ))
-                                .with_size(Size::new(char_width, line_height)),
-                            data.config
-                                .get_color_unchecked(LapceTheme::EDITOR_CARET),
+                    let severity = diagnostic
+                        .diagnostic
+                        .severity
+                        .unwrap_or(DiagnosticSeverity::INFORMATION);
+                    let color = match severity {
+                        DiagnosticSeverity::ERROR => {
+                            data.config.get_color_unchecked(LapceTheme::LAPCE_ERROR)
+                        }
+                        DiagnosticSeverity::WARNING => {
+                            data.config.get_color_unchecked(LapceTheme::LAPCE_WARN)
+                        }
+                        _ => data.config.get_color_unchecked(LapceTheme::LAPCE_WARN),
+                    };
+                    ctx.stroke(rect, color, 1.0);
+                    ctx.draw_text(
+                        &text_layout,
+                        Point::new(
+                            10.0 + data.editor.scroll_offset.x,
+                            info.y + info.line_height + 10.0,
+                        ),
+                    );
+                    let mut text_height = text_size.height;
+
+                    for text in related {
+                        text_height += 10.0;
+                        ctx.draw_text(
+                            &text,
+                            Point::new(
+                                10.0 + data.editor.scroll_offset.x,
+                                info.y + info.line_height + 10.0 + text_height,
+                            ),
                         );
+                        text_height += text.size().height;
                     }
                 }
             }
-            CursorMode::Insert(selection) => {
-                let last_line = data.doc.buffer().last_line();
-                let end_line = if end_line > last_line {
-                    last_line
-                } else {
-                    end_line
-                };
-                let start = data.doc.buffer().offset_of_line(start_line);
-                let end = data.doc.buffer().offset_of_line(end_line + 1);
-                let regions = selection.regions_in_range(start, end);
-                for region in regions {
-                    if region.start() == region.end() {
-                        let line = data.doc.buffer().line_of_offset(region.start());
-                        Self::paint_cursor_line(
-                            data,
-                            ctx,
-                            line,
-                            is_focused,
-                            placeholder,
-                        );
-                    } else {
-                        let start = region.start();
-                        let end = region.end();
-                        let paint_start_line = start_line;
-                        let paint_end_line = end_line;
-                        let (start_line, start_col) =
-                            data.doc.buffer().offset_to_line_col(start.min(end));
-                        let (end_line, end_col) =
-                            data.doc.buffer().offset_to_line_col(start.max(end));
-                        for line in paint_start_line..paint_end_line + 1 {
-                            if line < start_line || line > end_line {
-                                continue;
-                            }
+        }
+    }
 
-                            let line_content = data.doc.buffer().line_content(line);
-                            let left_col = match line {
-                                _ if line == start_line => start_col,
-                                _ => 0,
-                            };
-                            let right_col = match line {
-                                _ if line == end_line => {
-                                    let max_col =
-                                        data.doc.buffer().line_end_col(line, true);
-                                    end_col.min(max_col)
-                                }
-                                _ => data.doc.buffer().line_end_col(line, true),
-                            };
+    /// Checks if the cursor is on a bracket and highlights the matching bracket if there is one.
+    /// If the cursor is between brackets it highlights the enclosing brackets.
+    fn highlight_scope_and_brackets(
+        ctx: &mut PaintCtx,
+        data: &LapceEditorBufferData,
+        screen_lines: &ScreenLines,
+    ) {
+        if !data.config.editor.highlight_matching_brackets
+            && !data.config.editor.highlight_scope_lines
+        {
+            return;
+        }
 
-                            if !line_content.is_empty() {
-                                let x0 = data
-                                    .doc
-                                    .point_of_line_col(
-                                        ctx.text(),
-                                        line,
-                                        left_col,
-                                        font_size,
-                                        &data.config,
-                                    )
-                                    .x;
-                                let x1 = data
-                                    .doc
-                                    .point_of_line_col(
-                                        ctx.text(),
-                                        line,
-                                        right_col,
-                                        font_size,
-                                        &data.config,
-                                    )
-                                    .x;
-                                let y0 = line as f64 * line_height + line_padding;
-                                let y1 = y0 + line_height;
-                                ctx.fill(
-                                    Rect::new(x0, y0, x1, y1),
-                                    data.config.get_color_unchecked(
-                                        LapceTheme::EDITOR_SELECTION,
-                                    ),
-                                );
-                            }
-                        }
-                    }
-                }
+        if screen_lines.lines.is_empty() {
+            return;
+        }
 
-                for region in regions {
-                    if is_focused {
-                        let (line, col) =
-                            data.doc.buffer().offset_to_line_col(region.end());
-                        let x = data
-                            .doc
-                            .point_of_line_col(
-                                ctx.text(),
-                                line,
-                                col,
-                                font_size,
-                                &data.config,
-                            )
-                            .x;
-                        let y = line as f64 * line_height + line_padding;
-                        ctx.stroke(
-                            Line::new(
-                                Point::new(x, y),
-                                Point::new(x, y + line_height),
-                            ),
-                            data.config
-                                .get_color_unchecked(LapceTheme::EDITOR_CARET),
-                            2.0,
-                        )
-                    }
+        let cursor_offset = data.editor.cursor.offset();
+
+        let start_line = *screen_lines.lines.first().unwrap();
+        let end_line = *screen_lines.lines.last().unwrap();
+        let start = data.doc.buffer().offset_of_line(start_line);
+        let end = data.doc.buffer().offset_of_line(end_line + 1);
+
+        if let Some((start_offset, end_offset)) =
+            data.doc.find_enclosing_brackets(cursor_offset)
+        {
+            if data.config.editor.highlight_matching_brackets {
+                if start_offset > start && start_offset < end {
+                    Self::paint_bracket_highlight(
+                        ctx,
+                        data,
+                        screen_lines,
+                        start_offset,
+                    );
+                }
+                if end_offset > start && end_offset < end {
+                    Self::paint_bracket_highlight(
+                        ctx,
+                        data,
+                        screen_lines,
+                        end_offset,
+                    );
                 }
             }
-        }
+
+            if data.config.editor.highlight_scope_lines {
+                Self::paint_scope_line(
+                    ctx,
+                    data,
+                    screen_lines,
+                    start_offset,
+                    end_offset,
+                    data.config.get_color_unchecked(LapceTheme::EDITOR_CARET),
+                );
+            }
+        };
     }
 
-    fn paint_cursor_line(
-        data: &LapceEditorBufferData,
+    /// Highlights a character at the given position
+    fn paint_bracket_highlight(
         ctx: &mut PaintCtx,
-        line: usize,
-        is_focused: bool,
-        placeholder: Option<&String>,
+        data: &LapceEditorBufferData,
+        screen_lines: &ScreenLines,
+        offset: usize,
     ) {
-        if !is_focused && data.doc.buffer().is_empty() && placeholder.is_some() {
-            return;
-        }
-        if data.editor.content.is_input() {
-            return;
-        }
-        let line_height = data.config.editor.line_height as f64;
-        let size = ctx.size();
+        let (line, col) = data.doc.buffer().offset_to_line_col(offset);
+        let info = match screen_lines.info.get(&line) {
+            Some(info) => info,
+            None => return,
+        };
+        let char_width = data.config.editor_char_width(ctx.text());
+
+        let phantom_text = data.doc.line_phantom_text(&data.config, line);
+
+        let col = phantom_text.col_after(col, true);
+
+        let x0 = data
+            .doc
+            .line_point_of_line_col(
+                ctx.text(),
+                line,
+                col,
+                info.font_size,
+                &data.config,
+            )
+            .x;
+
+        let right_offset = offset + 1;
+        let (_, right_col) = data.doc.buffer().offset_to_line_col(right_offset);
+        let right_col = phantom_text.col_after(right_col, false);
+
+        let x1 = data
+            .doc
+            .line_point_of_line_col(
+                ctx.text(),
+                line,
+                right_col,
+                info.font_size,
+                &data.config,
+            )
+            .x;
+        let char_width = if x1 > x0 { x1 - x0 } else { char_width };
+        let rect = Rect::from_origin_size(
+            Point::new(x0 + info.x, info.y),
+            Size::new(char_width, info.line_height),
+        );
         ctx.fill(
-            Rect::ZERO
-                .with_origin(Point::new(0.0, line as f64 * line_height))
-                .with_size(Size::new(size.width, line_height)),
-            data.config
-                .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
+            rect,
+            &data
+                .config
+                .get_color_unchecked(LapceTheme::EDITOR_CARET)
+                .clone()
+                .with_alpha(0.2),
         );
     }
 
-    fn paint_find(
-        data: &LapceEditorBufferData,
+    fn paint_scope_line(
         ctx: &mut PaintCtx,
-        _char_width: f64,
-        env: &Env,
+        data: &LapceEditorBufferData,
+        screen_lines: &ScreenLines,
+        start_offset: usize,
+        end_offset: usize,
+        color: &Color,
     ) {
-        if data.editor.content.is_search() {
+        if data.editor.is_code_lens() {
             return;
         }
-        if !data.find.visual {
+
+        const LINE_WIDTH: f64 = 1.0;
+
+        let (start_line, start_col) =
+            data.doc.buffer().offset_to_line_col(start_offset);
+        let (end_line, end_col) = data.doc.buffer().offset_to_line_col(end_offset);
+
+        let first_screen_line = *screen_lines.lines.first().unwrap();
+
+        let first_line = if first_screen_line > start_line {
+            first_screen_line
+        } else {
+            start_line
+        };
+
+        if first_line > end_line {
             return;
         }
-        let line_height = Self::line_height(data, env);
-        let start_line =
-            (data.editor.scroll_offset.y / line_height).floor() as usize;
-        let end_line = ((data.editor.size.borrow().height
-            + data.editor.scroll_offset.y)
-            / line_height)
-            .ceil() as usize;
 
-        let start_offset = data.doc.buffer().offset_of_line(start_line);
-        let end_offset = data.doc.buffer().offset_of_line(end_line + 1);
-        let cursor_offset = data.editor.cursor.offset();
+        let info = match screen_lines.info.get(&first_line) {
+            Some(info) => info,
+            None => return,
+        };
 
-        // Update the find with the whole document, so the count will be accurate in the widget
-        data.doc
-            .update_find(&data.find, 0, data.doc.buffer().last_line());
-        if data.find.search_string.is_some() {
-            for region in data
-                .doc
-                .find
-                .borrow()
-                .occurrences()
-                .regions_in_range(start_offset, end_offset)
-            {
-                let start = region.min();
-                let end = region.max();
-                let active = start <= cursor_offset && cursor_offset <= end;
-                let (start_line, start_col) =
-                    data.doc.buffer().offset_to_line_col(start);
-                let (end_line, end_col) = data.doc.buffer().offset_to_line_col(end);
-                for line in start_line..end_line + 1 {
-                    let left_col = if line == start_line { start_col } else { 0 };
-                    let right_col = if line == end_line {
-                        end_col
-                    } else {
-                        data.doc.buffer().line_end_col(line, true) + 1
-                    };
-                    let text_layout = data.doc.get_text_layout(
-                        ctx.text(),
-                        line,
-                        data.config.editor.font_size,
-                        &data.config,
-                    );
-                    let x0 = text_layout.hit_test_text_position(left_col).point.x;
-                    let x1 = text_layout.hit_test_text_position(right_col).point.x;
-                    let y0 = line as f64 * line_height;
-                    let y1 = y0 + line_height;
-                    let rect = Rect::new(x0, y0, x1, y1);
-                    if active {
-                        ctx.fill(
-                            rect,
-                            &data
-                                .config
-                                .get_color_unchecked(LapceTheme::EDITOR_CARET)
-                                .clone()
-                                .with_alpha(0.5),
-                        );
-                    }
-                    ctx.stroke(
-                        rect,
-                        data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
-                        1.0,
-                    );
+        let mut x1 = Self::calculate_x_coordinate(
+            ctx,
+            data,
+            end_line,
+            end_col,
+            info.font_size,
+        );
+
+        let y0 = info.y + info.line_height;
+
+        let mut paint_horizontal_line_at_end = false;
+        if first_line == end_line {
+            let x0 = Self::calculate_x_coordinate(
+                ctx,
+                data,
+                first_line,
+                start_col,
+                info.font_size,
+            ) + data.config.editor_char_width(ctx.text());
+
+            ctx.stroke(
+                Line::new(Point::new(x0, y0), Point::new(x1, y0)),
+                color,
+                LINE_WIDTH,
+            );
+        } else {
+            let last_line = data.doc.buffer().last_line();
+            for line in start_line..end_line + 1 {
+                if line > last_line {
+                    break;
                 }
-            }
-        }
-    }
 
-    fn paint_snippet(data: &LapceEditorBufferData, ctx: &mut PaintCtx) {
-        let line_height = data.config.editor.line_height as f64;
-        let start_line =
-            (data.editor.scroll_offset.y / line_height).floor() as usize;
-        let end_line = ((data.editor.size.borrow().height
-            + data.editor.scroll_offset.y)
-            / line_height)
-            .ceil() as usize;
-        let width = data.config.editor_char_width(ctx.text());
-        if let Some(snippet) = data.editor.snippet.as_ref() {
-            for (_, (start, end)) in snippet {
-                let paint_start_line = start_line;
-                let paint_end_line = end_line;
-                let (start_line, start_col) =
-                    data.doc.buffer().offset_to_line_col(*start.min(end));
-                let (end_line, end_col) =
-                    data.doc.buffer().offset_to_line_col(*start.max(end));
-                for line in paint_start_line..paint_end_line {
-                    if line < start_line || line > end_line {
-                        continue;
-                    }
-                    let line_content = data.doc.buffer().line_content(line);
-                    let left_col = match line {
-                        _ if line == start_line => start_col,
-                        _ => 0,
-                    };
-                    let x0 = left_col as f64 * width;
+                let text_layout = data.doc.get_text_layout(
+                    ctx.text(),
+                    line,
+                    info.font_size,
+                    &data.config,
+                );
 
-                    let right_col = match line {
-                        _ if line == end_line => {
-                            let max_col = data.doc.buffer().line_end_col(line, true);
-                            end_col.min(max_col)
-                        }
-                        _ => data.doc.buffer().line_end_col(line, true),
-                    };
-                    if !line_content.is_empty() {
-                        let x1 = right_col as f64 * width;
-                        let y0 = line as f64 * line_height;
-                        let y1 = y0 + line_height;
-                        ctx.stroke(
-                            Rect::new(x0, y0, x1, y1).inflate(1.0, -0.5),
-                            data.config
-                                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
-                            1.0,
-                        );
-                    }
+                if text_layout.indent < x1 {
+                    x1 = text_layout.indent;
+                    paint_horizontal_line_at_end = true;
                 }
             }
-        }
-    }
 
-    fn paint_diagnostics(data: &LapceEditorBufferData, ctx: &mut PaintCtx) {
-        let line_height = data.config.editor.line_height as f64;
-        let start_line =
-            (data.editor.scroll_offset.y / line_height).floor() as usize;
-        let end_line = ((data.editor.size.borrow().height
-            + data.editor.scroll_offset.y)
-            / line_height)
-            .ceil() as usize;
+            let x0 = if first_line > start_line {
+                x1
+            } else {
+                Self::calculate_x_coordinate(
+                    ctx,
+                    data,
+                    start_line,
+                    start_col,
+                    info.font_size,
+                )
+            };
 
-        let mut current = None;
-        let cursor_offset = data.editor.cursor.offset();
-        if let Some(diagnostics) = data.diagnostics() {
-            for diagnostic in diagnostics.iter() {
-                let start = diagnostic.diagnostic.range.start;
-                let end = diagnostic.diagnostic.range.end;
-                if (start.line as usize) <= end_line
-                    && (end.line as usize) >= start_line
-                {
-                    let start_offset = if let Some(range) = diagnostic.range {
-                        range.0
-                    } else {
-                        data.doc.buffer().offset_of_position(&start)
-                    };
-                    if start_offset == cursor_offset {
-                        current = Some(diagnostic.clone());
-                    }
-                    for line in start.line as usize..end.line as usize + 1 {
-                        if line < start_line {
-                            continue;
-                        }
-                        if line > end_line {
-                            break;
-                        }
+            let lines = end_line - first_line;
 
-                        let text_layout = data.doc.get_text_layout(
-                            ctx.text(),
-                            line,
-                            data.config.editor.font_size,
-                            &data.config,
-                        );
-                        let x0 = if line == start.line as usize {
-                            text_layout
-                                .hit_test_text_position(start.character as usize)
-                                .point
-                                .x
-                        } else {
-                            let (_, col) = data.doc.buffer().offset_to_line_col(
-                                data.doc
-                                    .buffer()
-                                    .first_non_blank_character_on_line(line),
-                            );
-                            text_layout.hit_test_text_position(col).point.x
-                        };
-                        let x1 = if line == end.line as usize {
-                            text_layout
-                                .hit_test_text_position(end.character as usize)
-                                .point
-                                .x
-                        } else {
-                            let col =
-                                data.doc.buffer().line_end_col(line, false) + 1;
-                            text_layout.hit_test_text_position(col).point.x
-                        };
-                        let _y1 = (line + 1) as f64 * line_height;
-                        let y0 = (line + 1) as f64 * line_height - 4.0;
-
-                        let severity = diagnostic
-                            .diagnostic
-                            .severity
-                            .as_ref()
-                            .unwrap_or(&DiagnosticSeverity::Information);
-                        let color = match severity {
-                            DiagnosticSeverity::Error => data
-                                .config
-                                .get_color_unchecked(LapceTheme::LAPCE_ERROR),
-                            DiagnosticSeverity::Warning => data
-                                .config
-                                .get_color_unchecked(LapceTheme::LAPCE_WARN),
-                            _ => data
-                                .config
-                                .get_color_unchecked(LapceTheme::LAPCE_WARN),
-                        };
-                        Self::paint_wave_line(
-                            ctx,
-                            Point::new(x0, y0),
-                            x1 - x0,
-                            color,
-                        );
-                    }
-                }
-            }
-        }
+            let y1 = if data
+                .doc
+                .buffer()
+                .first_non_blank_character_on_line(end_line)
+                < end_offset
+            {
+                paint_horizontal_line_at_end = true;
+                info.y + ((lines + 1) as f64 * info.line_height)
+            } else {
+                info.y + (lines as f64 * info.line_height)
+            };
 
-        if let Some(diagnostic) = current {
-            if data.editor.cursor.is_normal() {
-                let text_layout = ctx
-                    .text()
-                    .new_text_layout(diagnostic.diagnostic.message.clone())
-                    .font(
-                        data.config.ui.font_family(),
-                        data.config.ui.font_size() as f64,
-                    )
-                    .text_color(
-                        data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                            .clone(),
-                    )
-                    .max_width(data.editor.size.borrow().width - 20.0)
-                    .build()
-                    .unwrap();
-                let text_size = text_layout.size();
-                let mut text_height = text_size.height;
-
-                let related = diagnostic
-                    .diagnostic
-                    .related_information
-                    .map(|related| {
-                        related
-                            .iter()
-                            .map(|i| {
-                                let text_layout = ctx
-                                    .text()
-                                    .new_text_layout(i.message.clone())
-                                    .font(
-                                        data.config.ui.font_family(),
-                                        data.config.ui.font_size() as f64,
-                                    )
-                                    .text_color(
-                                        data.config
-                                            .get_color_unchecked(
-                                                LapceTheme::EDITOR_FOREGROUND,
-                                            )
-                                            .clone(),
-                                    )
-                                    .max_width(
-                                        data.editor.size.borrow().width - 20.0,
-                                    )
-                                    .build()
-                                    .unwrap();
-                                text_height += 10.0 + text_layout.size().height;
-                                text_layout
-                            })
-                            .collect::<Vec<PietTextLayout>>()
-                    })
-                    .unwrap_or_else(Vec::new);
+            ctx.stroke(
+                Line::new(Point::new(x0, y0), Point::new(x1, y0)),
+                color,
+                LINE_WIDTH,
+            );
 
-                let start = diagnostic.diagnostic.range.start;
-                let rect = Rect::ZERO
-                    .with_origin(Point::new(
-                        0.0,
-                        (start.line + 1) as f64 * line_height,
-                    ))
-                    .with_size(Size::new(
-                        data.editor.size.borrow().width,
-                        text_height + 20.0,
-                    ));
-                ctx.fill(
-                    rect,
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_SELECTION),
-                );
+            ctx.stroke(
+                Line::new(Point::new(x1, y0), Point::new(x1, y1)),
+                color,
+                LINE_WIDTH,
+            );
 
-                let severity = diagnostic
-                    .diagnostic
-                    .severity
-                    .as_ref()
-                    .unwrap_or(&DiagnosticSeverity::Information);
-                let color = match severity {
-                    DiagnosticSeverity::Error => {
-                        data.config.get_color_unchecked(LapceTheme::LAPCE_ERROR)
-                    }
-                    DiagnosticSeverity::Warning => {
-                        data.config.get_color_unchecked(LapceTheme::LAPCE_WARN)
-                    }
-                    _ => data.config.get_color_unchecked(LapceTheme::LAPCE_WARN),
-                };
-                ctx.stroke(rect, color, 1.0);
-                ctx.draw_text(
-                    &text_layout,
-                    Point::new(
-                        10.0 + data.editor.scroll_offset.x,
-                        (start.line + 1) as f64 * line_height + 10.0,
-                    ),
+            if paint_horizontal_line_at_end {
+                let x2 = Self::calculate_x_coordinate(
+                    ctx,
+                    data,
+                    end_line,
+                    end_col,
+                    info.font_size,
                 );
-                let mut text_height = text_size.height;
 
-                for text in related {
-                    text_height += 10.0;
-                    ctx.draw_text(
-                        &text,
-                        Point::new(
-                            10.0 + data.editor.scroll_offset.x,
-                            (start.line + 1) as f64 * line_height
-                                + 10.0
-                                + text_height,
-                        ),
-                    );
-                    text_height += text.size().height;
-                }
+                ctx.stroke(
+                    Line::new(Point::new(x1, y1), Point::new(x2, y1)),
+                    color,
+                    LINE_WIDTH,
+                );
             }
         }
     }
 
     fn line_height(data: &LapceEditorBufferData, env: &Env) -> f64 {
-        if data.editor.content.is_input() {
+        if data.editor.content.is_palette() {
+            env.get(LapceTheme::PALETTE_INPUT_LINE_HEIGHT)
+        } else if data.editor.content.is_input() {
             env.get(LapceTheme::INPUT_LINE_HEIGHT)
         } else {
-            data.config.editor.line_height as f64
+            data.config.editor.line_height() as f64
         }
     }
 
     fn line_padding(data: &LapceEditorBufferData, env: &Env) -> f64 {
-        if data.editor.content.is_input() {
+        if data.editor.content.is_palette() {
+            env.get(LapceTheme::PALETTE_INPUT_LINE_PADDING)
+        } else if data.editor.content.is_input() {
             env.get(LapceTheme::INPUT_LINE_PADDING)
         } else {
             0.0
@@ -1731,12 +2259,13 @@ impl LapceEditor {
         ctx: &mut PaintCtx,
         origin: Point,
         max_width: f64,
+        scale: f64,
         color: &Color,
     ) {
         let mut path = BezPath::new();
         let mut x = 0.0;
-        let width = 3.5;
-        let height = 4.0;
+        let width = 3.5 * scale;
+        let height = 4.0 * scale;
         path.move_to(origin + (0.0, height / 2.0));
         let mut direction = 1.0;
         while x < max_width {
@@ -1747,7 +2276,29 @@ impl LapceEditor {
             x += width;
             direction *= -1.0;
         }
-        ctx.stroke(path, color, 1.4);
+        ctx.stroke(path, color, 1.4 * scale);
+    }
+
+    fn calculate_x_coordinate(
+        ctx: &mut PaintCtx,
+        data: &LapceEditorBufferData,
+        line: usize,
+        column: usize,
+        font_size: usize,
+    ) -> f64 {
+        let phantom_text = data.doc.line_phantom_text(&data.config, line);
+
+        let column = phantom_text.col_after(column, true);
+
+        data.doc
+            .line_point_of_line_col(
+                ctx.text(),
+                line,
+                column,
+                font_size,
+                &data.config,
+            )
+            .x
     }
 }
 
@@ -1761,11 +2312,15 @@ impl Widget<LapceTabData> for LapceEditor {
         ctx: &mut EventCtx,
         event: &Event,
         data: &mut LapceTabData,
-        _env: &Env,
+        env: &Env,
     ) {
         match event {
+            Event::Wheel(_) => {
+                if data.hover.status != HoverStatus::Inactive {
+                    Arc::make_mut(&mut data.hover).cancel();
+                }
+            }
             Event::MouseMove(mouse_event) => {
-                ctx.set_handled();
                 ctx.set_cursor(&druid::Cursor::IBeam);
                 let doc = data.main_split.editor_doc(self.view_id);
                 let editor =
@@ -1774,20 +2329,25 @@ impl Widget<LapceTabData> for LapceEditor {
                 self.mouse_move(
                     ctx,
                     mouse_event.pos,
+                    mouse_event.mods,
                     &mut editor_data,
                     &data.config,
                 );
                 data.update_from_editor_buffer_data(editor_data, &editor, &doc);
+                if ctx.is_active() {
+                    ctx.set_handled();
+                }
             }
             Event::MouseUp(_mouse_event) => {
+                self.mouse_mods = Modifiers::empty();
                 ctx.set_active(false);
             }
             Event::MouseDown(mouse_event) => {
+                self.mouse_mods = mouse_event.mods;
                 let doc = data.main_split.editor_doc(self.view_id);
                 let editor =
                     data.main_split.editors.get(&self.view_id).unwrap().clone();
-                let mut editor_data = data.editor_view_content(self.view_id);
-                self.mouse_down(ctx, mouse_event, &mut editor_data, &data.config);
+                let editor_data = self.mouse_down(ctx, mouse_event, data, env);
                 data.update_from_editor_buffer_data(editor_data, &editor, &doc);
             }
             Event::Timer(id) => {
@@ -1800,10 +2360,11 @@ impl Widget<LapceTabData> for LapceEditor {
                         ctx.text(),
                         editor.cursor.get_mode(),
                         self.mouse_pos,
-                        data.config.editor.font_size,
+                        &editor.view,
                         &data.config,
                     );
                     editor_data.update_hover(ctx, offset);
+
                     data.update_from_editor_buffer_data(editor_data, &editor, &doc);
                 } else if self.drag_timer == *id {
                     let doc = data.main_split.editor_doc(self.view_id);
@@ -1813,6 +2374,7 @@ impl Widget<LapceTabData> for LapceEditor {
                     self.mouse_move(
                         ctx,
                         self.mouse_pos,
+                        self.mouse_mods,
                         &mut editor_data,
                         &data.config,
                     );
@@ -1820,54 +2382,162 @@ impl Widget<LapceTabData> for LapceEditor {
                 }
             }
             Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
-                let cmd = cmd.get_unchecked(LAPCE_UI_COMMAND);
-                if let LapceUICommand::ShowCodeActions(point) = cmd {
-                    let editor_data = data.editor_view_content(self.view_id);
-                    if let Some(actions) = editor_data.current_code_actions() {
-                        if !actions.is_empty() {
-                            let mut menu = druid::Menu::new("");
-
-                            for action in actions.iter() {
-                                let title = match action {
-                                    CodeActionOrCommand::Command(c) => {
-                                        c.title.clone()
-                                    }
-                                    CodeActionOrCommand::CodeAction(a) => {
-                                        a.title.clone()
-                                    }
-                                };
-                                let mut item = druid::MenuItem::new(title);
-                                item = item.command(Command::new(
-                                    LAPCE_UI_COMMAND,
-                                    LapceUICommand::RunCodeAction(action.clone()),
-                                    Target::Widget(editor_data.view_id),
-                                ));
-                                menu = menu.entry(item);
+                match cmd.get_unchecked(LAPCE_UI_COMMAND) {
+                    LapceUICommand::ShowCodeActions(point) => {
+                        let editor_data = data.editor_view_content(self.view_id);
+                        if let Some((plugin_id, actions)) =
+                            editor_data.current_code_actions()
+                        {
+                            if !actions.is_empty() {
+                                let mut menu = druid::Menu::new("");
+
+                                for action in actions.iter() {
+                                    let title = match action {
+                                        CodeActionOrCommand::Command(c) => {
+                                            c.title.clone()
+                                        }
+                                        CodeActionOrCommand::CodeAction(a) => {
+                                            a.title.clone()
+                                        }
+                                    };
+                                    let mut item = druid::MenuItem::new(title);
+                                    item = item.command(Command::new(
+                                        LAPCE_UI_COMMAND,
+                                        LapceUICommand::RunCodeAction(
+                                            action.clone(),
+                                            *plugin_id,
+                                        ),
+                                        Target::Widget(editor_data.view_id),
+                                    ));
+                                    menu = menu.entry(item);
+                                }
+
+                                let point = point.unwrap_or_else(|| {
+                                    let offset = editor_data.editor.cursor.offset();
+                                    let (line, col) = editor_data
+                                        .doc
+                                        .buffer()
+                                        .offset_to_line_col(offset);
+
+                                    let phantom_text = editor_data
+                                        .doc
+                                        .line_phantom_text(&data.config, line);
+
+                                    let col = phantom_text.col_at(col);
+
+                                    let x = editor_data
+                                        .doc
+                                        .line_point_of_line_col(
+                                            ctx.text(),
+                                            line,
+                                            col,
+                                            editor_data.config.editor.font_size,
+                                            &editor_data.config,
+                                        )
+                                        .x;
+                                    let y = editor_data.config.editor.line_height()
+                                        as f64
+                                        * (line + 1) as f64;
+                                    ctx.to_window(Point::new(x, y))
+                                });
+                                ctx.show_context_menu::<LapceData>(menu, point);
+                            }
+                        }
+                    }
+                    LapceUICommand::ApplySelectionRange {
+                        buffer_id,
+                        rev,
+                        direction,
+                    } => {
+                        if let Some(editor) = data
+                            .main_split
+                            .active
+                            .and_then(|active| data.main_split.editors.get(&active))
+                            .cloned()
+                        {
+                            let mut editor_data =
+                                data.editor_view_content(editor.view_id);
+
+                            let orig_doc =
+                                data.main_split.editor_doc(editor.view_id);
+
+                            if orig_doc.id() != *buffer_id || orig_doc.rev() != *rev
+                            {
+                                return;
+                            }
+
+                            let doc = Arc::make_mut(&mut editor_data.doc);
+
+                            if let Some(selection) =
+                                doc.change_syntax_selection(*direction)
+                            {
+                                Arc::make_mut(&mut editor_data.editor)
+                                    .cursor
+                                    .update_selection(orig_doc.buffer(), selection);
+                                data.update_from_editor_buffer_data(
+                                    editor_data,
+                                    &editor,
+                                    &orig_doc,
+                                );
+                            }
+                        }
+                    }
+                    LapceUICommand::StoreSelectionRangeAndApply {
+                        rev,
+                        buffer_id,
+                        current_selection,
+                        ranges,
+                        direction,
+                    } => {
+                        if let Some(editor) = data
+                            .main_split
+                            .active
+                            .and_then(|active| data.main_split.editors.get(&active))
+                            .cloned()
+                        {
+                            let mut editor_data =
+                                data.editor_view_content(editor.view_id);
+                            let orig_doc =
+                                data.main_split.editor_doc(editor.view_id);
+
+                            if orig_doc.id() != *buffer_id || orig_doc.rev() != *rev
+                            {
+                                return;
                             }
 
-                            let point = point.unwrap_or_else(|| {
-                                let offset = editor_data.editor.cursor.offset();
-                                let (line, col) = editor_data
-                                    .doc
-                                    .buffer()
-                                    .offset_to_line_col(offset);
-                                let x = editor_data
-                                    .doc
-                                    .point_of_line_col(
-                                        ctx.text(),
-                                        line,
-                                        col,
-                                        editor_data.config.editor.font_size,
-                                        &editor_data.config,
-                                    )
-                                    .x;
-                                let y = editor_data.config.editor.line_height as f64
-                                    * (line + 1) as f64;
-                                ctx.to_window(Point::new(x, y))
-                            });
-                            ctx.show_context_menu::<LapceData>(menu, point);
+                            let mut doc = Arc::make_mut(&mut editor_data.doc);
+                            if let (_, Some(ranges)) = (
+                                &doc.syntax_selection_range,
+                                ranges.first().cloned(),
+                            ) {
+                                doc.syntax_selection_range =
+                                    Some(SyntaxSelectionRanges {
+                                        buffer_id: *buffer_id,
+                                        rev: *rev,
+                                        last_known_selection: *current_selection,
+                                        ranges,
+                                        current_selection: None,
+                                    });
+                            };
+
+                            data.update_from_editor_buffer_data(
+                                editor_data,
+                                &editor,
+                                &orig_doc,
+                            );
+
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::ApplySelectionRange {
+                                    buffer_id: *buffer_id,
+                                    rev: *rev,
+                                    direction: *direction,
+                                },
+                                Target::Auto,
+                            ));
                         }
                     }
+                    _ => {}
                 }
             }
             _ => (),
@@ -1907,23 +2577,35 @@ impl Widget<LapceTabData> for LapceEditor {
         data: &LapceTabData,
         env: &Env,
     ) -> Size {
+        ctx.set_paint_insets((1.0, 0.0, 0.0, 0.0));
         let editor_data = data.editor_view_content(self.view_id);
-        Self::get_size(&editor_data, ctx.text(), bc.max(), &data.panels, env)
+        Self::get_size(&editor_data, ctx.text(), bc.max(), &data.panel, env)
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
-        let is_focused = data.focus == self.view_id;
+        let is_focused = *data.focus == self.view_id;
         let data = data.editor_view_content(self.view_id);
+
+        // TODO: u128 is supported by config-rs since 0.12.0, but also the API changed heavily,
+        // casting blink_interval to u128 for now but can be removed once config-rs is bumped
+        /*
+            is_focus is used in paint_cursor_new to decide whether to draw cursor (and animate it / "blink")
+            cursor will blink based if below conditions are true:
+            - editor is focused
+            - blink_interval is not 0
+            - time since last blink is exact to blink_interval
+        */
         let is_focused = is_focused
-            && (data
-                .editor
-                .last_cursor_instant
-                .borrow()
-                .elapsed()
-                .as_millis()
-                / 500)
-                % 2
-                == 0;
+            && (data.config.editor.blink_interval == 0
+                || (data
+                    .editor
+                    .last_cursor_instant
+                    .borrow()
+                    .elapsed()
+                    .as_millis()
+                    / data.config.editor.blink_interval as u128)
+                    % 2
+                    == 0);
         self.paint_content(&data, ctx, is_focused, env);
     }
 }
diff --git a/lapce-ui/src/editor/bread_crumb.rs b/lapce-ui/src/editor/bread_crumb.rs
new file mode 100644
index 0000000000..a54b61385d
--- /dev/null
+++ b/lapce-ui/src/editor/bread_crumb.rs
@@ -0,0 +1,158 @@
+use std::path::Path;
+
+use druid::{
+    piet::{PietTextLayout, Svg, Text, TextLayout, TextLayoutBuilder},
+    BoxConstraints, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx,
+    PaintCtx, Point, Rect, RenderContext, Size, UpdateCtx, Widget, WidgetId,
+};
+use lapce_data::{
+    config::{LapceIcons, LapceTheme},
+    data::LapceTabData,
+    document::BufferContent,
+};
+
+pub struct LapceEditorBreadCrumb {
+    pub view_id: WidgetId,
+    text_layouts: Vec<(Point, PietTextLayout)>,
+    svgs: Vec<(Rect, Svg)>,
+}
+
+impl LapceEditorBreadCrumb {
+    pub fn new(view_id: WidgetId) -> Self {
+        Self {
+            view_id,
+            text_layouts: Vec::new(),
+            svgs: Vec::new(),
+        }
+    }
+}
+
+impl Widget<LapceTabData> for LapceEditorBreadCrumb {
+    fn event(
+        &mut self,
+        _ctx: &mut EventCtx,
+        _event: &Event,
+        _data: &mut LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn lifecycle(
+        &mut self,
+        _ctx: &mut LifeCycleCtx,
+        _event: &LifeCycle,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn update(
+        &mut self,
+        _ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        _env: &Env,
+    ) -> Size {
+        let editor_buffer = data.editor_view_content(self.view_id);
+        self.text_layouts.clear();
+        self.svgs.clear();
+
+        let line_height = data.config.editor.line_height() as f64;
+
+        let font_size = data.config.ui.font_size() as f64;
+
+        let mut x = font_size;
+        if let BufferContent::File(path) = &editor_buffer.editor.content {
+            let mut path = path.to_path_buf();
+            if let Some(workspace_path) = data.workspace.path.as_ref() {
+                path = path
+                    .strip_prefix(workspace_path)
+                    .unwrap_or(&path)
+                    .to_path_buf();
+            }
+
+            if let Some(path) = path.parent() {
+                for p in path.ancestors().collect::<Vec<&Path>>().iter().rev() {
+                    if let Some(file_name) = p.file_name().and_then(|s| s.to_str()) {
+                        if !file_name.is_empty() {
+                            let text_layout = ctx
+                                .text()
+                                .new_text_layout(file_name.to_string())
+                                .font(data.config.ui.font_family(), font_size)
+                                .text_color(
+                                    data.config
+                                        .get_color_unchecked(LapceTheme::EDITOR_DIM)
+                                        .clone(),
+                                )
+                                .build()
+                                .unwrap();
+                            let size = text_layout.size();
+                            self.text_layouts.push((
+                                Point::new(x, text_layout.y_offset(line_height)),
+                                text_layout,
+                            ));
+
+                            x += size.width;
+                            self.svgs.push((
+                                Rect::ZERO
+                                    .with_origin(Point::new(
+                                        x + font_size / 2.0,
+                                        line_height / 2.0,
+                                    ))
+                                    .inflate(font_size / 2.0, font_size / 2.0),
+                                data.config.ui_svg(LapceIcons::BREADCRUMB_SEPARATOR),
+                            ));
+                            x += font_size;
+                        }
+                    }
+                }
+            }
+            if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
+                let text_layout = ctx
+                    .text()
+                    .new_text_layout(file_name.to_string())
+                    .font(data.config.ui.font_family(), font_size)
+                    .text_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_DIM)
+                            .clone(),
+                    )
+                    .build()
+                    .unwrap();
+                let size = text_layout.size();
+                self.text_layouts.push((
+                    Point::new(x, text_layout.y_offset(line_height)),
+                    text_layout,
+                ));
+
+                x += size.width;
+                x += font_size;
+            }
+        }
+
+        Size::new(bc.max().width.max(x), line_height)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+        for (point, text_layout) in self.text_layouts.iter() {
+            ctx.draw_text(text_layout, *point);
+        }
+
+        for (rect, svg) in self.svgs.iter() {
+            ctx.draw_svg(
+                svg,
+                *rect,
+                Some(data.config.get_color_unchecked(LapceTheme::EDITOR_DIM)),
+            );
+        }
+    }
+}
diff --git a/lapce-ui/src/editor/container.rs b/lapce-ui/src/editor/container.rs
index edc2b8ed32..9c17aab99c 100644
--- a/lapce-ui/src/editor/container.rs
+++ b/lapce-ui/src/editor/container.rs
@@ -1,9 +1,11 @@
 use druid::{
-    BoxConstraints, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx,
-    PaintCtx, Point, Size, UpdateCtx, Widget, WidgetId, WidgetPod,
+    kurbo::Line, BoxConstraints, Env, Event, EventCtx, LayoutCtx, LifeCycle,
+    LifeCycleCtx, PaintCtx, Point, RenderContext, Size, UpdateCtx, Widget, WidgetId,
+    WidgetPod,
 };
-use lapce_data::data::LapceTabData;
+use lapce_data::{config::LapceTheme, data::LapceTabData};
 
+use super::bread_crumb::LapceEditorBreadCrumb;
 use crate::{
     editor::{gutter::LapceEditorGutter, LapceEditor},
     scroll::{LapceIdentityWrapper, LapcePadding, LapceScroll},
@@ -13,6 +15,8 @@ pub struct LapceEditorContainer {
     pub view_id: WidgetId,
     pub scroll_id: WidgetId,
     pub display_gutter: bool,
+    pub bread_crumb:
+        WidgetPod<LapceTabData, LapceScroll<LapceTabData, LapceEditorBreadCrumb>>,
     pub gutter:
         WidgetPod<LapceTabData, LapcePadding<LapceTabData, LapceEditorGutter>>,
     pub editor: WidgetPod<
@@ -24,6 +28,9 @@ pub struct LapceEditorContainer {
 impl LapceEditorContainer {
     pub fn new(view_id: WidgetId, editor_id: WidgetId) -> Self {
         let scroll_id = WidgetId::next();
+        let bread_crumb = LapceScroll::new(LapceEditorBreadCrumb::new(view_id))
+            .horizontal()
+            .vertical_scroll_for_horizontal();
         let gutter = LapceEditorGutter::new(view_id);
         let gutter = LapcePadding::new((10.0, 0.0, 0.0, 0.0), gutter);
         let editor = LapceEditor::new(view_id, editor_id);
@@ -35,10 +42,24 @@ impl LapceEditorContainer {
             view_id,
             scroll_id,
             display_gutter: true,
+            bread_crumb: WidgetPod::new(bread_crumb),
             gutter: WidgetPod::new(gutter),
             editor: WidgetPod::new(editor),
         }
     }
+
+    fn show_bread_crumbs(&self, data: &LapceTabData) -> bool {
+        if !data.config.editor.show_bread_crumbs {
+            return false;
+        }
+
+        let editor = data.main_split.editors.get(&self.view_id).unwrap();
+        if editor.content.is_file() {
+            return true;
+        }
+
+        false
+    }
 }
 
 impl Widget<LapceTabData> for LapceEditorContainer {
@@ -49,6 +70,9 @@ impl Widget<LapceTabData> for LapceEditorContainer {
         data: &mut LapceTabData,
         env: &Env,
     ) {
+        if self.show_bread_crumbs(data) {
+            self.bread_crumb.event(ctx, event, data, env);
+        }
         self.gutter.event(ctx, event, data, env);
         self.editor.event(ctx, event, data, env);
         match event {
@@ -72,6 +96,7 @@ impl Widget<LapceTabData> for LapceEditorContainer {
         data: &LapceTabData,
         env: &Env,
     ) {
+        self.bread_crumb.lifecycle(ctx, event, data, env);
         self.gutter.lifecycle(ctx, event, data, env);
         self.editor.lifecycle(ctx, event, data, env);
     }
@@ -83,6 +108,7 @@ impl Widget<LapceTabData> for LapceEditorContainer {
         data: &LapceTabData,
         env: &Env,
     ) {
+        self.bread_crumb.update(ctx, data, env);
         self.gutter.update(ctx, data, env);
         self.editor.update(ctx, data, env);
     }
@@ -95,8 +121,25 @@ impl Widget<LapceTabData> for LapceEditorContainer {
         env: &Env,
     ) -> Size {
         let self_size = bc.max();
-        let gutter_size = self.gutter.layout(ctx, bc, data, env);
-        self.gutter.set_origin(ctx, data, env, Point::ZERO);
+        let show_bread_crumbs = self.show_bread_crumbs(data);
+
+        let mut bread_crumbs_size = Size::ZERO;
+        if show_bread_crumbs {
+            bread_crumbs_size = self.bread_crumb.layout(ctx, bc, data, env);
+            self.bread_crumb.set_origin(ctx, data, env, Point::ZERO);
+        }
+
+        let bc = BoxConstraints::tight(Size::new(
+            self_size.width,
+            self_size.height - bread_crumbs_size.height,
+        ));
+        let gutter_size = self.gutter.layout(ctx, &bc, data, env);
+        self.gutter.set_origin(
+            ctx,
+            data,
+            env,
+            Point::new(0.0, bread_crumbs_size.height),
+        );
         let editor_size = Size::new(
             self_size.width
                 - if self.display_gutter {
@@ -104,7 +147,7 @@ impl Widget<LapceTabData> for LapceEditorContainer {
                 } else {
                     0.0
                 },
-            self_size.height,
+            self_size.height - bread_crumbs_size.height,
         );
         let editor_bc = BoxConstraints::new(Size::ZERO, editor_size);
         let editor_size = self.editor.layout(ctx, &editor_bc, data, env);
@@ -118,7 +161,7 @@ impl Widget<LapceTabData> for LapceEditorContainer {
                 } else {
                     0.0
                 },
-                0.0,
+                bread_crumbs_size.height,
             ),
         );
         *data
@@ -134,14 +177,72 @@ impl Widget<LapceTabData> for LapceEditorContainer {
             } else {
                 0.0
             } + editor_size.width,
-            editor_size.height,
+            bread_crumbs_size.height + editor_size.height,
         )
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let show_bread_crumbs = self.show_bread_crumbs(data);
+
         self.editor.paint(ctx, data, env);
         if self.display_gutter {
             self.gutter.paint(ctx, data, env);
         }
+
+        let mut bread_crumbs_height = 0.0;
+        if data.config.editor.sticky_header {
+            let data = data.editor_view_content(self.view_id);
+            let info = data.editor.sticky_header.borrow();
+            let size = ctx.size();
+            if info.height > 0.0 {
+                bread_crumbs_height = if show_bread_crumbs {
+                    self.bread_crumb.layout_rect().height()
+                } else {
+                    0.0
+                };
+
+                ctx.with_save(|ctx| {
+                    let rect = Size::new(size.width, info.height)
+                        .to_rect()
+                        .with_origin(Point::new(0.0, bread_crumbs_height));
+                    ctx.clip(rect.inset((0.0, 0.0, 0.0, info.height)));
+                    ctx.blurred_rect(
+                        rect.inflate(50.0, 0.0),
+                        3.0,
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                    );
+                });
+            }
+        }
+
+        if show_bread_crumbs {
+            if bread_crumbs_height == 0.0 {
+                let rect = self.bread_crumb.layout_rect();
+                let shadow_width = data.config.ui.drop_shadow_width() as f64;
+                if shadow_width > 0.0 {
+                    ctx.with_save(|ctx| {
+                        ctx.clip(rect.inset((0.0, 0.0, 0.0, rect.height())));
+                        ctx.blurred_rect(
+                            rect,
+                            shadow_width,
+                            data.config.get_color_unchecked(
+                                LapceTheme::LAPCE_DROPDOWN_SHADOW,
+                            ),
+                        );
+                    });
+                } else {
+                    ctx.stroke(
+                        Line::new(
+                            Point::new(rect.x0, rect.y1 - 0.5),
+                            Point::new(rect.x1, rect.y1 - 0.5),
+                        ),
+                        data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                        1.0,
+                    );
+                }
+            }
+            self.bread_crumb.paint(ctx, data, env);
+        }
     }
 }
diff --git a/lapce-ui/src/editor/gutter.rs b/lapce-ui/src/editor/gutter.rs
index e6be3cc88f..7737519ad6 100644
--- a/lapce-ui/src/editor/gutter.rs
+++ b/lapce-ui/src/editor/gutter.rs
@@ -1,4 +1,3 @@
-use crate::svg::get_svg;
 use druid::{
     piet::{PietText, Text, TextLayout, TextLayoutBuilder},
     BoxConstraints, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
@@ -6,9 +5,11 @@ use druid::{
     Widget, WidgetId,
 };
 use lapce_core::buffer::DiffLines;
+use lapce_data::document::BufferContent;
+use lapce_data::history::DocumentHistory;
 use lapce_data::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::LapceTheme,
+    config::{LapceIcons, LapceTheme},
     data::{EditorView, LapceTabData},
     editor::{LapceEditorBufferData, Syntax},
 };
@@ -43,13 +44,14 @@ impl Widget<LapceTabData> for LapceEditorGutter {
             }
             Event::MouseUp(mouse_event) => {
                 let data = data.editor_view_content(self.view_id);
-                if let Some(actions) = data.current_code_actions() {
+                if let Some((_plugin_id, actions)) = data.current_code_actions() {
                     if !actions.is_empty() {
                         let rect = self.code_actions_rect(ctx.text(), &data);
                         if rect.contains(self.mouse_down_pos)
                             && rect.contains(mouse_event.pos)
                         {
-                            let line_height = data.config.editor.line_height as f64;
+                            let line_height =
+                                data.config.editor.line_height() as f64;
                             let offset = data.editor.cursor.offset();
                             let (line, _) =
                                 data.doc.buffer().offset_to_line_col(offset);
@@ -67,6 +69,25 @@ impl Widget<LapceTabData> for LapceEditorGutter {
                         }
                     }
                 }
+                let editor = data.main_split.editors.get(&self.view_id).unwrap();
+                if let BufferContent::File(_) = &editor.content {
+                    if let EditorView::Diff(version) = &data.editor.view {
+                        if let Some(history) = data.doc.get_history(version) {
+                            let diff_skip = self
+                                .check_and_get_diff_skip_mouse_within(
+                                    ctx,
+                                    &data,
+                                    history,
+                                    mouse_event.pos,
+                                );
+                            if let Some(diff_skip) = diff_skip {
+                                history.trigger_increase_diff_extend_lines(
+                                    &data.doc, diff_skip,
+                                )
+                            }
+                        }
+                    }
+                };
             }
             _ => {}
         }
@@ -153,7 +174,7 @@ impl LapceEditorGutter {
         let history = data.doc.get_history(version).unwrap();
         let self_size = ctx.size();
         let rect = self_size.to_rect();
-        let line_height = data.config.editor.line_height as f64;
+        let line_height = data.config.editor.line_height() as f64;
         let scroll_offset = data.editor.scroll_offset;
         let start_line = (scroll_offset.y / line_height).floor() as usize;
         let end_line =
@@ -192,12 +213,6 @@ impl LapceEditorGutter {
                         let actual_line = l - (line - len) + r.start;
 
                         let content = actual_line + 1;
-                        let x = ((last_line + 1).to_string().len()
-                            - content.to_string().len())
-                            as f64
-                            * width;
-                        let y = line_height * l as f64 + 5.0 - scroll_offset.y;
-                        let pos = Point::new(x, y);
 
                         let text_layout = ctx
                             .text()
@@ -221,6 +236,14 @@ impl LapceEditorGutter {
                             )
                             .build()
                             .unwrap();
+                        let x = ((last_line + 1).to_string().len()
+                            - content.to_string().len())
+                            as f64
+                            * width;
+                        let y = line_height * l as f64
+                            + text_layout.y_offset(line_height)
+                            - scroll_offset.y;
+                        let pos = Point::new(x, y);
                         ctx.draw_text(&text_layout, pos);
 
                         if l > end_line {
@@ -243,12 +266,6 @@ impl LapceEditorGutter {
                         let right_actual_line = l - (line - len) + r.start;
 
                         let left_content = left_actual_line + 1;
-                        let x = ((last_line + 1).to_string().len()
-                            - left_content.to_string().len())
-                            as f64
-                            * width;
-                        let y = line_height * l as f64 + 5.0 - scroll_offset.y;
-                        let pos = Point::new(x, y);
 
                         let text_layout = ctx
                             .text()
@@ -264,6 +281,14 @@ impl LapceEditorGutter {
                             )
                             .build()
                             .unwrap();
+                        let x = ((last_line + 1).to_string().len()
+                            - left_content.to_string().len())
+                            as f64
+                            * width;
+                        let y = line_height * l as f64
+                            + text_layout.y_offset(line_height)
+                            - scroll_offset.y;
+                        let pos = Point::new(x, y);
                         ctx.draw_text(&text_layout, pos);
 
                         let right_content = right_actual_line + 1;
@@ -319,6 +344,25 @@ impl LapceEditorGutter {
                             .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
                         1.0,
                     );
+                    let pos = Point::new(
+                        (self_size.width - width * 3.0) / 2.0,
+                        line_height * line as f64 - scroll_offset.y,
+                    );
+                    let text_layout = ctx
+                        .text()
+                        .new_text_layout("...")
+                        .font(
+                            data.config.editor.font_family(),
+                            data.config.editor.font_size as f64,
+                        )
+                        .text_color(
+                            data.config
+                                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                                .clone(),
+                        )
+                        .build()
+                        .unwrap();
+                    ctx.draw_text(&text_layout, pos);
                     line += 1;
                 }
                 DiffLines::Right(r) => {
@@ -346,14 +390,6 @@ impl LapceEditorGutter {
                         let actual_line = l - (line - len) + r.start;
 
                         let content = actual_line + 1;
-                        let x = ((last_line + 1).to_string().len()
-                            - content.to_string().len())
-                            as f64
-                            * width
-                            + self.width
-                            + 2.0 * width;
-                        let y = line_height * l as f64 + 5.0 - scroll_offset.y;
-                        let pos = Point::new(x, y);
 
                         let text_layout = ctx
                             .text()
@@ -375,6 +411,16 @@ impl LapceEditorGutter {
                             })
                             .build()
                             .unwrap();
+                        let x = ((last_line + 1).to_string().len()
+                            - content.to_string().len())
+                            as f64
+                            * width
+                            + self.width
+                            + 2.0 * width;
+                        let y = line_height * l as f64
+                            + text_layout.y_offset(line_height)
+                            - scroll_offset.y;
+                        let pos = Point::new(x, y);
                         ctx.draw_text(&text_layout, pos);
 
                         if l > end_line {
@@ -386,6 +432,55 @@ impl LapceEditorGutter {
         }
     }
 
+    fn check_and_get_diff_skip_mouse_within(
+        &self,
+        ctx: &mut EventCtx,
+        data: &LapceEditorBufferData,
+        history: &DocumentHistory,
+        mouse_pos: Point,
+    ) -> Option<DiffLines> {
+        let line_height = data.config.editor.line_height() as f64;
+        let self_size = ctx.size();
+        let rect = self_size.to_rect();
+        let scroll_offset = data.editor.scroll_offset;
+        let end_line =
+            (scroll_offset.y + rect.height() / line_height).ceil() as usize;
+
+        let mut line = 0;
+        for change in history.changes().iter() {
+            match change {
+                DiffLines::Left(r) => {
+                    let len = r.len();
+                    line += len;
+                }
+                DiffLines::Both(_, r) => {
+                    let len = r.len();
+                    line += len;
+                }
+                DiffLines::Skip(l, r) => {
+                    let rect = Size::new(self_size.width, line_height)
+                        .to_rect()
+                        .with_origin(Point::new(
+                            0.0,
+                            line_height * line as f64 - scroll_offset.y,
+                        ));
+                    if rect.contains(mouse_pos) {
+                        return Some(DiffLines::Skip(l.clone(), r.clone()));
+                    }
+                    line += 1;
+                }
+                DiffLines::Right(r) => {
+                    let len = r.len();
+                    line += len;
+                }
+            }
+            if line > end_line {
+                break;
+            }
+        }
+        None
+    }
+
     fn paint_gutter_code_lens(
         &self,
         data: &LapceEditorBufferData,
@@ -395,7 +490,7 @@ impl LapceEditorGutter {
         let scroll_offset = data.editor.scroll_offset;
         let empty_lens = Syntax::lens_from_normal_lines(
             data.doc.buffer().len(),
-            data.config.editor.line_height,
+            data.config.editor.line_height(),
             data.config.editor.code_lens_font_size,
             &[],
         );
@@ -415,7 +510,7 @@ impl LapceEditorGutter {
         let end_line = lens
             .line_of_height(
                 (scroll_offset.y + rect.height()).ceil() as usize
-                    + data.config.editor.line_height,
+                    + data.config.editor.line_height(),
             )
             .min(last_line);
         let char_width = data.config.editor_char_width(ctx.text());
@@ -434,7 +529,7 @@ impl LapceEditorGutter {
                 cursor_line - line
             };
             let content = content.to_string();
-            let is_small = line_height < data.config.editor.line_height;
+            let is_small = line_height < data.config.editor.line_height();
             let text_layout = ctx
                 .text()
                 .new_text_layout(content.clone())
@@ -464,7 +559,7 @@ impl LapceEditorGutter {
                     + if is_small {
                         0.0
                     } else {
-                        (line_height as f64 - text_layout.size().height) / 2.0
+                        text_layout.y_offset(line_height as f64)
                     },
             );
             ctx.draw_text(&text_layout, pos);
@@ -478,7 +573,7 @@ impl LapceEditorGutter {
         text: &mut PietText,
         data: &LapceEditorBufferData,
     ) -> Rect {
-        let line_height = data.config.editor.line_height as f64;
+        let line_height = data.config.editor.line_height() as f64;
         let offset = data.editor.cursor.offset();
         let (line, _) = data.doc.buffer().offset_to_line_col(offset);
 
@@ -497,9 +592,9 @@ impl LapceEditorGutter {
         data: &LapceEditorBufferData,
         ctx: &mut PaintCtx,
     ) {
-        if let Some(actions) = data.current_code_actions() {
+        if let Some((_plugin_id, actions)) = data.current_code_actions() {
             if !actions.is_empty() {
-                let svg = get_svg("lightbulb.svg").unwrap();
+                let svg = data.config.ui_svg(LapceIcons::LIGHTBULB);
                 let rect = self.code_actions_rect(ctx.text(), data);
                 ctx.draw_svg(
                     &svg,
@@ -510,6 +605,66 @@ impl LapceEditorGutter {
         }
     }
 
+    fn paint_sticky_header(
+        &self,
+        ctx: &mut PaintCtx,
+        data: &LapceEditorBufferData,
+        line_label_length: f64,
+    ) {
+        if !data.config.editor.sticky_header {
+            return;
+        }
+
+        let size = ctx.size();
+        let line_height = data.config.editor.line_height() as f64;
+
+        let info = data.editor.sticky_header.borrow();
+
+        let sticky_area_rect = Size::new(size.width, info.height)
+            .to_rect()
+            .with_origin(Point::new(0.0, 0.0));
+
+        ctx.fill(
+            sticky_area_rect,
+            data.config
+                .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+        );
+
+        let total_lines = info.lines.len();
+        for (i, line) in info.lines.iter().enumerate() {
+            let y_diff = if i == total_lines - 1 {
+                info.last_y_diff
+            } else {
+                0.0
+            };
+
+            let rect = Size::new(size.width, line_height - y_diff)
+                .to_rect()
+                .with_origin(Point::new(0.0, line_height * i as f64));
+            ctx.with_save(|ctx| {
+                ctx.clip(rect);
+                let text_layout = ctx
+                    .text()
+                    .new_text_layout((line + 1).to_string())
+                    .font(
+                        data.config.editor.font_family(),
+                        data.config.editor.font_size as f64,
+                    )
+                    .text_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_DIM)
+                            .clone(),
+                    )
+                    .build()
+                    .unwrap();
+                let x = line_label_length - text_layout.size().width;
+                let y = line_height * i as f64 + text_layout.y_offset(line_height)
+                    - y_diff;
+                ctx.draw_text(&text_layout, Point::new(x, y));
+            });
+        }
+    }
+
     fn paint_gutter(&self, data: &LapceEditorBufferData, ctx: &mut PaintCtx) {
         let rect = ctx.size().to_rect();
         ctx.with_save(|ctx| {
@@ -519,11 +674,11 @@ impl LapceEditorGutter {
                 self.paint_gutter_inline_diff(data, ctx, version);
                 return;
             }
-            if data.editor.code_lens {
+            if data.editor.is_code_lens() {
                 self.paint_gutter_code_lens(data, ctx);
                 return;
             }
-            let line_height = data.config.editor.line_height as f64;
+            let line_height = data.config.editor.line_height() as f64;
             let scroll_offset = data.editor.scroll_offset;
             let start_line = (scroll_offset.y / line_height).floor() as usize;
             let num_lines = (ctx.size().height / line_height).floor() as usize;
@@ -549,12 +704,7 @@ impl LapceEditorGutter {
                 let line_no = if sequential_line_numbers || line == current_line {
                     line + 1
                 } else {
-                    // TODO: after Rust 1.60, this can be replaced with `line.abs_diff(current_line)`
-                    if line > current_line {
-                        line - current_line
-                    } else {
-                        current_line - line
-                    }
+                    line.abs_diff(current_line)
                 };
 
                 let content = line_no.to_string();
@@ -576,11 +726,11 @@ impl LapceEditorGutter {
                     .unwrap();
 
                 // Horizontally right aligned
-                let x = line_label_length as f64 - text_layout.size().width;
+                let x = line_label_length - text_layout.size().width;
 
                 // Vertically centered
                 let y = line_height * line as f64 - scroll_offset.y
-                    + (line_height - text_layout.size().height) / 2.0;
+                    + text_layout.y_offset(line_height);
 
                 ctx.draw_text(&text_layout, Point::new(x, y));
             }
@@ -672,6 +822,8 @@ impl LapceEditorGutter {
             if *data.main_split.active == Some(self.view_id) {
                 self.paint_code_actions_hint(data, ctx);
             }
+
+            self.paint_sticky_header(ctx, data, line_label_length);
         });
     }
 }
diff --git a/lapce-ui/src/editor/header.rs b/lapce-ui/src/editor/header.rs
index afb93cdd6c..a57ac5efbd 100644
--- a/lapce-ui/src/editor/header.rs
+++ b/lapce-ui/src/editor/header.rs
@@ -1,7 +1,7 @@
 use std::{iter::Iterator, path::PathBuf};
 
 use druid::{
-    piet::{Text, TextAttribute, TextLayout as TextLayoutTrait, TextLayoutBuilder},
+    piet::{Text, TextAttribute, TextLayoutBuilder},
     BoxConstraints, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
     LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect, RenderContext, Size, Target,
     UpdateCtx, Widget, WidgetId,
@@ -9,16 +9,13 @@ use druid::{
 use lapce_core::command::FocusCommand;
 use lapce_data::{
     command::{CommandKind, LapceCommand, LAPCE_COMMAND},
-    config::LapceTheme,
+    config::{LapceIcons, LapceTheme},
     data::{LapceTabData, LapceWorkspace},
     document::BufferContent,
     editor::LapceEditorBufferData,
 };
 
-use crate::{
-    svg::{file_svg, get_svg},
-    tab::LapceIcon,
-};
+use crate::tab::LapceIcon;
 
 pub struct LapceEditorHeader {
     view_id: WidgetId,
@@ -53,7 +50,7 @@ impl LapceEditorHeader {
         let x =
             self_size.width - ((icons.len() + 1) as f64) * (gap + self.icon_size);
         let icon = LapceIcon {
-            icon: "close.svg",
+            icon: LapceIcons::CLOSE,
             rect: Size::new(self.icon_size, self.icon_size)
                 .to_rect()
                 .with_origin(Point::new(x, gap)),
@@ -71,7 +68,7 @@ impl LapceEditorHeader {
         let x =
             self_size.width - ((icons.len() + 1) as f64) * (gap + self.icon_size);
         let icon = LapceIcon {
-            icon: "split-horizontal.svg",
+            icon: LapceIcons::SPLIT_HORIZONTAL,
             rect: Size::new(self.icon_size, self.icon_size)
                 .to_rect()
                 .with_origin(Point::new(x, gap)),
@@ -148,18 +145,19 @@ impl LapceEditorHeader {
 
             ctx.with_save(|ctx| {
                 ctx.clip(clip_rect);
-                let svg = file_svg(&path);
+                let (svg, svg_color) = data.config.file_svg(&path);
 
                 let font_size = data.config.ui.font_size() as f64;
 
-                let width = font_size;
-                let height = font_size;
+                let svg_size = data.config.ui.icon_size() as f64;
                 let rect =
-                    Size::new(width, height).to_rect().with_origin(Point::new(
-                        (size.height - width) / 2.0,
-                        (size.height - height) / 2.0,
-                    ));
-                ctx.draw_svg(&svg, rect, None);
+                    Size::new(svg_size, svg_size)
+                        .to_rect()
+                        .with_origin(Point::new(
+                            (size.height - svg_size) / 2.0,
+                            (size.height - svg_size) / 2.0,
+                        ));
+                ctx.draw_svg(&svg, rect, svg_color);
 
                 let mut file_name = path
                     .file_name()
@@ -184,7 +182,7 @@ impl LapceEditorHeader {
                     .unwrap_or("")
                     .to_string();
                 if !folder.is_empty() {
-                    file_name = format!("{} {}", file_name, folder);
+                    file_name = format!("{file_name} {folder}");
                 }
                 let total_len = file_name.len();
                 let mut text_layout = ctx
@@ -209,10 +207,7 @@ impl LapceEditorHeader {
                 let text_layout = text_layout.build().unwrap();
                 ctx.draw_text(
                     &text_layout,
-                    Point::new(
-                        size.height,
-                        (size.height - text_layout.size().height) / 2.0,
-                    ),
+                    Point::new(size.height, text_layout.y_offset(size.height)),
                 );
             });
         }
@@ -221,12 +216,13 @@ impl LapceEditorHeader {
             for icon in self.icons.iter() {
                 if icon.rect.contains(self.mouse_pos) {
                     ctx.fill(
-                        &icon.rect,
+                        icon.rect,
                         data.config
                             .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
                     );
                 }
-                if let Some(svg) = get_svg(icon.icon) {
+                {
+                    let svg = data.config.ui_svg(icon.icon);
                     ctx.draw_svg(
                         &svg,
                         icon.rect.inflate(-self.svg_padding, -self.svg_padding),
@@ -254,10 +250,8 @@ impl Widget<LapceTabData> for LapceEditorHeader {
                 self.mouse_pos = mouse_event.pos;
                 if self.icon_hit_test(mouse_event) {
                     ctx.set_cursor(&druid::Cursor::Pointer);
-                    ctx.request_paint();
                 } else {
                     ctx.clear_cursor();
-                    ctx.request_paint();
                 }
             }
             Event::MouseDown(mouse_event) => {
diff --git a/lapce-ui/src/editor/tab.rs b/lapce-ui/src/editor/tab.rs
index 5dfe47b126..674dc114af 100644
--- a/lapce-ui/src/editor/tab.rs
+++ b/lapce-ui/src/editor/tab.rs
@@ -1,16 +1,16 @@
 use std::{cell::RefCell, rc::Rc, sync::Arc};
 
 use druid::{
-    kurbo::Line, piet::TextLayout, BoxConstraints, Command, Env, Event, EventCtx,
-    LayoutCtx, LifeCycle, LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect,
-    RenderContext, Size, Target, UpdateCtx, Widget, WidgetId, WidgetPod,
+    kurbo::Line, BoxConstraints, Command, Env, Event, EventCtx, LayoutCtx,
+    LifeCycle, LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect, RenderContext, Size,
+    Target, UpdateCtx, Widget, WidgetId, WidgetPod,
 };
 use lapce_core::command::FocusCommand;
 use lapce_data::{
     command::{
         CommandKind, LapceCommand, LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
     },
-    config::LapceTheme,
+    config::{LapceIcons, LapceTheme},
     data::{
         DragContent, EditorTabChild, FocusArea, LapceEditorTabData, LapceTabData,
         SplitContent,
@@ -25,8 +25,6 @@ use crate::editor::{
     tab_header::LapceEditorTabHeader, view::editor_tab_child_widget,
 };
 
-use crate::svg::get_svg;
-
 pub struct LapceEditorTab {
     pub widget_id: WidgetId,
     header: WidgetPod<LapceTabData, LapceEditorTabHeader>,
@@ -50,26 +48,18 @@ impl LapceEditorTab {
         self
     }
 
-    fn clear_child(&mut self, ctx: &mut EventCtx, data: &mut LapceTabData) {
-        self.children.clear();
-        ctx.children_changed();
-
+    fn close_all_children(&mut self, ctx: &mut EventCtx, data: &mut LapceTabData) {
         let editor_tab = data.main_split.editor_tabs.get(&self.widget_id).unwrap();
-        for child in editor_tab.children.iter() {
-            match child {
-                EditorTabChild::Editor(view_id, _, _) => {
-                    data.main_split.editors.remove(view_id);
-                }
-                EditorTabChild::Settings(_, _) => {}
-            }
+        for child in editor_tab.children.iter().rev() {
+            ctx.submit_command(Command::new(
+                LAPCE_COMMAND,
+                LapceCommand {
+                    kind: CommandKind::Focus(FocusCommand::SplitClose),
+                    data: None,
+                },
+                Target::Widget(child.widget_id()),
+            ));
         }
-        ctx.submit_command(Command::new(
-            LAPCE_UI_COMMAND,
-            LapceUICommand::SplitRemove(SplitContent::EditorTab(
-                editor_tab.widget_id,
-            )),
-            Target::Widget(editor_tab.split),
-        ));
     }
 
     pub fn remove_child(
@@ -100,7 +90,7 @@ impl LapceEditorTab {
             editor_tab.children.remove(i)
         } else if editor_tab.active == i {
             if i >= editor_tab.children.len() - 1 {
-                editor_tab.active = i - 1;
+                editor_tab.active -= 1;
             };
             if focus {
                 ctx.submit_command(Command::new(
@@ -126,9 +116,22 @@ impl LapceEditorTab {
         if delete {
             match removed_child {
                 EditorTabChild::Editor(view_id, _, _) => {
-                    data.main_split.editors.remove(&view_id);
+                    if let Some(editor) = data.main_split.editors.remove(&view_id) {
+                        if let BufferContent::Scratch(buffer_id, _) = editor.content
+                        {
+                            let exits_in_other_edits =
+                                data.main_split.editors.iter().any(|(_, e)| {
+                                    e.view_id != editor.view_id
+                                        && e.content == editor.content
+                                });
+                            if !exits_in_other_edits {
+                                data.main_split.scratch_docs.remove(&buffer_id);
+                            }
+                        }
+                    }
                 }
-                EditorTabChild::Settings(_, _) => {}
+                EditorTabChild::Settings { .. } => {}
+                EditorTabChild::Plugin { .. } => {}
             }
         }
     }
@@ -139,7 +142,7 @@ impl LapceEditorTab {
         data: &mut LapceTabData,
         mouse_event: &MouseEvent,
     ) {
-        if let Some((_, drag_content)) = data.drag.clone().as_ref() {
+        if let Some((_, _, drag_content)) = data.drag.clone().as_ref() {
             match drag_content {
                 DragContent::EditorTab(from_id, from_index, child, _) => {
                     let size = ctx.size();
@@ -198,7 +201,7 @@ impl LapceEditorTab {
                                     widget_id: new_editor_tab_id,
                                     split: split_id,
                                     active: 0,
-                                    children: vec![child.clone()],
+                                    children: vec![child.clone()].into(),
                                     layout_rect: Rc::new(RefCell::new(Rect::ZERO)),
                                     content_is_hot: Rc::new(RefCell::new(false)),
                                 };
@@ -283,8 +286,10 @@ impl LapceEditorTab {
                                 ));
                             }
                         }
+                        *Arc::make_mut(&mut data.drag) = None;
                     }
                 }
+                DragContent::Panel(..) => {}
             }
         }
     }
@@ -305,7 +310,6 @@ impl Widget<LapceTabData> for LapceEditorTab {
         match event {
             Event::MouseMove(mouse_event) => {
                 self.mouse_pos = mouse_event.pos;
-                ctx.request_paint();
             }
             Event::MouseUp(mouse_event) => {
                 self.mouse_up(ctx, data, mouse_event);
@@ -314,25 +318,26 @@ impl Widget<LapceTabData> for LapceEditorTab {
                 ctx.set_handled();
                 let cmd = cmd.get_unchecked(LAPCE_COMMAND);
                 if let CommandKind::Focus(FocusCommand::SplitVertical) = cmd.kind {
-                    let editor_tab = data
-                        .main_split
-                        .editor_tabs
-                        .get_mut(&self.widget_id)
-                        .unwrap();
-                    ctx.submit_command(Command::new(
-                        LAPCE_COMMAND,
-                        LapceCommand {
-                            kind: CommandKind::Focus(FocusCommand::SplitVertical),
-                            data: None,
-                        },
-                        Target::Widget(editor_tab.active_child().widget_id()),
-                    ));
+                    data.main_split.tab_split(
+                        ctx,
+                        self.widget_id,
+                        SplitDirection::Vertical,
+                        &data.config,
+                    );
                 }
             }
             Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
                 ctx.set_handled();
                 let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
                 match command {
+                    LapceUICommand::EditorContentChanged => {
+                        self.header
+                            .widget_mut()
+                            .content
+                            .widget_mut()
+                            .child_mut()
+                            .update_dedup_paths(data);
+                    }
                     LapceUICommand::EditorTabAdd(index, content) => {
                         self.children.insert(
                             *index,
@@ -361,7 +366,7 @@ impl Widget<LapceTabData> for LapceEditorTab {
                         return;
                     }
                     LapceUICommand::SplitClose => {
-                        self.clear_child(ctx, data);
+                        self.close_all_children(ctx, data);
                         return;
                     }
                     LapceUICommand::Focus => {
@@ -382,35 +387,86 @@ impl Widget<LapceTabData> for LapceEditorTab {
                         if let Some(tab) =
                             data.main_split.editor_tabs.get(&self.widget_id)
                         {
-                            let active = &tab.children[tab.active];
-                            match active.child_info(data) {
-                                EditorTabChildInfo::Editor(info) => {
-                                    if info.content
-                                        == BufferContent::Local(
-                                            LocalBufferKind::Empty,
-                                        )
-                                    {
-                                        // File has not yet been loaded, most likely.
-                                        return;
-                                    }
+                            if let Some(active) = tab.children.get(tab.active) {
+                                match active.child_info(data) {
+                                    EditorTabChildInfo::Editor(info) => {
+                                        if info.content
+                                            == BufferContent::Local(
+                                                LocalBufferKind::Empty,
+                                            )
+                                        {
+                                            // File has not yet been loaded, most likely.
+                                            return;
+                                        }
 
-                                    ctx.submit_command(Command::new(
-                                        LAPCE_UI_COMMAND,
-                                        LapceUICommand::ActiveFileChanged {
-                                            path: if let BufferContent::File(path) =
-                                                info.content
-                                            {
-                                                Some(path)
-                                            } else {
-                                                None
+                                        ctx.submit_command(Command::new(
+                                            LAPCE_UI_COMMAND,
+                                            LapceUICommand::ActiveFileChanged {
+                                                path: if let BufferContent::File(
+                                                    path,
+                                                ) = info.content
+                                                {
+                                                    Some(path)
+                                                } else {
+                                                    None
+                                                },
                                             },
-                                        },
-                                        Target::Widget(data.file_explorer.widget_id),
-                                    ));
+                                            Target::Widget(
+                                                data.file_explorer.widget_id,
+                                            ),
+                                        ));
+                                    }
+                                    EditorTabChildInfo::Settings => {}
+                                    EditorTabChildInfo::Plugin { .. } => {}
                                 }
-                                EditorTabChildInfo::Settings => {}
+                                return;
                             }
-                            return;
+                        }
+                    }
+                    LapceUICommand::NextEditorTab => {
+                        let editor_tab = data
+                            .main_split
+                            .editor_tabs
+                            .get(&self.widget_id)
+                            .unwrap();
+                        if !editor_tab.children.is_empty() {
+                            let new_index = if editor_tab.active
+                                == editor_tab.children.len() - 1
+                            {
+                                0
+                            } else {
+                                editor_tab.active + 1
+                            };
+
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::Focus,
+                                Target::Widget(
+                                    editor_tab.children[new_index].widget_id(),
+                                ),
+                            ));
+                        }
+                    }
+                    LapceUICommand::PreviousEditorTab => {
+                        let editor_tab = data
+                            .main_split
+                            .editor_tabs
+                            .get(&self.widget_id)
+                            .unwrap();
+                        if !editor_tab.children.is_empty() {
+                            let new_index = if editor_tab.active == 0 {
+                                editor_tab.children.len() - 1
+                            } else {
+                                editor_tab.active - 1
+                            };
+
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::Focus,
+                                Target::Widget(
+                                    editor_tab.children[new_index].widget_id(),
+                                ),
+                            ));
                         }
                     }
                     _ => (),
@@ -418,9 +474,6 @@ impl Widget<LapceTabData> for LapceEditorTab {
             }
             _ => (),
         }
-        if ctx.is_handled() {
-            return;
-        }
         self.header.event(ctx, event, data, env);
         if event.should_propagate_to_hidden() {
             for child in self.children.iter_mut() {
@@ -497,8 +550,7 @@ impl Widget<LapceTabData> for LapceEditorTab {
 
         let tab = data.main_split.editor_tabs.get(&self.widget_id).unwrap();
         self.children[tab.active].paint(ctx, data, env);
-        self.header.paint(ctx, data, env);
-        if ctx.is_hot() && data.drag.is_some() {
+        if ctx.is_hot() && data.is_drag_editor() {
             let width = size.width;
             let header_rect = self.header.layout_rect();
             let header_height = header_rect.height();
@@ -537,16 +589,21 @@ impl Widget<LapceTabData> for LapceEditorTab {
                         .to_rect()
                         .with_origin(Point::new(0.0, header_height))
                 };
-                ctx.fill(
-                    rect,
-                    &data
-                        .config
-                        .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE)
-                        .clone()
-                        .with_alpha(0.8),
-                );
+                ctx.with_save(|ctx| {
+                    ctx.incr_alpha_depth();
+                    ctx.fill(
+                        rect,
+                        data.config.get_color_unchecked(
+                            LapceTheme::EDITOR_DRAG_DROP_BACKGROUND,
+                        ),
+                    );
+                });
             }
         }
+        ctx.with_save(|ctx| {
+            ctx.incr_alpha_depth();
+            self.header.paint(ctx, data, env);
+        });
     }
 }
 
@@ -556,9 +613,9 @@ pub trait TabRectRenderer {
         ctx: &mut PaintCtx,
         data: &LapceTabData,
         widget_id: WidgetId,
-        i: usize,
+        tab_idx: usize,
         size: Size,
-        mouse_pos: Point,
+        mouse_pos: Option<Point>,
     );
 }
 
@@ -568,96 +625,157 @@ impl TabRectRenderer for TabRect {
         ctx: &mut PaintCtx,
         data: &LapceTabData,
         widget_id: WidgetId,
-        i: usize,
+        tab_idx: usize,
         size: Size,
-        mouse_pos: Point,
+        mouse_pos: Option<Point>,
     ) {
-        let font_size = data.config.ui.font_size() as f64;
-        let width = font_size;
-        let height = font_size;
+        let svg_size = data.config.ui.icon_size() as f64;
         let padding = 4.0;
         let editor_tab = data.main_split.editor_tabs.get(&widget_id).unwrap();
 
-        let rect = Size::new(width, height).to_rect().with_origin(Point::new(
-            self.rect.x0 + (size.height - width) / 2.0,
-            (size.height - height) / 2.0,
-        ));
-        if i == editor_tab.active {
-            let color = if data.focus_area == FocusArea::Editor
-                && Some(widget_id) == *data.main_split.active_tab
-            {
-                data.config.get_color_unchecked(LapceTheme::EDITOR_CARET)
-            } else {
-                data.config.get_color_unchecked(LapceTheme::EDITOR_DIM)
-            };
+        // Draw tab separator before first tab
+        if tab_idx == 0 {
+            draw_tab_separator(ctx, data, self.rect.x0, size.height);
+        }
+
+        // Shrink our tab rect and move origin point by 1px so tab separator isn't drawn on the tab
+        let self_rect = Size::new(self.rect.width() - 1., self.rect.height())
+            .to_rect()
+            .with_origin(Point::new(self.rect.x0 + 1., self.rect.y0));
+
+        // Draw tab separator to the right of our tab rect
+        draw_tab_separator(ctx, data, self_rect.x1, size.height);
+
+        let svg_rect =
+            Size::new(svg_size, svg_size)
+                .to_rect()
+                .with_origin(Point::new(
+                    self_rect.x0 + (svg_size) / 2.0,
+                    self_rect.y0 + (size.height - svg_size) / 2.0,
+                ));
+
+        let is_active_tab = tab_idx == editor_tab.active;
+
+        // Fill tab, simple
+        ctx.fill(self_rect, get_tab_background_color(data, is_active_tab));
+        // Stroke active tabs (active = selected but not necessarily focused)
+        // e.g. a tab might be active in separate pane that is currently not focused
+        if is_active_tab {
+            let stroke = get_tab_stroke_color(data, widget_id);
             ctx.stroke(
                 Line::new(
-                    Point::new(self.rect.x0 + 2.0, self.rect.y1 - 1.0),
-                    Point::new(self.rect.x1 - 2.0, self.rect.y1 - 1.0),
+                    // p0 must be +(n+1) and p1 must be -(n) to have same offset
+                    // don't ask me why
+                    Point::new(self_rect.x0 + 3.0, self_rect.y1 - 2.0),
+                    Point::new(self_rect.x1 - 2.0, self_rect.y1 - 2.0),
                 ),
-                color,
+                stroke,
                 2.0,
             );
         }
-        ctx.draw_svg(&self.svg, rect, None);
-        let text_size = self.text_layout.size();
+        ctx.draw_svg(&self.svg, svg_rect, self.svg_color.as_ref());
         ctx.draw_text(
             &self.text_layout,
-            Point::new(rect.x1 + 5.0, (size.height - text_size.height) / 2.0),
-        );
-        let x = self.rect.x1;
-        ctx.stroke(
-            Line::new(
-                Point::new(x - 0.5, (size.height * 0.8).round()),
-                Point::new(x - 0.5, size.height - (size.height * 0.8).round()),
-            ),
-            data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
-            1.0,
+            Point::new(svg_rect.x1 + 5.0, self.text_layout.y_offset(size.height)),
         );
+        if let Some(path_layout) = &self.path_layout {
+            ctx.draw_text(
+                path_layout,
+                Point::new(
+                    svg_rect.x1 + 5.0 + self.text_layout.layout.width() as f64 + 5.0,
+                    path_layout.y_offset(size.height),
+                ),
+            );
+        }
 
-        if ctx.is_hot() {
-            if self.close_rect.contains(mouse_pos) {
-                ctx.fill(
-                    &self.close_rect,
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
-                );
-            }
-            if self.rect.contains(mouse_pos) {
-                let svg = get_svg("close.svg").unwrap();
-                ctx.draw_svg(
-                    &svg,
-                    self.close_rect.inflate(-padding, -padding),
-                    Some(
-                        data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
-                    ),
-                );
-            }
+        // See if any of the children have unsaved changes
+        let is_pristine = match &editor_tab.children[tab_idx] {
+            EditorTabChild::Editor(editor_id, _, _) => data
+                .main_split
+                .editor_doc(*editor_id)
+                .buffer()
+                .is_pristine(),
+            EditorTabChild::Settings { .. } => true,
+            EditorTabChild::Plugin { .. } => true,
+        };
+
+        if mouse_pos
+            .map(|s| self.close_rect.contains(s))
+            .unwrap_or(false)
+        {
+            ctx.fill(
+                self.close_rect,
+                &data
+                    .config
+                    .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                    .clone()
+                    .with_alpha(0.1),
+            );
         }
 
-        // Only display dirty icon if focus is not on tab bar, so that the close svg can be shown
-        if !(ctx.is_hot() && self.rect.contains(mouse_pos)) {
-            // See if any of the children are dirty
-            let is_pristine = match &editor_tab.children[i] {
-                EditorTabChild::Editor(editor_id, _, _) => {
-                    let doc = data.main_split.editor_doc(*editor_id);
-                    doc.buffer().is_pristine()
-                }
-                EditorTabChild::Settings(_, _) => true,
-            };
+        let mut draw_icon = |name: &'static str| {
+            ctx.draw_svg(
+                &data.config.ui_svg(name),
+                self.close_rect.inflate(-padding, -padding),
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+                ),
+            );
+        };
 
-            if !is_pristine {
-                let svg = get_svg("unsaved.svg").unwrap();
-                ctx.draw_svg(
-                    &svg,
-                    self.close_rect.inflate(-padding, -padding),
-                    Some(
-                        data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
-                    ),
-                )
+        if mouse_pos.map(|s| self.rect.contains(s)).unwrap_or(false) {
+            draw_icon(LapceIcons::CLOSE)
+        } else if !is_pristine {
+            draw_icon(LapceIcons::UNSAVED)
+        } else if is_active_tab {
+            if is_pristine {
+                draw_icon(LapceIcons::CLOSE)
+            } else {
+                draw_icon(LapceIcons::UNSAVED)
             }
         }
     }
 }
+
+#[inline]
+fn get_tab_background_color(data: &LapceTabData, active_tab: bool) -> &druid::Color {
+    if active_tab {
+        data.config
+            .get_color_unchecked(LapceTheme::LAPCE_TAB_ACTIVE_BACKGROUND)
+    } else {
+        data.config
+            .get_color_unchecked(LapceTheme::LAPCE_TAB_INACTIVE_BACKGROUND)
+    }
+}
+
+#[inline]
+fn get_tab_stroke_color(data: &LapceTabData, widget_id: WidgetId) -> &druid::Color {
+    if data.focus_area == FocusArea::Editor
+        && Some(widget_id) == *data.main_split.active_tab
+    {
+        data.config
+            .get_color_unchecked(LapceTheme::LAPCE_TAB_ACTIVE_UNDERLINE)
+    } else {
+        data.config
+            .get_color_unchecked(LapceTheme::LAPCE_TAB_INACTIVE_UNDERLINE)
+    }
+}
+
+#[inline]
+fn draw_tab_separator(
+    ctx: &mut druid::PaintCtx<'_, '_, '_>,
+    data: &LapceTabData,
+    x: f64,
+    y: f64,
+) {
+    ctx.stroke(
+        Line::new(
+            Point::new(x + 0.5, (y * 0.8).round()),
+            Point::new(x + 0.5, y - (y * 0.8).round()),
+        ),
+        data.config
+            .get_color_unchecked(LapceTheme::LAPCE_TAB_SEPARATOR),
+        1.0,
+    );
+}
diff --git a/lapce-ui/src/editor/tab_header.rs b/lapce-ui/src/editor/tab_header.rs
index ff10f89aac..9b0119cc39 100644
--- a/lapce-ui/src/editor/tab_header.rs
+++ b/lapce-ui/src/editor/tab_header.rs
@@ -2,26 +2,23 @@ use std::time::Duration;
 
 use druid::{
     kurbo::Line,
-    piet::{Text, TextAttribute, TextLayout, TextLayoutBuilder},
+    piet::{Text, TextAttribute, TextLayoutBuilder},
     BoxConstraints, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
-    LifeCycleCtx, MouseEvent, PaintCtx, Point, RenderContext, Size, Target,
+    LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect, RenderContext, Size, Target,
     TimerToken, UpdateCtx, Widget, WidgetId, WidgetPod,
 };
-use lapce_core::command::FocusCommand;
+use lapce_core::{command::FocusCommand, meta};
 use lapce_data::{
     command::{
         CommandKind, LapceCommand, LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
     },
-    config::LapceTheme,
+    config::{LapceIcons, LapceTheme},
     data::{EditorTabChild, LapceTabData},
     document::BufferContent,
-    proxy::VERSION,
 };
 
 use crate::{
-    editor::tab_header_content::LapceEditorTabHeaderContent,
-    scroll::LapceScroll,
-    svg::{file_svg, get_svg},
+    editor::tab_header_content::LapceEditorTabHeaderContent, scroll::LapceScroll,
     tab::LapceIcon,
 };
 
@@ -33,6 +30,7 @@ pub struct LapceEditorTabHeader {
     >,
     icons: Vec<LapceIcon>,
     mouse_pos: Point,
+    hover_rect: Option<Rect>,
     is_hot: bool,
 }
 
@@ -40,6 +38,7 @@ impl LapceEditorTabHeader {
     pub fn new(widget_id: WidgetId) -> Self {
         let content = LapceScroll::new(LapceEditorTabHeaderContent::new(widget_id))
             .horizontal()
+            .hide_bar()
             .vertical_scroll_for_horizontal();
         Self {
             widget_id,
@@ -47,12 +46,14 @@ impl LapceEditorTabHeader {
             icons: Vec::new(),
             mouse_pos: Point::ZERO,
             is_hot: false,
+            hover_rect: None,
         }
     }
 
-    fn icon_hit_test(&self, mouse_event: &MouseEvent) -> bool {
+    fn icon_hit_test(&mut self, mouse_event: &MouseEvent) -> bool {
         for icon in self.icons.iter() {
             if icon.rect.contains(mouse_event.pos) {
+                self.hover_rect = Some(icon.rect);
                 return true;
             }
         }
@@ -92,61 +93,74 @@ impl LapceEditorTabHeader {
         let child = editor_tab.active_child();
         let mut text = "".to_string();
         let mut hint = "".to_string();
-        let mut svg = get_svg("default_file.svg").unwrap();
-        match child {
-            EditorTabChild::Editor(view_id, _, _) => {
-                let editor_buffer = data.editor_view_content(*view_id);
+        let mut svg = data.config.ui_svg(LapceIcons::FILE);
+        let mut svg_color = Some(
+            data.config
+                .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+        );
+        if let Some(child) = child {
+            match child {
+                EditorTabChild::Editor(view_id, _, _) => {
+                    let editor_buffer = data.editor_view_content(*view_id);
 
-                if let BufferContent::File(path) = &editor_buffer.editor.content {
-                    svg = file_svg(path);
-                    if let Some(file_name) = path.file_name() {
-                        if let Some(s) = file_name.to_str() {
-                            text = s.to_string();
+                    if let BufferContent::File(path) = &editor_buffer.editor.content
+                    {
+                        (svg, svg_color) = data.config.file_svg(path);
+                        if let Some(file_name) = path.file_name() {
+                            if let Some(s) = file_name.to_str() {
+                                text = s.to_string();
+                            }
+                        }
+                        let mut path = path.to_path_buf();
+                        if let Some(workspace_path) = data.workspace.path.as_ref() {
+                            path = path
+                                .strip_prefix(workspace_path)
+                                .unwrap_or(&path)
+                                .to_path_buf();
                         }
+                        hint = path
+                            .parent()
+                            .and_then(|s| s.to_str())
+                            .unwrap_or("")
+                            .to_string();
+                    } else if let BufferContent::Scratch(..) =
+                        &editor_buffer.editor.content
+                    {
+                        text = editor_buffer.editor.content.file_name().to_string();
                     }
-                    let mut path = path.to_path_buf();
-                    if let Some(workspace_path) = data.workspace.path.as_ref() {
-                        path = path
-                            .strip_prefix(workspace_path)
-                            .unwrap_or(&path)
-                            .to_path_buf();
+                    if !editor_buffer.doc.buffer().is_pristine() {
+                        text = format!("*{text}");
+                    }
+                    if let Some(_compare) = editor_buffer.editor.compare.as_ref() {
+                        text = format!("{text} (Working tree)");
                     }
-                    hint = path
-                        .parent()
-                        .and_then(|s| s.to_str())
-                        .unwrap_or("")
-                        .to_string();
-                } else if let BufferContent::Scratch(..) =
-                    &editor_buffer.editor.content
-                {
-                    text = editor_buffer.editor.content.file_name().to_string();
                 }
-                if !editor_buffer.doc.buffer().is_pristine() {
-                    text = format!("*{text}");
+                EditorTabChild::Settings { .. } => {
+                    text = "Settings".to_string();
+                    hint = format!("ver. {}", *meta::VERSION);
+                    svg = data.config.ui_svg(LapceIcons::SETTINGS);
                 }
-                if let Some(_compare) = editor_buffer.editor.compare.as_ref() {
-                    text = format!("{text} (Working tree)");
+                EditorTabChild::Plugin { volt_name, .. } => {
+                    text = format!("Plugin: {volt_name}");
+                    svg = data.config.ui_svg(LapceIcons::EXTENSIONS);
                 }
             }
-            EditorTabChild::Settings(_, _) => {
-                text = "Settings".to_string();
-                hint = format!("v{}", VERSION);
-            }
         }
         let font_size = data.config.ui.font_size() as f64;
 
+        let svg_size = data.config.ui.icon_size() as f64;
         let size = ctx.size();
         let svg_rect =
-            Size::new(font_size, font_size)
+            Size::new(svg_size, svg_size)
                 .to_rect()
                 .with_origin(Point::new(
-                    (size.height - font_size) / 2.0,
-                    (size.height - font_size) / 2.0,
+                    (size.height - svg_size) / 2.0,
+                    (size.height - svg_size) / 2.0,
                 ));
-        ctx.draw_svg(&svg, svg_rect, None);
+        ctx.draw_svg(&svg, svg_rect, svg_color);
 
         if !hint.is_empty() {
-            text = format!("{} {}", text, hint);
+            text = format!("{text} {hint}");
         }
         let total_len = text.len();
         let mut text_layout = ctx
@@ -171,10 +185,7 @@ impl LapceEditorTabHeader {
         let text_layout = text_layout.build().unwrap();
         ctx.draw_text(
             &text_layout,
-            Point::new(
-                svg_rect.x1 + 5.0,
-                (size.height - text_layout.size().height) / 2.0,
-            ),
+            Point::new(svg_rect.x1 + 5.0, text_layout.y_offset(size.height)),
         );
     }
 }
@@ -190,12 +201,16 @@ impl Widget<LapceTabData> for LapceEditorTabHeader {
         match event {
             Event::MouseMove(mouse_event) => {
                 self.mouse_pos = mouse_event.pos;
+                let hover_rect = self.hover_rect;
                 if self.icon_hit_test(mouse_event) {
                     ctx.set_cursor(&druid::Cursor::Pointer);
                 } else {
+                    self.hover_rect = None;
                     ctx.clear_cursor();
                 }
-                ctx.request_paint();
+                if hover_rect != self.hover_rect {
+                    ctx.request_paint();
+                }
             }
             Event::MouseDown(mouse_event) => {
                 self.mouse_down(ctx, mouse_event);
@@ -255,36 +270,61 @@ impl Widget<LapceTabData> for LapceEditorTabHeader {
         let header_height = data.config.ui.header_height() as f64;
         let size = Size::new(bc.max().width, data.config.ui.header_height() as f64);
 
-        let editor_tab = data.main_split.editor_tabs.get(&self.widget_id).unwrap();
-        if self.is_hot || *editor_tab.content_is_hot.borrow() {
-            let icon_size = 24.0;
-            let gap = (header_height - icon_size) / 2.0;
-            let x = size.width - ((self.icons.len() + 1) as f64) * (gap + icon_size);
+        let icon_size = 24.0;
+        let gap = (header_height - icon_size) / 2.0;
+        let x = size.width - ((self.icons.len() + 1) as f64) * (gap + icon_size);
+        let icon = LapceIcon {
+            icon: LapceIcons::CLOSE,
+            rect: Size::new(icon_size, icon_size)
+                .to_rect()
+                .with_origin(Point::new(x, gap)),
+            command: Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::SplitClose,
+                Target::Widget(self.widget_id),
+            ),
+        };
+        self.icons.push(icon);
+
+        let x = size.width - ((self.icons.len() + 1) as f64) * (gap + icon_size);
+        let icon = LapceIcon {
+            icon: LapceIcons::SPLIT_HORIZONTAL,
+            rect: Size::new(icon_size, icon_size)
+                .to_rect()
+                .with_origin(Point::new(x + gap, gap)),
+            command: Command::new(
+                LAPCE_COMMAND,
+                LapceCommand {
+                    kind: CommandKind::Focus(FocusCommand::SplitVertical),
+                    data: None,
+                },
+                Target::Widget(self.widget_id),
+            ),
+        };
+        self.icons.push(icon);
+
+        if data.config.editor.show_tab {
             let icon = LapceIcon {
-                icon: "close.svg",
+                icon: LapceIcons::TAB_PREVIOUS,
                 rect: Size::new(icon_size, icon_size)
                     .to_rect()
-                    .with_origin(Point::new(x, gap)),
+                    .with_origin(Point::new(gap, gap)),
                 command: Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::SplitClose,
+                    LapceUICommand::PreviousEditorTab,
                     Target::Widget(self.widget_id),
                 ),
             };
             self.icons.push(icon);
 
-            let x = size.width - ((self.icons.len() + 1) as f64) * (gap + icon_size);
             let icon = LapceIcon {
-                icon: "split-horizontal.svg",
+                icon: LapceIcons::TAB_NEXT,
                 rect: Size::new(icon_size, icon_size)
                     .to_rect()
-                    .with_origin(Point::new(x, gap)),
+                    .with_origin(Point::new(gap + icon_size, gap)),
                 command: Command::new(
-                    LAPCE_COMMAND,
-                    LapceCommand {
-                        kind: CommandKind::Focus(FocusCommand::SplitVertical),
-                        data: None,
-                    },
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::NextEditorTab,
                     Target::Widget(self.widget_id),
                 ),
             };
@@ -294,19 +334,37 @@ impl Widget<LapceTabData> for LapceEditorTabHeader {
         self.content.layout(
             ctx,
             &BoxConstraints::tight(Size::new(
-                size.width - self.icons.len() as f64 * size.height,
+                size.width - self.icons.len() as f64 * (gap + icon_size),
                 size.height,
             )),
             data,
             env,
         );
-        self.content.set_origin(ctx, data, env, Point::ZERO);
+        self.content.set_origin(
+            ctx,
+            data,
+            env,
+            Point::new(
+                if data.config.editor.show_tab {
+                    2.0 * (gap + icon_size)
+                } else {
+                    0.0
+                },
+                0.0,
+            ),
+        );
         size
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
         let size = ctx.size();
         let rect = size.to_rect();
+        ctx.fill(
+            size.to_rect(),
+            data.config
+                .get_color_unchecked(LapceTheme::LAPCE_TAB_INACTIVE_BACKGROUND),
+        );
+
         let shadow_width = data.config.ui.drop_shadow_width() as f64;
         if shadow_width > 0.0 {
             ctx.with_save(|ctx| {
@@ -330,6 +388,43 @@ impl Widget<LapceTabData> for LapceEditorTabHeader {
         }
         if data.config.editor.show_tab {
             self.content.paint(ctx, data, env);
+            let scroll_offset = self.content.widget().offset().x;
+            let content_rect = self.content.layout_rect();
+            let child_size = self.content.widget().child_size();
+            if scroll_offset > 0.0 {
+                ctx.with_save(|ctx| {
+                    ctx.clip(content_rect);
+                    let rect = Rect::new(
+                        content_rect.x0 - 10.0,
+                        content_rect.y0 - 10.0,
+                        content_rect.x0,
+                        content_rect.y1 + 10.0,
+                    );
+                    ctx.blurred_rect(
+                        rect,
+                        4.0,
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                    );
+                });
+            }
+            if scroll_offset < child_size.width - content_rect.width() {
+                ctx.with_save(|ctx| {
+                    ctx.clip(content_rect);
+                    let rect = Rect::new(
+                        content_rect.x1,
+                        content_rect.y0 - 10.0,
+                        content_rect.x1 + 10.0,
+                        content_rect.y1 + 10.0,
+                    );
+                    ctx.blurred_rect(
+                        rect,
+                        4.0,
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                    );
+                });
+            }
         } else {
             self.paint_header(ctx, data);
         }
@@ -338,18 +433,21 @@ impl Widget<LapceTabData> for LapceEditorTabHeader {
         for icon in self.icons.iter() {
             if icon.rect.contains(self.mouse_pos) {
                 ctx.fill(
-                    &icon.rect,
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
+                    icon.rect,
+                    &data.config.get_hover_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+                    ),
                 );
             }
-            if let Some(svg) = get_svg(icon.icon) {
+            {
+                let svg = data.config.ui_svg(icon.icon);
                 ctx.draw_svg(
                     &svg,
                     icon.rect.inflate(-svg_padding, -svg_padding),
                     Some(
                         data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                            .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
                     ),
                 );
             }
diff --git a/lapce-ui/src/editor/tab_header_content.rs b/lapce-ui/src/editor/tab_header_content.rs
index 82e10f6c16..e94ed25353 100644
--- a/lapce-ui/src/editor/tab_header_content.rs
+++ b/lapce-ui/src/editor/tab_header_content.rs
@@ -1,28 +1,37 @@
-use std::{iter::Iterator, sync::Arc};
+use std::{
+    collections::HashSet,
+    iter::Iterator,
+    ops::Sub,
+    path::{Path, PathBuf},
+    str::FromStr,
+    sync::Arc,
+};
 
 use druid::{
     kurbo::Line,
+    menu::MenuEventCtx,
     piet::{Text, TextLayout as TextLayoutTrait, TextLayoutBuilder},
-    BoxConstraints, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
+    BoxConstraints, Command, Env, Event, EventCtx, FontStyle, LayoutCtx, LifeCycle,
     LifeCycleCtx, MouseButton, MouseEvent, PaintCtx, Point, RenderContext, Size,
     Target, UpdateCtx, Widget, WidgetId,
 };
-use lapce_core::command::FocusCommand;
+use im::HashMap;
+use lapce_core::{command::FocusCommand, meta};
 use lapce_data::{
     command::{
         CommandKind, LapceCommand, LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
     },
-    config::LapceTheme,
-    data::{DragContent, EditorTabChild, LapceTabData},
+    config::{LapceIcons, LapceTheme},
+    data::{
+        DragContent, EditorTabChild, LapceData, LapceEditorTabData, LapceTabData,
+    },
+    db::EditorTabChildInfo,
     document::BufferContent,
     editor::TabRect,
-    proxy::VERSION,
 };
+use lapce_rpc::source_control::FileDiff;
 
-use crate::{
-    editor::tab::TabRectRenderer,
-    svg::{file_svg, get_svg},
-};
+use crate::editor::tab::TabRectRenderer;
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum MouseAction {
@@ -34,8 +43,9 @@ enum MouseAction {
 pub struct LapceEditorTabHeaderContent {
     pub widget_id: WidgetId,
     pub rects: Vec<TabRect>,
-    mouse_pos: Point,
+    mouse_pos: Option<Point>,
     mouse_down_target: Option<(MouseAction, usize)>,
+    dedup_paths: HashMap<PathBuf, PathBuf>,
 }
 
 impl LapceEditorTabHeaderContent {
@@ -43,8 +53,9 @@ impl LapceEditorTabHeaderContent {
         Self {
             widget_id,
             rects: Vec::new(),
-            mouse_pos: Point::ZERO,
+            mouse_pos: None,
             mouse_down_target: None,
+            dedup_paths: HashMap::default(),
         }
     }
 
@@ -58,6 +69,9 @@ impl LapceEditorTabHeaderContent {
     }
 
     fn cancel_pending_drag(&mut self, data: &mut LapceTabData) {
+        if data.drag.is_none() {
+            return;
+        }
         *Arc::make_mut(&mut data.drag) = None;
     }
 
@@ -105,7 +119,7 @@ impl LapceEditorTabHeaderContent {
                         Target::Widget(editor_tab.children[tab_idx].widget_id()),
                     ));
                 }
-                self.mouse_pos = mouse_event.pos;
+                self.mouse_pos = Some(mouse_event.pos);
                 self.mouse_down_target = Some((MouseAction::Drag, tab_idx));
 
                 ctx.request_paint();
@@ -113,6 +127,44 @@ impl LapceEditorTabHeaderContent {
                 return;
             }
 
+            if mouse_event.button.is_right() {
+                let file_explorer_id = data.file_explorer.widget_id;
+                let editor_tab =
+                    data.main_split.editor_tabs.get(&self.widget_id).unwrap();
+                let tab_info = editor_tab.children[tab_idx].child_info(data);
+
+                let path = match tab_info {
+                    EditorTabChildInfo::Editor(info) => match info.content {
+                        BufferContent::File(path) => Some(path),
+                        _ => None,
+                    },
+                    _ => None,
+                };
+
+                let is_worksapce_member = data
+                    .workspace
+                    .path
+                    .as_ref()
+                    .and_then(|workspace| {
+                        path.as_deref()
+                            .map(|path| path.starts_with(workspace.as_path()))
+                    })
+                    .unwrap_or(false);
+
+                let menu = LapceEditorTabHeaderContextMenu::new(
+                    tab_idx,
+                    editor_tab,
+                    file_explorer_id,
+                    path,
+                    is_worksapce_member,
+                )
+                .to_menu();
+                ctx.show_context_menu::<LapceData>(
+                    menu,
+                    ctx.to_window(mouse_event.pos),
+                );
+            }
+
             if mouse_event.button.is_middle() {
                 self.mouse_down_target =
                     Some((MouseAction::CloseViaMiddleClick, tab_idx));
@@ -127,13 +179,12 @@ impl LapceEditorTabHeaderContent {
         data: &mut LapceTabData,
         mouse_event: &MouseEvent,
     ) {
-        self.mouse_pos = mouse_event.pos;
+        self.mouse_pos = Some(mouse_event.pos);
         if self.tab_hit_test(mouse_event) {
             ctx.set_cursor(&druid::Cursor::Pointer);
         } else {
             ctx.clear_cursor();
         }
-        ctx.request_paint();
 
         if !mouse_event.buttons.contains(MouseButton::Left) {
             // If drag data exists, mouse was released outside of the view.
@@ -153,17 +204,75 @@ impl LapceEditorTabHeaderContent {
                     mouse_event.pos.to_vec2() - tab_rect.rect.origin().to_vec2();
                 *Arc::make_mut(&mut data.drag) = Some((
                     offset,
+                    mouse_event.window_pos.to_vec2(),
                     DragContent::EditorTab(
                         editor_tab.widget_id,
                         target,
                         editor_tab.children[target].clone(),
-                        tab_rect.clone(),
+                        Box::new(tab_rect.clone()),
                     ),
                 ));
             }
         }
     }
 
+    fn mouse_up(
+        &mut self,
+        ctx: &mut EventCtx,
+        data: &mut LapceTabData,
+        mouse_event: &MouseEvent,
+    ) {
+        let editor_tab = data
+            .main_split
+            .editor_tabs
+            .get_mut(&self.widget_id)
+            .unwrap();
+
+        let mut close_tab = |tab_idx: usize, was_active: bool| {
+            if was_active {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::ActiveFileChanged { path: None },
+                    Target::Widget(data.file_explorer.widget_id),
+                ));
+            }
+
+            ctx.submit_command(Command::new(
+                LAPCE_COMMAND,
+                LapceCommand {
+                    kind: CommandKind::Focus(FocusCommand::SplitClose),
+                    data: None,
+                },
+                Target::Widget(editor_tab.children[tab_idx].widget_id()),
+            ));
+        };
+
+        match self.mouse_down_target.take() {
+            // Was the left button released on the close icon that started the close?
+            Some((MouseAction::CloseViaIcon, target))
+                if self.is_close_icon_hit(target, mouse_event.pos)
+                    && mouse_event.button.is_left() =>
+            {
+                close_tab(target, target == editor_tab.active);
+            }
+
+            // Was the middle button released on the tab that started the close?
+            Some((MouseAction::CloseViaMiddleClick, target))
+                if self.is_tab_hit(target, mouse_event.pos)
+                    && mouse_event.button.is_middle() =>
+            {
+                close_tab(target, target == editor_tab.active);
+            }
+
+            None if mouse_event.button.is_left() => {
+                let mouse_index = self.drag_target_idx(mouse_event.pos);
+                self.handle_drag(mouse_index, ctx, data)
+            }
+
+            _ => {}
+        }
+    }
+
     fn after_last_tab_index(&self) -> usize {
         self.rects.len()
     }
@@ -189,7 +298,7 @@ impl LapceEditorTabHeaderContent {
         ctx: &mut EventCtx,
         data: &mut LapceTabData,
     ) {
-        if let Some((_, DragContent::EditorTab(from_id, from_index, child, _))) =
+        if let Some((_, _, DragContent::EditorTab(from_id, from_index, child, _))) =
             Arc::make_mut(&mut data.drag).take()
         {
             let editor_tab = data
@@ -248,6 +357,41 @@ impl LapceEditorTabHeaderContent {
             ));
         }
     }
+
+    pub fn update_dedup_paths(&mut self, data: &LapceTabData) {
+        let editor_tab = data.main_split.editor_tabs.get(&self.widget_id).unwrap();
+        // Collect all the filenames we currently have
+        let mut dup_filenames: HashMap<&str, Vec<PathBuf>> = HashMap::default();
+        for child in &editor_tab.children {
+            if let EditorTabChild::Editor(view_id, _, _) = child {
+                let editor = data.main_split.editors.get(view_id).unwrap();
+                if let BufferContent::File(path) = &editor.content {
+                    if let Some(file_name) = path.file_name() {
+                        dup_filenames
+                            .entry(file_name.to_str().unwrap())
+                            .and_modify(|v| v.push(path.clone()))
+                            .or_insert(vec![path.clone()]);
+                    }
+                }
+            }
+        }
+
+        // Clear dedup paths so that we dont store closed files
+        // TODO: Can be optimized by listening to close file events?
+        self.dedup_paths.clear();
+
+        // Resolve each group of duplicates and insert into `self.dedup_paths`.
+        for (_, dup_paths) in dup_filenames.iter().filter(|v| v.1.len() > 1) {
+            for (original_path, truncated_path) in
+                dup_paths.iter().zip(get_truncated_path(dup_paths).iter())
+            {
+                self.dedup_paths.insert(
+                    original_path.to_path_buf(),
+                    truncated_path.to_path_buf(),
+                );
+            }
+        }
+    }
 }
 
 impl Widget<LapceTabData> for LapceEditorTabHeaderContent {
@@ -266,55 +410,7 @@ impl Widget<LapceTabData> for LapceEditorTabHeaderContent {
                 self.mouse_down(ctx, data, mouse_event);
             }
             Event::MouseUp(mouse_event) => {
-                let editor_tab = data
-                    .main_split
-                    .editor_tabs
-                    .get_mut(&self.widget_id)
-                    .unwrap();
-
-                let mut close_tab = |tab_idx: usize, was_active: bool| {
-                    if was_active {
-                        ctx.submit_command(Command::new(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::ActiveFileChanged { path: None },
-                            Target::Widget(data.file_explorer.widget_id),
-                        ));
-                    }
-
-                    ctx.submit_command(Command::new(
-                        LAPCE_COMMAND,
-                        LapceCommand {
-                            kind: CommandKind::Focus(FocusCommand::SplitClose),
-                            data: None,
-                        },
-                        Target::Widget(editor_tab.children[tab_idx].widget_id()),
-                    ));
-                };
-
-                match self.mouse_down_target.take() {
-                    // Was the left button released on the close icon that started the close?
-                    Some((MouseAction::CloseViaIcon, target))
-                        if self.is_close_icon_hit(target, mouse_event.pos)
-                            && mouse_event.button.is_left() =>
-                    {
-                        close_tab(target, target == editor_tab.active);
-                    }
-
-                    // Was the middle button released on the tab that started the close?
-                    Some((MouseAction::CloseViaMiddleClick, target))
-                        if self.is_tab_hit(target, mouse_event.pos)
-                            && mouse_event.button.is_middle() =>
-                    {
-                        close_tab(target, target == editor_tab.active);
-                    }
-
-                    None if mouse_event.button.is_left() => {
-                        let mouse_index = self.drag_target_idx(mouse_event.pos);
-                        self.handle_drag(mouse_index, ctx, data)
-                    }
-
-                    _ => {}
-                }
+                self.mouse_up(ctx, data, mouse_event);
             }
             _ => (),
         }
@@ -332,10 +428,20 @@ impl Widget<LapceTabData> for LapceEditorTabHeaderContent {
     fn update(
         &mut self,
         _ctx: &mut UpdateCtx,
-        _old_data: &LapceTabData,
-        _data: &LapceTabData,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
         _env: &Env,
     ) {
+        let editor_tab = data.main_split.editor_tabs.get(&self.widget_id).unwrap();
+        let old_editor_tab = old_data
+            .main_split
+            .editor_tabs
+            .get(&self.widget_id)
+            .unwrap();
+
+        if !editor_tab.children.ptr_eq(&old_editor_tab.children) {
+            self.update_dedup_paths(data);
+        }
     }
 
     fn layout(
@@ -346,30 +452,69 @@ impl Widget<LapceTabData> for LapceEditorTabHeaderContent {
         _env: &Env,
     ) -> Size {
         let editor_tab = data.main_split.editor_tabs.get(&self.widget_id).unwrap();
-        let _child_min_width = 200.0;
         let height = bc.max().height;
 
         self.rects.clear();
         let mut x = 0.0;
-        for (_i, child) in editor_tab.children.iter().enumerate() {
+
+        for child in editor_tab.children.iter() {
             let mut text = "".to_string();
-            let mut svg = get_svg("default_file.svg").unwrap();
+            let mut svg = data.config.ui_svg(LapceIcons::FILE);
+            let mut svg_color = Some(
+                data.config
+                    .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+            );
+            let mut text_color = match editor_tab.active_child() {
+                Some(active_child)
+                    if active_child.widget_id() == child.widget_id() =>
+                {
+                    LapceTheme::LAPCE_TAB_ACTIVE_FOREGROUND
+                }
+                _ => LapceTheme::LAPCE_TAB_INACTIVE_FOREGROUND,
+            };
+            let mut file_path = None;
             match child {
                 EditorTabChild::Editor(view_id, _, _) => {
                     let editor = data.main_split.editors.get(view_id).unwrap();
                     if let BufferContent::File(path) = &editor.content {
-                        svg = file_svg(path);
+                        (svg, svg_color) = data.config.file_svg(path);
+
                         if let Some(file_name) = path.file_name() {
                             if let Some(s) = file_name.to_str() {
                                 text = s.to_string();
+                                if let Some(dedup_path) = self.dedup_paths.get(path)
+                                {
+                                    file_path = Some(
+                                        dedup_path.to_string_lossy().to_string(),
+                                    );
+                                }
                             }
                         }
+                        if let Some(diff) = data.source_control.file_diffs.get(path)
+                        {
+                            text_color = match diff.0 {
+                                FileDiff::Modified(_) | FileDiff::Renamed(_, _) => {
+                                    LapceTheme::SOURCE_CONTROL_MODIFIED
+                                }
+                                FileDiff::Added(_) => {
+                                    LapceTheme::SOURCE_CONTROL_ADDED
+                                }
+                                FileDiff::Deleted(_) => {
+                                    LapceTheme::SOURCE_CONTROL_REMOVED
+                                }
+                            };
+                        }
                     } else if let BufferContent::Scratch(..) = &editor.content {
                         text = editor.content.file_name().to_string();
                     }
                 }
-                EditorTabChild::Settings(_, _) => {
-                    text = format!("Settings v{}", VERSION);
+                EditorTabChild::Settings { .. } => {
+                    text = format!("Settings (ver. {})", *meta::VERSION);
+                    svg = data.config.ui_svg(LapceIcons::SETTINGS);
+                }
+                EditorTabChild::Plugin { volt_name, .. } => {
+                    text = format!("Plugin: {volt_name}");
+                    svg = data.config.ui_svg(LapceIcons::EXTENSIONS);
                 }
             }
             let font_size = data.config.ui.font_size() as f64;
@@ -377,21 +522,33 @@ impl Widget<LapceTabData> for LapceEditorTabHeaderContent {
                 .text()
                 .new_text_layout(text)
                 .font(data.config.ui.font_family(), font_size)
-                .text_color(
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                        .clone(),
-                )
+                .text_color(data.config.get_color_unchecked(text_color).clone())
                 .build()
                 .unwrap();
-            let text_size = text_layout.size();
+            let path_layout = file_path.map(|f| {
+                ctx.text()
+                    .new_text_layout(f)
+                    .default_attribute(FontStyle::Italic)
+                    .font(data.config.ui.font_family(), font_size.sub(2.0).max(1.0))
+                    .text_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                            .clone(),
+                    )
+                    .build()
+                    .unwrap()
+            });
+            let text_size = text_layout.size()
+                + path_layout.as_ref().map(|p| p.size()).unwrap_or(Size::ZERO);
             let width =
                 (text_size.width + height + (height - font_size) / 2.0 + font_size)
-                    .max(data.config.ui.tab_min_width() as f64);
+                    .max(data.config.ui.tab_min_width() as f64)
+                    + 1.; // +1. for tab separator
             let close_size = 24.0;
             let inflate = (height - close_size) / 2.0;
             let tab_rect = TabRect {
                 svg,
+                svg_color: svg_color.cloned(),
                 rect: Size::new(width, height)
                     .to_rect()
                     .with_origin(Point::new(x, 0.0)),
@@ -400,6 +557,7 @@ impl Widget<LapceTabData> for LapceEditorTabHeaderContent {
                     .with_origin(Point::new(x + width - height, 0.0))
                     .inflate(-inflate, -inflate),
                 text_layout,
+                path_layout,
             };
             x += width;
             self.rects.push(tab_rect);
@@ -411,12 +569,19 @@ impl Widget<LapceTabData> for LapceEditorTabHeaderContent {
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
         let size = ctx.size();
 
-        for (i, tab_rect) in self.rects.iter().enumerate() {
-            tab_rect.paint(ctx, data, self.widget_id, i, size, self.mouse_pos);
+        ctx.fill(
+            size.to_rect(),
+            data.config
+                .get_color_unchecked(LapceTheme::LAPCE_TAB_INACTIVE_BACKGROUND),
+        );
+
+        for (tab_idx, tab_rect) in self.rects.iter().enumerate() {
+            tab_rect.paint(ctx, data, self.widget_id, tab_idx, size, self.mouse_pos);
         }
 
-        if ctx.is_hot() && data.drag.is_some() {
-            let mouse_index = self.drag_target_idx(self.mouse_pos);
+        if ctx.is_hot() && data.is_drag_editor() {
+            // SAFETY: unwrap here is safe because `ctx.is_hot` is true if mouse is hovered over it.
+            let mouse_index = self.drag_target_idx(self.mouse_pos.unwrap());
 
             let tab_rect;
             let x = if mouse_index == self.after_last_tab_index() {
@@ -441,3 +606,296 @@ impl Widget<LapceTabData> for LapceEditorTabHeaderContent {
         }
     }
 }
+
+fn get_truncated_path(full_paths: &[PathBuf]) -> Vec<PathBuf> {
+    let mut skip_left = 0;
+    'stop_left: loop {
+        if full_paths
+            .iter()
+            .map(|p| p.iter().nth(skip_left))
+            .collect::<Option<HashSet<_>>>()
+            .map(|h| h.len() == 1)
+            .unwrap_or(false)
+        {
+            skip_left += 1;
+        } else {
+            break 'stop_left;
+        }
+    }
+
+    let mut skip_right = 0;
+    'stop_right: loop {
+        if full_paths
+            .iter()
+            .map(|p| p.iter().rev().nth(skip_right))
+            .collect::<Option<HashSet<_>>>()
+            .map(|h| h.len() == 1)
+            .unwrap_or(false)
+        {
+            skip_right += 1;
+        } else {
+            break 'stop_right;
+        }
+    }
+
+    let skip_left = if skip_left == 1 { 0 } else { skip_left };
+
+    let truncated_paths = full_paths
+        .iter()
+        .map(|p| {
+            let length = p.iter().count();
+            let mut result = p
+                .iter()
+                .skip(skip_left)
+                .take(length.saturating_sub(skip_left).saturating_sub(skip_right))
+                .collect::<PathBuf>();
+
+            if skip_left > 0 {
+                result = PathBuf::from_str("...").unwrap().join(result);
+            }
+
+            if skip_right > 1 {
+                result.push("...")
+            }
+
+            result
+        })
+        .collect::<Vec<_>>();
+
+    truncated_paths
+}
+
+struct LapceEditorTabHeaderContextMenu<'a> {
+    tab_idx: usize,
+    editor_tab: &'a Arc<LapceEditorTabData>,
+    file_explorer_id: WidgetId,
+    tab_path: Option<PathBuf>,
+    is_workspace_member: bool,
+}
+
+impl<'a> LapceEditorTabHeaderContextMenu<'a> {
+    fn new(
+        tab_idx: usize,
+        editor_tab: &'a Arc<LapceEditorTabData>,
+        file_explorer_id: WidgetId,
+        tab_path: Option<PathBuf>,
+        is_workspace_member: bool,
+    ) -> Self {
+        Self {
+            tab_idx,
+            editor_tab,
+            file_explorer_id,
+            tab_path,
+            is_workspace_member,
+        }
+    }
+
+    fn to_menu(&self) -> druid::Menu<LapceData> {
+        let entry_close_tab = druid::MenuItem::new("Close Tab")
+            .on_activate(self.create_close_tab_callback());
+
+        let entry_close_tabs_other = druid::MenuItem::new("Close Other Tabs")
+            .on_activate(self.create_close_all_tabs_callback());
+
+        let entry_close_tabs_left = druid::MenuItem::new("Close Tabs to the Left")
+            .on_activate(self.create_close_tabs_left_callback());
+
+        let entry_close_tabs_right = druid::MenuItem::new("Close Tabs to the Right")
+            .on_activate(self.create_close_tabs_right_callback());
+
+        let entry_reveal_file = self.tab_path.as_deref().map(|path| {
+            druid::MenuItem::new("Reveal in File Tree")
+                .on_activate(self.create_reveal_file_callback(path))
+                .enabled(self.is_workspace_member)
+        });
+
+        let mut menu = druid::Menu::<LapceData>::new("Tab Header")
+            .entry(entry_close_tab)
+            .entry(entry_close_tabs_other)
+            .entry(entry_close_tabs_left)
+            .entry(entry_close_tabs_right)
+            .separator();
+
+        if let Some(entry) = entry_reveal_file {
+            menu = menu.entry(entry);
+        }
+
+        menu
+    }
+
+    fn create_close_tab_callback(
+        &self,
+    ) -> impl FnMut(&mut MenuEventCtx, &mut LapceData, &Env) + 'static {
+        let editor_tab = self.editor_tab.clone();
+        let file_explorer_id = self.file_explorer_id;
+        let tab_idx = self.tab_idx;
+
+        move |ctx, _, _| {
+            if editor_tab.active == tab_idx {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::ActiveFileChanged { path: None },
+                    Target::Widget(file_explorer_id),
+                ));
+            }
+
+            ctx.submit_command(Command::new(
+                LAPCE_COMMAND,
+                LapceCommand {
+                    kind: CommandKind::Focus(FocusCommand::SplitClose),
+                    data: None,
+                },
+                Target::Widget(editor_tab.children[tab_idx].widget_id()),
+            ));
+        }
+    }
+
+    fn create_close_all_tabs_callback(
+        &self,
+    ) -> impl FnMut(&mut MenuEventCtx, &mut LapceData, &Env) + 'static {
+        let editor_tab = self.editor_tab.clone();
+        let tab_idx = self.tab_idx;
+
+        move |ctx, _, _| {
+            editor_tab
+                .children
+                .iter()
+                .enumerate()
+                .rev()
+                .filter_map(
+                    |(idx, tab)| if idx != tab_idx { Some(tab) } else { None },
+                )
+                .for_each(|tab| {
+                    ctx.submit_command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Focus(FocusCommand::SplitClose),
+                            data: None,
+                        },
+                        Target::Widget(tab.widget_id()),
+                    ))
+                })
+        }
+    }
+
+    fn create_close_tabs_left_callback(
+        &self,
+    ) -> impl FnMut(&mut MenuEventCtx, &mut LapceData, &Env) + 'static {
+        let editor_tab = self.editor_tab.clone();
+        let tab_idx = self.tab_idx;
+
+        move |ctx, _, _| {
+            editor_tab
+                .children
+                .iter()
+                .take(tab_idx)
+                .rev()
+                .for_each(|tab| {
+                    ctx.submit_command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Focus(FocusCommand::SplitClose),
+                            data: None,
+                        },
+                        Target::Widget(tab.widget_id()),
+                    ));
+                });
+        }
+    }
+
+    fn create_close_tabs_right_callback(
+        &self,
+    ) -> impl FnMut(&mut MenuEventCtx, &mut LapceData, &Env) + 'static {
+        let editor_tab = self.editor_tab.clone();
+        let tab_idx = self.tab_idx;
+
+        move |ctx, _, _| {
+            editor_tab
+                .children
+                .iter()
+                .skip(tab_idx + 1)
+                .rev()
+                .for_each(|tab| {
+                    ctx.submit_command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Focus(FocusCommand::SplitClose),
+                            data: None,
+                        },
+                        Target::Widget(tab.widget_id()),
+                    ))
+                })
+        }
+    }
+
+    fn create_reveal_file_callback(
+        &self,
+        tab_path: &Path,
+    ) -> impl FnMut(&mut MenuEventCtx, &mut LapceData, &Env) + 'static {
+        let file_explorer_id = self.file_explorer_id;
+        let path = tab_path.to_path_buf();
+
+        move |ctx, _data, _env| {
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::ExplorerRevealPath {
+                    path: path.to_owned(),
+                },
+                Target::Widget(file_explorer_id),
+            ));
+        }
+    }
+}
+
+#[allow(unused_imports)]
+mod test {
+    use std::{path::PathBuf, str::FromStr};
+
+    use druid::WidgetId;
+
+    use crate::editor::tab_header_content::{
+        get_truncated_path, LapceEditorTabHeaderContent,
+    };
+
+    #[test]
+    fn test_all_truncated_paths() {
+        let f1 = PathBuf::from("/home/user/myproject/folder1/file.rs");
+        let f2 = PathBuf::from("/home/user/myproject/folder2/file.rs");
+        let f3 = PathBuf::from("/file.rs");
+        let f4 = PathBuf::from("/home/user/proj/file.rs");
+        let f5 = PathBuf::from("/home/user/toolongprojectshouldtruncate/file.rs");
+        let f6 = PathBuf::from("/home/user/myproject/file.rs");
+
+        let result = get_truncated_path(&[f1, f2, f3, f4, f5, f6]);
+
+        assert_eq!(
+            result[0],
+            PathBuf::from_str("/home/user/myproject/folder1").unwrap()
+        );
+        assert_eq!(
+            result[1],
+            PathBuf::from_str("/home/user/myproject/folder2").unwrap()
+        );
+        assert_eq!(result[2], PathBuf::from_str("/").unwrap());
+        assert_eq!(result[3], PathBuf::from_str("/home/user/proj").unwrap());
+        assert_eq!(
+            result[4],
+            PathBuf::from_str("/home/user/toolongprojectshouldtruncate").unwrap()
+        );
+        assert_eq!(
+            result[5],
+            PathBuf::from_str("/home/user/myproject/").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_almost_same_paths() {
+        let f1 = PathBuf::from("/home/user/myproject/folder1/file.rs");
+        let f2 = PathBuf::from("/home/user/myproject/folder2/file.rs");
+
+        let result = get_truncated_path(&[f1, f2]);
+
+        assert_eq!(result[0], PathBuf::from_str(".../folder1").unwrap());
+        assert_eq!(result[1], PathBuf::from_str(".../folder2").unwrap());
+    }
+}
diff --git a/lapce-ui/src/editor/view.rs b/lapce-ui/src/editor/view.rs
index 00cb786c8f..6d2f2b628e 100644
--- a/lapce-ui/src/editor/view.rs
+++ b/lapce-ui/src/editor/view.rs
@@ -15,24 +15,25 @@ use lapce_core::command::{EditCommand, FocusCommand};
 use lapce_data::{
     command::{
         CommandExecuted, CommandKind, EnsureVisiblePosition, LapceCommand,
-        LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
+        LapceUICommand, LapceWorkbenchCommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
     },
     config::{EditorConfig, LapceTheme},
-    data::{
-        EditorTabChild, EditorView, FocusArea, LapceTabData, PanelData, PanelKind,
-    },
+    data::{EditorTabChild, EditorView, FocusArea, LapceTabData},
     document::{BufferContent, LocalBufferKind},
     editor::LapceEditorBufferData,
     keypress::KeyPressFocus,
-    panel::PanelPosition,
-    settings::SettingsValueKind,
+    palette::PaletteStatus,
+    panel::{PanelData, PanelKind},
 };
 
 use crate::{
+    diff::DiffBox,
     editor::{
         container::LapceEditorContainer, header::LapceEditorHeader, LapceEditor,
     },
     find::FindBox,
+    ime::ImeComponent,
+    plugin::PluginInfo,
     settings::LapceSettingsPanel,
 };
 
@@ -41,8 +42,12 @@ pub struct LapceEditorView {
     pub header: WidgetPod<LapceTabData, LapceEditorHeader>,
     pub editor: WidgetPod<LapceTabData, LapceEditorContainer>,
     pub find: Option<WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>>,
+    pub diff: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
     cursor_blink_timer: TimerToken,
-    last_idle_timer: TimerToken,
+    autosave_timer: TimerToken,
+    display_border: bool,
+    background_color_name: &'static str,
+    ime: ImeComponent,
 }
 
 pub fn editor_tab_child_widget(
@@ -53,9 +58,24 @@ pub fn editor_tab_child_widget(
         EditorTabChild::Editor(view_id, editor_id, find_view_id) => {
             LapceEditorView::new(*view_id, *editor_id, *find_view_id).boxed()
         }
-        EditorTabChild::Settings(widget_id, editor_tab_id) => {
-            LapceSettingsPanel::new(data, *widget_id, *editor_tab_id).boxed()
-        }
+        EditorTabChild::Settings {
+            settings_widget_id,
+            editor_tab_id,
+            keymap_input_view_id,
+        } => LapceSettingsPanel::new(
+            data,
+            *settings_widget_id,
+            *editor_tab_id,
+            *keymap_input_view_id,
+        )
+        .boxed(),
+        EditorTabChild::Plugin {
+            widget_id,
+            editor_tab_id,
+            volt_id,
+            ..
+        } => PluginInfo::new_scroll(*widget_id, *editor_tab_id, volt_id.clone())
+            .boxed(),
     }
 }
 
@@ -71,13 +91,18 @@ impl LapceEditorView {
             WidgetPod::new(FindBox::new(find_view_id, find_editor_id, view_id))
                 .boxed()
         });
+        let diff = WidgetPod::new(DiffBox::new(view_id)).boxed();
         Self {
             view_id,
             header: WidgetPod::new(header),
             editor: WidgetPod::new(editor),
             find,
+            diff,
             cursor_blink_timer: TimerToken::INVALID,
-            last_idle_timer: TimerToken::INVALID,
+            autosave_timer: TimerToken::INVALID,
+            display_border: true,
+            background_color_name: LapceTheme::EDITOR_BACKGROUND,
+            ime: ImeComponent::default(),
         }
     }
 
@@ -91,6 +116,11 @@ impl LapceEditorView {
         self
     }
 
+    pub fn hide_border(mut self) -> Self {
+        self.display_border = false;
+        self
+    }
+
     pub fn set_placeholder(mut self, placeholder: String) -> Self {
         self.editor
             .widget_mut()
@@ -102,6 +132,14 @@ impl LapceEditorView {
         self
     }
 
+    pub fn set_background_color(
+        mut self,
+        background_color_name: &'static str,
+    ) -> Self {
+        self.background_color_name = background_color_name;
+        self
+    }
+
     pub fn request_focus(
         &self,
         ctx: &mut EventCtx,
@@ -111,7 +149,7 @@ impl LapceEditorView {
         if left_click {
             ctx.request_focus();
         }
-        data.focus = self.view_id;
+        data.focus = Arc::new(self.view_id);
         let editor = data.main_split.editors.get(&self.view_id).unwrap().clone();
         if let Some(editor_tab_id) = editor.tab_id {
             let editor_tab =
@@ -139,6 +177,8 @@ impl LapceEditorView {
             BufferContent::Local(kind) => match kind {
                 LocalBufferKind::Keymap => {}
                 LocalBufferKind::Settings => {}
+                LocalBufferKind::PluginSearch => {}
+                LocalBufferKind::BranchesFilter => {}
                 LocalBufferKind::Palette => {
                     data.focus_area = FocusArea::Palette;
                 }
@@ -152,6 +192,10 @@ impl LapceEditorView {
                     data.focus_area = FocusArea::Panel(PanelKind::SourceControl);
                     Arc::make_mut(&mut data.source_control).active = self.view_id;
                 }
+                LocalBufferKind::PathName => {}
+                LocalBufferKind::Rename => {
+                    data.focus_area = FocusArea::Rename;
+                }
                 LocalBufferKind::Empty => {
                     data.focus_area = FocusArea::Editor;
                     data.main_split.active = Arc::new(Some(self.view_id));
@@ -167,30 +211,32 @@ impl LapceEditorView {
         ctx: &mut EventCtx,
         cmd: &LapceUICommand,
         data: &mut LapceEditorBufferData,
-        panels: &im::HashMap<PanelPosition, Arc<PanelData>>,
+        panel: &PanelData,
         env: &Env,
     ) {
         match cmd {
-            LapceUICommand::RunCodeAction(action) => {
-                data.run_code_action(action);
+            LapceUICommand::RunCodeAction(action, plugin_id) => {
+                data.run_code_action(ctx, action, plugin_id);
+            }
+            LapceUICommand::ApplyWorkspaceEdit(edit) => {
+                data.apply_workspace_edit(ctx, edit);
             }
             LapceUICommand::EnsureCursorVisible(position) => {
-                self.ensure_cursor_visible(
-                    ctx,
-                    data,
-                    panels,
-                    position.as_ref(),
-                    env,
-                );
+                self.ensure_cursor_visible(ctx, data, panel, position.as_ref(), env);
             }
             LapceUICommand::EnsureCursorPosition(position) => {
-                self.ensure_cursor_position(ctx, data, panels, position, env);
+                self.ensure_cursor_position(ctx, data, panel, position, env);
             }
             LapceUICommand::EnsureRectVisible(rect) => {
                 self.ensure_rect_visible(ctx, data, *rect, env);
             }
-            LapceUICommand::ResolveCompletion(buffer_id, rev, offset, item) => {
-                if data.doc.id() != *buffer_id {
+            LapceUICommand::ResolveCompletion {
+                id,
+                rev,
+                offset,
+                item,
+            } => {
+                if data.doc.id() != *id {
                     return;
                 }
                 if data.doc.rev() != *rev {
@@ -213,7 +259,7 @@ impl LapceEditorView {
                         .scroll_by(Vec2::new(
                             0.0,
                             (new_line as f64 - line as f64)
-                                * data.config.editor.line_height as f64,
+                                * data.config.editor.line_height() as f64,
                         ));
                 }
             }
@@ -266,10 +312,15 @@ impl LapceEditorView {
                     Target::Widget(self.editor.widget().scroll_id),
                 ));
             }
+            LapceUICommand::FocusLost => {
+                data.cancel_completion();
+                data.cancel_signature();
+            }
             _ => (),
         }
     }
 
+    /// Scroll the editor such that the rect is visible.
     fn ensure_rect_visible(
         &mut self,
         ctx: &mut EventCtx,
@@ -303,7 +354,7 @@ impl LapceEditorView {
     ) -> Rect {
         // TODO: scroll margin (in number of lines) should be configurable.
         const MARGIN_LINES: usize = 1;
-        let line_height = editor_config.line_height;
+        let line_height = editor_config.line_height();
 
         // The origin of a rect is its top-left corner.  Inflating a point
         // creates a rect that centers at the point.
@@ -355,7 +406,7 @@ impl LapceEditorView {
         &mut self,
         ctx: &mut EventCtx,
         data: &LapceEditorBufferData,
-        panels: &im::HashMap<PanelPosition, Arc<PanelData>>,
+        panel: &PanelData,
         position: &EnsureVisiblePosition,
         env: &Env,
     ) {
@@ -371,7 +422,7 @@ impl LapceEditorView {
             &data.config.editor,
         );
 
-        let size = LapceEditor::get_size(data, ctx.text(), editor_size, panels, env);
+        let size = LapceEditor::get_size(data, ctx.text(), editor_size, panel, env);
         let scroll = self.editor.widget_mut().editor.widget_mut().inner_mut();
         scroll.set_child_size(size);
         if scroll.scroll_to_visible(rect, env) {
@@ -387,15 +438,18 @@ impl LapceEditorView {
         &mut self,
         ctx: &mut EventCtx,
         data: &LapceEditorBufferData,
-        panels: &im::HashMap<PanelPosition, Arc<PanelData>>,
+        panel: &PanelData,
         position: Option<&EnsureVisiblePosition>,
         env: &Env,
     ) {
-        let line_height = data.config.editor.line_height as f64;
+        let line_height = data.config.editor.line_height() as f64;
         let editor_size = *data.editor.size.borrow();
-        let size = LapceEditor::get_size(data, ctx.text(), editor_size, panels, env);
+        let size = LapceEditor::get_size(data, ctx.text(), editor_size, panel, env);
 
+        let sticky_header_height = data.editor.sticky_header.borrow().height;
         let rect = Self::cursor_region(data, ctx.text());
+        let rect =
+            Rect::new(rect.x0, rect.y0 - sticky_header_height, rect.x1, rect.y1);
         let scroll_id = self.editor.widget().scroll_id;
         let scroll = self.editor.widget_mut().editor.widget_mut().inner_mut();
         scroll.set_child_size(size);
@@ -407,7 +461,7 @@ impl LapceEditorView {
                 Target::Widget(scroll_id),
             ));
             if let Some(position) = position {
-                self.ensure_cursor_position(ctx, data, panels, position, env);
+                self.ensure_cursor_position(ctx, data, panel, position, env);
             } else {
                 let scroll_offset = scroll.offset();
                 if (scroll_offset.y - old_scroll_offset.y).abs() > line_height * 2.0
@@ -415,7 +469,7 @@ impl LapceEditorView {
                     self.ensure_cursor_position(
                         ctx,
                         data,
-                        panels,
+                        panel,
                         &EnsureVisiblePosition::CenterOfWindow,
                         env,
                     );
@@ -427,10 +481,13 @@ impl LapceEditorView {
     fn cursor_region(data: &LapceEditorBufferData, text: &mut PietText) -> Rect {
         let offset = data.editor.cursor.offset();
         let (line, col) = data.doc.buffer().offset_to_line_col(offset);
+        let inlay_hints = data.doc.line_phantom_text(&data.config, line);
+        let col = inlay_hints.col_after(col, false);
+
         let width = data.config.editor_char_width(text);
         let cursor_x = data
             .doc
-            .point_of_line_col(
+            .line_point_of_line_col(
                 text,
                 line,
                 col,
@@ -438,9 +495,9 @@ impl LapceEditorView {
                 &data.config,
             )
             .x;
-        let line_height = data.config.editor.line_height as f64;
+        let line_height = data.config.editor.line_height() as f64;
 
-        let y = if data.editor.code_lens {
+        let y = if data.editor.is_code_lens() {
             let empty_vec = Vec::new();
             let normal_lines = data
                 .doc
@@ -485,10 +542,14 @@ impl LapceEditorView {
             line as f64 * line_height
         };
 
+        let surrounding_lines_height =
+            (data.config.editor.cursor_surrounding_lines as f64 * line_height)
+                .min(data.editor.size.borrow().height / 2.);
+
         Rect::ZERO
             .with_size(Size::new(width, line_height))
             .with_origin(Point::new(cursor_x, y))
-            .inflate(width, line_height)
+            .inflate(width, surrounding_lines_height)
     }
 }
 
@@ -509,10 +570,19 @@ impl Widget<LapceTabData> for LapceEditorView {
                 Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {}
                 Event::Command(cmd) if cmd.is(LAPCE_COMMAND) => {}
                 _ => {
-                    find.event(ctx, event, data, env);
+                    if event.should_propagate_to_hidden() || data.find.visual {
+                        find.event(ctx, event, data, env);
+                    }
                 }
             }
         }
+        match event {
+            Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {}
+            Event::Command(cmd) if cmd.is(LAPCE_COMMAND) => {}
+            _ => {
+                self.diff.event(ctx, event, data, env);
+            }
+        }
 
         if ctx.is_handled() {
             return;
@@ -531,12 +601,21 @@ impl Widget<LapceTabData> for LapceEditorView {
             Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
                 let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
                 if let LapceUICommand::Focus = command {
-                    self.request_focus(ctx, data, true);
                     let editor_data = data.editor_view_content(self.view_id);
+                    if data.config.editor.blink_interval > 0 {
+                        self.cursor_blink_timer = ctx.request_timer(
+                            Duration::from_millis(data.config.editor.blink_interval),
+                            None,
+                        );
+                        *editor_data.editor.last_cursor_instant.borrow_mut() =
+                            Instant::now();
+                        ctx.request_paint();
+                    }
+                    self.request_focus(ctx, data, true);
                     self.ensure_cursor_visible(
                         ctx,
                         &editor_data,
-                        &data.panels,
+                        &data.panel,
                         None,
                         env,
                     );
@@ -544,40 +623,58 @@ impl Widget<LapceTabData> for LapceEditorView {
             }
             Event::Timer(id) if self.cursor_blink_timer == *id => {
                 ctx.set_handled();
-                if data.focus == self.view_id {
-                    ctx.request_paint();
-                    self.cursor_blink_timer =
-                        ctx.request_timer(Duration::from_millis(500), None);
-                } else {
-                    self.cursor_blink_timer = TimerToken::INVALID;
+                if data.config.editor.blink_interval > 0 {
+                    if ctx.is_focused() {
+                        ctx.request_paint();
+                        self.cursor_blink_timer = ctx.request_timer(
+                            Duration::from_millis(data.config.editor.blink_interval),
+                            None,
+                        );
+                    } else {
+                        self.cursor_blink_timer = TimerToken::INVALID;
+                    }
                 }
             }
-            Event::Timer(id) if self.last_idle_timer == *id => {
+            Event::Timer(id) if self.autosave_timer == *id => {
                 ctx.set_handled();
-                let editor_data = data.editor_view_content(self.view_id);
-                if let BufferContent::SettingsValue(_, kind, parent, key) =
-                    &editor_data.editor.content
+                if let Some(editor) = data
+                    .main_split
+                    .active
+                    .and_then(|active| data.main_split.editors.get(&active))
+                    .cloned()
                 {
-                    let content = editor_data.doc.buffer().text().to_string();
-                    let new_value = match kind {
-                        SettingsValueKind::String => {
-                            Some(serde_json::json!(content))
-                        }
-                        SettingsValueKind::Number => {
-                            content.parse::<i64>().ok().map(|n| serde_json::json!(n))
+                    // If autosave is enabled, and the content is a file that we can save,
+                    if data.config.editor.autosave_interval > 0
+                        && editor.content.is_file()
+                    {
+                        if ctx.is_focused() {
+                            let doc = data.main_split.editor_doc(self.view_id);
+                            if !doc.buffer().is_pristine() {
+                                let save_cmd =
+                                    if data.config.editor.format_on_autosave {
+                                        FocusCommand::Save
+                                    } else {
+                                        FocusCommand::SaveWithoutFormatting
+                                    };
+
+                                ctx.submit_command(Command::new(
+                                    LAPCE_COMMAND,
+                                    LapceCommand {
+                                        kind: CommandKind::Focus(save_cmd),
+                                        data: None,
+                                    },
+                                    Target::Widget(editor.view_id),
+                                ));
+                            }
+                            self.autosave_timer = ctx.request_timer(
+                                Duration::from_millis(
+                                    data.config.editor.autosave_interval,
+                                ),
+                                None,
+                            );
+                        } else {
+                            self.cursor_blink_timer = TimerToken::INVALID;
                         }
-                        SettingsValueKind::Bool => None,
-                    };
-                    if let Some(new_value) = new_value {
-                        ctx.submit_command(Command::new(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::UpdateSettingsFile(
-                                parent.to_string(),
-                                key.to_string(),
-                                new_value,
-                            ),
-                            Target::Widget(data.id),
-                        ));
                     }
                 }
             }
@@ -590,28 +687,52 @@ impl Widget<LapceTabData> for LapceEditorView {
         match event {
             Event::KeyDown(key_event) => {
                 ctx.set_handled();
-                let mut keypress = data.keypress.clone();
-                if Arc::make_mut(&mut keypress).key_down(
-                    ctx,
-                    key_event,
-                    &mut editor_data,
-                    env,
-                ) {
-                    self.ensure_cursor_visible(
+                if key_event.is_composing {
+                    if data.config.editor.blink_interval > 0 {
+                        self.cursor_blink_timer = ctx.request_timer(
+                            Duration::from_millis(data.config.editor.blink_interval),
+                            None,
+                        );
+                        *editor_data.editor.last_cursor_instant.borrow_mut() =
+                            Instant::now();
+                    }
+                    if let Some(text) = self.ime.get_input_text() {
+                        Arc::make_mut(&mut editor_data.doc).clear_ime_text();
+                        editor_data.receive_char(ctx, &text);
+                    } else if !self.ime.borrow().text().is_empty() {
+                        let offset = editor_data.editor.cursor.offset();
+                        let (line, col) =
+                            editor_data.doc.buffer().offset_to_line_col(offset);
+                        let doc = Arc::make_mut(&mut editor_data.doc);
+                        doc.set_ime_pos(line, col, self.ime.get_shift());
+                        doc.set_ime_text(self.ime.borrow().text());
+                    } else {
+                        Arc::make_mut(&mut editor_data.doc).clear_ime_text();
+                    }
+                } else {
+                    Arc::make_mut(&mut editor_data.doc).clear_ime_text();
+                    let mut keypress = data.keypress.clone();
+                    if Arc::make_mut(&mut keypress).key_down(
                         ctx,
-                        &editor_data,
-                        &data.panels,
-                        None,
+                        key_event,
+                        &mut editor_data,
                         env,
+                    ) {
+                        self.ensure_cursor_visible(
+                            ctx,
+                            &editor_data,
+                            &data.panel,
+                            None,
+                            env,
+                        );
+                    }
+                    editor_data.sync_buffer_position(
+                        self.editor.widget().editor.widget().inner().offset(),
                     );
-                }
-                editor_data.sync_buffer_position(
-                    self.editor.widget().editor.widget().inner().offset(),
-                );
-                editor_data.get_code_actions(ctx);
+                    editor_data.get_code_actions(ctx);
 
-                data.keypress = keypress.clone();
-                ctx.set_handled();
+                    data.keypress = keypress.clone();
+                }
             }
             Event::Command(cmd) if cmd.is(LAPCE_COMMAND) => {
                 let command = cmd.get_unchecked(LAPCE_COMMAND);
@@ -625,13 +746,17 @@ impl Widget<LapceTabData> for LapceEditorView {
                 {
                     ctx.set_handled();
                 }
-                self.ensure_cursor_visible(
-                    ctx,
-                    &editor_data,
-                    &data.panels,
-                    None,
-                    env,
-                );
+
+                // We don't want to send this on `FocusCommand::Save`, especially when autosave is enabled.
+                if command.kind != CommandKind::Focus(FocusCommand::Save) {
+                    self.ensure_cursor_visible(
+                        ctx,
+                        &editor_data,
+                        &data.panel,
+                        None,
+                        env,
+                    );
+                }
             }
             Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
                 let cmd = cmd.get_unchecked(LAPCE_UI_COMMAND);
@@ -639,7 +764,7 @@ impl Widget<LapceTabData> for LapceEditorView {
                     ctx,
                     cmd,
                     &mut editor_data,
-                    &data.panels,
+                    &data.panel,
                     env,
                 );
             }
@@ -667,7 +792,7 @@ impl Widget<LapceTabData> for LapceEditorView {
         if let Some(find) = self.find.as_mut() {
             find.lifecycle(ctx, event, data, env);
         }
-
+        self.diff.lifecycle(ctx, event, data, env);
         match event {
             LifeCycle::WidgetAdded => {
                 let editor = data.main_split.editors.get(&self.view_id).unwrap();
@@ -681,21 +806,91 @@ impl Widget<LapceTabData> for LapceEditorView {
                         Target::Widget(editor.view_id),
                     ));
                 }
+                ctx.register_text_input(self.ime.ime_handler());
+                let editor = data.main_split.editors.get(&self.view_id).unwrap();
+                if editor.cursor.is_insert() {
+                    self.ime.set_active(true);
+                } else {
+                    self.ime.set_active(false);
+                }
             }
             LifeCycle::FocusChanged(is_focus) => {
                 let editor = data.main_split.editors.get(&self.view_id).unwrap();
-                if !*is_focus
-                    && editor.content
-                        == BufferContent::Local(LocalBufferKind::Palette)
-                {
-                    ctx.submit_command(Command::new(
-                        LAPCE_COMMAND,
-                        LapceCommand {
-                            kind: CommandKind::Focus(FocusCommand::ModalClose),
-                            data: None,
-                        },
-                        Target::Widget(data.palette.widget_id),
-                    ));
+                if !*is_focus {
+                    match editor.content {
+                        BufferContent::Local(LocalBufferKind::Palette) => {
+                            ctx.submit_command(Command::new(
+                                LAPCE_COMMAND,
+                                LapceCommand {
+                                    kind: CommandKind::Focus(
+                                        FocusCommand::ModalClose,
+                                    ),
+                                    data: None,
+                                },
+                                Target::Widget(data.palette.widget_id),
+                            ));
+                        }
+                        BufferContent::Local(LocalBufferKind::Rename) => {
+                            ctx.submit_command(Command::new(
+                                LAPCE_COMMAND,
+                                LapceCommand {
+                                    kind: CommandKind::Focus(
+                                        FocusCommand::ModalClose,
+                                    ),
+                                    data: None,
+                                },
+                                Target::Widget(data.rename.view_id),
+                            ));
+                        }
+                        BufferContent::Local(LocalBufferKind::PathName) => {
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::ExplorerEndNaming {
+                                    apply_naming: true,
+                                },
+                                Target::Auto,
+                            ));
+                        }
+                        BufferContent::File(_) => {
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::FocusLost,
+                                Target::Widget(self.view_id),
+                            ));
+                        }
+                        _ => {}
+                    }
+                } else {
+                    let editor_data = data.editor_view_content(self.view_id);
+                    let offset = editor_data.editor.cursor.offset();
+                    let (_, origin) = editor_data.doc.points_of_offset(
+                        ctx.text(),
+                        offset,
+                        &editor_data.editor.view,
+                        &editor_data.config,
+                    );
+                    self.ime.set_origin(
+                        *editor_data.editor.window_origin.borrow()
+                            + (origin.x, origin.y),
+                    );
+
+                    if editor.content.is_palette()
+                        && data.palette.status == PaletteStatus::Inactive
+                    {
+                        let cmd = if data.workspace.path.is_none() {
+                            LapceWorkbenchCommand::PaletteWorkspace
+                        } else {
+                            LapceWorkbenchCommand::Palette
+                        };
+                        ctx.submit_command(Command::new(
+                            LAPCE_COMMAND,
+                            LapceCommand {
+                                kind: CommandKind::Workbench(cmd),
+                                data: None,
+                            },
+                            Target::Auto,
+                        ));
+                    }
                 }
             }
             LifeCycle::HotChanged(is_hot) => {
@@ -724,48 +919,50 @@ impl Widget<LapceTabData> for LapceEditorView {
         if let Some(find) = self.find.as_mut() {
             find.update(ctx, data, env);
         }
-
+        self.diff.update(ctx, data, env);
         let old_editor_data = old_data.editor_view_content(self.view_id);
         let editor_data = data.editor_view_content(self.view_id);
 
-        if let BufferContent::SettingsValue(..) = &editor_data.editor.content {
-            if !editor_data.doc.buffer().is_pristine()
-                && (editor_data.doc.buffer().len()
-                    != old_editor_data.doc.buffer().len()
-                    || editor_data.doc.buffer().text().slice_to_cow(..)
-                        != old_editor_data.doc.buffer().text().slice_to_cow(..))
-            {
-                self.last_idle_timer =
-                    ctx.request_timer(Duration::from_millis(500), None);
-            }
-        }
+        let offset = editor_data.editor.cursor.offset();
+        let old_offset = old_editor_data.editor.cursor.offset();
 
-        if data.focus == self.view_id {
-            let reset = if old_data.focus != self.view_id {
+        if data.config.editor.blink_interval > 0 && *data.focus == self.view_id {
+            let reset = if *old_data.focus != self.view_id {
                 true
             } else {
-                let offset = editor_data.editor.cursor.offset();
-                let old_offset = old_editor_data.editor.cursor.offset();
+                let mode = editor_data.editor.cursor.get_mode();
+                let old_mode = old_editor_data.editor.cursor.get_mode();
                 let (line, col) =
                     editor_data.doc.buffer().offset_to_line_col(offset);
                 let (old_line, old_col) =
                     old_editor_data.doc.buffer().offset_to_line_col(old_offset);
-                line != old_line || col != old_col
+                mode != old_mode || line != old_line || col != old_col
             };
 
             if reset {
-                self.cursor_blink_timer =
-                    ctx.request_timer(Duration::from_millis(500), None);
+                self.cursor_blink_timer = ctx.request_timer(
+                    Duration::from_millis(data.config.editor.blink_interval),
+                    None,
+                );
                 *editor_data.editor.last_cursor_instant.borrow_mut() =
                     Instant::now();
                 ctx.request_paint();
             }
         }
 
-        if old_data.config.lapce.modal != data.config.lapce.modal
+        if data.config.editor.autosave_interval > 0
+            && editor_data.doc.rev() != old_editor_data.doc.rev()
+        {
+            self.autosave_timer = ctx.request_timer(
+                Duration::from_millis(data.config.editor.autosave_interval),
+                None,
+            );
+        }
+
+        if old_data.config.core.modal != data.config.core.modal
             && !editor_data.doc.content().is_input()
         {
-            if !data.config.lapce.modal {
+            if !data.config.core.modal {
                 ctx.submit_command(Command::new(
                     LAPCE_COMMAND,
                     LapceCommand {
@@ -787,23 +984,21 @@ impl Widget<LapceTabData> for LapceEditorView {
         }
 
         if let Some(syntax) = editor_data.doc.syntax() {
-            if syntax.line_height != data.config.editor.line_height
+            if syntax.line_height != data.config.editor.line_height()
                 || syntax.lens_height != data.config.editor.code_lens_font_size
             {
                 let content = editor_data.doc.content().clone();
                 let tab_id = data.id;
                 let event_sink = ctx.get_external_handle();
                 let mut syntax = syntax.clone();
-                let line_height = data.config.editor.line_height;
+                let line_height = data.config.editor.line_height();
                 let lens_height = data.config.editor.code_lens_font_size;
-                let rev = editor_data.doc.rev();
                 rayon::spawn(move || {
                     syntax.update_lens_height(line_height, lens_height);
                     let _ = event_sink.submit_command(
                         LAPCE_UI_COMMAND,
                         LapceUICommand::UpdateSyntax {
                             content,
-                            rev,
                             syntax: SingleUse::new(syntax),
                         },
                         Target::Widget(tab_id),
@@ -812,13 +1007,51 @@ impl Widget<LapceTabData> for LapceEditorView {
             }
         }
 
-        if editor_data.editor.content != old_editor_data.editor.content {
-            ctx.request_layout();
+        let mut update_ime_origin = false;
+        match (
+            old_editor_data.editor.cursor.is_insert(),
+            editor_data.editor.cursor.is_insert(),
+        ) {
+            (true, false) => {
+                self.ime.set_active(false);
+            }
+            (false, true) => {
+                self.ime.set_active(true);
+                update_ime_origin = true;
+            }
+            (false, false) | (true, true) => {}
+        }
+
+        if offset != old_offset
+            || editor_data.editor.scroll_offset
+                != old_editor_data.editor.scroll_offset
+        {
+            update_ime_origin = true;
         }
-        if editor_data.editor.compare != old_editor_data.editor.compare {
+
+        if update_ime_origin {
+            let (_, origin) = editor_data.doc.points_of_offset(
+                ctx.text(),
+                offset,
+                &editor_data.editor.view,
+                &editor_data.config,
+            );
+            self.ime.set_origin(
+                *editor_data.editor.window_origin.borrow() + (origin.x, origin.y),
+            );
+        }
+
+        if editor_data.editor.content != old_editor_data.editor.content {
             ctx.request_layout();
+            if let Some(editor_tab_id) = editor_data.editor.tab_id.as_ref() {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::EditorContentChanged,
+                    Target::Widget(*editor_tab_id),
+                ));
+            }
         }
-        if editor_data.editor.code_lens != old_editor_data.editor.code_lens {
+        if editor_data.editor.view != old_editor_data.editor.view {
             ctx.request_layout();
         }
         if let EditorView::Diff(version) = &editor_data.editor.view {
@@ -887,6 +1120,7 @@ impl Widget<LapceTabData> for LapceEditorView {
         let self_size = bc.max();
         let header_size = self.header.layout(ctx, bc, data, env);
         self.header.set_origin(ctx, data, env, Point::ZERO);
+
         let editor_size = if self_size.height > header_size.height {
             let editor_size =
                 Size::new(self_size.width, self_size.height - header_size.height);
@@ -914,7 +1148,13 @@ impl Widget<LapceTabData> for LapceEditorView {
                 Point::new(size.width - find_size.width - 10.0, header_size.height),
             );
         }
-
+        let diff_size = self.diff.layout(ctx, bc, data, env);
+        self.diff.set_origin(
+            ctx,
+            data,
+            env,
+            Point::new(size.width - diff_size.width - 10.0, header_size.height),
+        );
         size
     }
 
@@ -925,19 +1165,19 @@ impl Widget<LapceTabData> for LapceEditorView {
             if editor.content.is_input() {
                 ctx.fill(
                     rect.inflate(5.0, 0.0),
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
-                );
-                ctx.stroke(
-                    rect.inflate(4.5, -0.5),
-                    data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
-                    1.0,
+                    data.config.get_color_unchecked(self.background_color_name),
                 );
+                if self.display_border {
+                    ctx.stroke(
+                        rect.inflate(4.5, -0.5),
+                        data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                        1.0,
+                    );
+                }
             } else {
                 ctx.fill(
                     rect.inflate(5.0, 5.0),
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+                    data.config.get_color_unchecked(self.background_color_name),
                 );
             }
         }
@@ -947,5 +1187,6 @@ impl Widget<LapceTabData> for LapceEditorView {
         if let Some(find) = self.find.as_mut() {
             find.paint(ctx, data, env);
         }
+        self.diff.paint(ctx, data, env);
     }
 }
diff --git a/lapce-ui/src/explorer.rs b/lapce-ui/src/explorer.rs
index 7f9f0b5385..606562d705 100644
--- a/lapce-ui/src/explorer.rs
+++ b/lapce-ui/src/explorer.rs
@@ -1,31 +1,157 @@
-use std::sync::Arc;
-use std::{collections::HashMap, path::Path};
+use std::{collections::HashMap, path::Path, sync::Arc};
 
 use druid::{
-    piet::{Text, TextLayout as PietTextLayout, TextLayoutBuilder},
-    BoxConstraints, Command, Cursor, Env, Event, EventCtx, LayoutCtx, LifeCycle,
-    LifeCycleCtx, PaintCtx, Point, Rect, RenderContext, Size, Target, UpdateCtx,
-    Widget, WidgetExt, WidgetId, WidgetPod,
+    menu::MenuEventCtx,
+    piet::{Text, TextAttribute, TextLayoutBuilder},
+    BoxConstraints, Command, Cursor, Env, Event, EventCtx, ExtEventSink, KbKey,
+    LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, Point, Rect, RenderContext, Size,
+    Target, UpdateCtx, Widget, WidgetExt, WidgetId, WidgetPod, WindowId,
 };
+use itertools::Itertools;
+use lapce_core::{command::FocusCommand, meta};
 use lapce_data::{
-    command::LapceUICommand,
-    command::LAPCE_UI_COMMAND,
-    config::{Config, LapceTheme},
-    data::LapceTabData,
-    split::SplitDirection,
+    command::{
+        CommandKind, LapceCommand, LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
+    },
+    config::{ClickMode, LapceConfig, LapceIcons, LapceTheme},
+    data::{EditorTabChild, LapceData, LapceEditorData, LapceTabData},
+    document::{BufferContent, LocalBufferKind},
+    explorer::{FileExplorerData, Naming},
+    panel::PanelKind,
+    proxy::LapceProxy,
 };
-use lapce_data::{data::PanelKind, explorer::FileExplorerData};
-use lapce_rpc::file::FileNodeItem;
+use lapce_rpc::{file::FileNodeItem, source_control::FileDiff};
 
 use crate::{
-    panel::{LapcePanel, PanelHeaderKind},
+    editor::view::LapceEditorView,
+    panel::{LapcePanel, PanelHeaderKind, PanelSizing},
     scroll::LapceScroll,
-    svg::{file_svg, get_svg},
 };
 
+#[allow(clippy::too_many_arguments)]
+/// Paint the file node item at its position
+fn paint_single_file_node_item(
+    ctx: &mut PaintCtx,
+    item: &FileNodeItem,
+    line_height: f64,
+    width: f64,
+    level: usize,
+    current: usize,
+    active: Option<&Path>,
+    hovered: Option<usize>,
+    config: &LapceConfig,
+    toggle_rects: &mut HashMap<usize, Rect>,
+    file_diff: Option<FileDiff>,
+) {
+    let background = if Some(item.path_buf.as_ref()) == active {
+        Some(LapceTheme::PANEL_CURRENT_BACKGROUND)
+    } else if Some(current) == hovered {
+        Some(LapceTheme::PANEL_HOVERED_BACKGROUND)
+    } else {
+        None
+    };
+
+    if let Some(background) = background {
+        ctx.fill(
+            Rect::ZERO
+                .with_origin(Point::new(
+                    0.0,
+                    current as f64 * line_height - line_height,
+                ))
+                .with_size(Size::new(width, line_height)),
+            config.get_color_unchecked(background),
+        );
+    }
+
+    let text_color = if let Some(diff) = file_diff {
+        match diff {
+            FileDiff::Modified(_) | FileDiff::Renamed(_, _) => {
+                LapceTheme::SOURCE_CONTROL_MODIFIED
+            }
+            FileDiff::Added(_) => LapceTheme::SOURCE_CONTROL_ADDED,
+            FileDiff::Deleted(_) => LapceTheme::SOURCE_CONTROL_REMOVED,
+        }
+    } else {
+        LapceTheme::PANEL_FOREGROUND
+    };
+
+    let font_size = config.ui.font_size() as f64;
+
+    let y = current as f64 * line_height - line_height;
+    let svg_size = config.ui.icon_size() as f64;
+    let svg_y = y + (line_height - svg_size) / 2.0;
+    let padding = 15.0 * level as f64;
+
+    if item.is_dir {
+        let icon_name = if item.open {
+            LapceIcons::ITEM_OPENED
+        } else {
+            LapceIcons::ITEM_CLOSED
+        };
+        let svg = config.ui_svg(icon_name);
+
+        let rect = Size::new(svg_size, svg_size)
+            .to_rect()
+            .with_origin(Point::new(1.0 + padding, svg_y));
+        ctx.draw_svg(
+            &svg,
+            rect,
+            Some(config.get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)),
+        );
+        toggle_rects.insert(current, rect);
+
+        let (svg, svg_color) =
+            if let Some((svg, svg_color)) = config.folder_svg(&item.path_buf) {
+                (svg, svg_color)
+            } else {
+                let icon_name = if item.open {
+                    LapceIcons::DIRECTORY_OPENED
+                } else {
+                    LapceIcons::DIRECTORY_CLOSED
+                };
+                let svg = config.ui_svg(icon_name);
+                (
+                    svg,
+                    Some(config.get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)),
+                )
+            };
+        let rect = Size::new(svg_size, svg_size)
+            .to_rect()
+            .with_origin(Point::new(1.0 + 16.0 + padding, svg_y));
+        ctx.draw_svg(&svg, rect, svg_color);
+    } else {
+        let (svg, svg_color) = config.file_svg(&item.path_buf);
+        let rect = Size::new(svg_size, svg_size)
+            .to_rect()
+            .with_origin(Point::new(1.0 + 16.0 + padding, svg_y));
+        ctx.draw_svg(&svg, rect, svg_color);
+    }
+
+    let text_layout = ctx
+        .text()
+        .new_text_layout(
+            item.path_buf
+                .file_name()
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .to_string(),
+        )
+        .font(config.ui.font_family(), font_size)
+        .text_color(config.get_color_unchecked(text_color).clone())
+        .build()
+        .unwrap();
+    ctx.draw_text(
+        &text_layout,
+        Point::new(38.0 + padding, y + text_layout.y_offset(line_height)),
+    );
+}
+
+/// Paint the file node item, if it is in view, and its children
 #[allow(clippy::too_many_arguments)]
 pub fn paint_file_node_item(
     ctx: &mut PaintCtx,
+    env: &Env,
     item: &FileNodeItem,
     min: usize,
     max: usize,
@@ -35,7 +161,11 @@ pub fn paint_file_node_item(
     current: usize,
     active: Option<&Path>,
     hovered: Option<usize>,
-    config: &Config,
+    naming: Option<&Naming>,
+    name_edit_input: &mut NameEditInput,
+    drawn_name_input: &mut bool,
+    data: &LapceTabData,
+    config: &LapceConfig,
     toggle_rects: &mut HashMap<usize, Rect>,
 ) -> usize {
     if current > max {
@@ -44,96 +174,45 @@ pub fn paint_file_node_item(
     if current + item.children_open_count < min {
         return current + item.children_open_count;
     }
-    if current >= min {
-        let background = if Some(item.path_buf.as_ref()) == active {
-            Some(LapceTheme::PANEL_CURRENT)
-        } else if Some(current) == hovered {
-            Some(LapceTheme::PANEL_HOVERED)
-        } else {
-            None
-        };
 
-        if let Some(background) = background {
-            ctx.fill(
-                Rect::ZERO
-                    .with_origin(Point::new(
-                        0.0,
-                        current as f64 * line_height - line_height,
-                    ))
-                    .with_size(Size::new(width, line_height)),
-                config.get_color_unchecked(background),
-            );
+    let mut i = current;
+
+    if current >= min {
+        let mut should_paint_file_node = true;
+        if !*drawn_name_input {
+            if let Some(naming) = naming {
+                if current == naming.list_index() {
+                    draw_name_input(ctx, data, env, &mut i, naming, name_edit_input);
+                    *drawn_name_input = true;
+                    // If it is renaming then don't draw the underlying file node
+                    should_paint_file_node =
+                        !matches!(naming, Naming::Renaming { .. })
+                }
+            }
         }
 
-        let y = current as f64 * line_height - line_height;
-        let svg_y = y + 4.0;
-        let svg_size = 15.0;
-        let padding = 15.0 * level as f64;
-        if item.is_dir {
-            let icon_name = if item.open {
-                "chevron-down.svg"
-            } else {
-                "chevron-right.svg"
-            };
-            let svg = get_svg(icon_name).unwrap();
-            let rect = Size::new(svg_size, svg_size)
-                .to_rect()
-                .with_origin(Point::new(1.0 + padding, svg_y));
-            ctx.draw_svg(
-                &svg,
-                rect,
-                Some(config.get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)),
+        if should_paint_file_node {
+            paint_single_file_node_item(
+                ctx,
+                item,
+                line_height,
+                width,
+                level,
+                i,
+                active,
+                hovered,
+                config,
+                toggle_rects,
+                get_item_diff(item, data),
             );
-            toggle_rects.insert(current, rect);
-
-            let icon_name = if item.open {
-                "default_folder_opened.svg"
-            } else {
-                "default_folder.svg"
-            };
-            let svg = get_svg(icon_name).unwrap();
-            let rect = Size::new(svg_size, svg_size)
-                .to_rect()
-                .with_origin(Point::new(1.0 + 16.0 + padding, svg_y));
-            ctx.draw_svg(&svg, rect, None);
-        } else {
-            let svg = file_svg(&item.path_buf);
-            let rect = Size::new(svg_size, svg_size)
-                .to_rect()
-                .with_origin(Point::new(1.0 + 16.0 + padding, svg_y));
-            ctx.draw_svg(&svg, rect, None);
         }
-        let text_layout = ctx
-            .text()
-            .new_text_layout(
-                item.path_buf
-                    .file_name()
-                    .unwrap()
-                    .to_str()
-                    .unwrap()
-                    .to_string(),
-            )
-            .font(config.ui.font_family(), config.ui.font_size() as f64)
-            .text_color(
-                config
-                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                    .clone(),
-            )
-            .build()
-            .unwrap();
-        ctx.draw_text(
-            &text_layout,
-            Point::new(
-                38.0 + padding,
-                y + (line_height - text_layout.size().height) / 2.0,
-            ),
-        );
     }
-    let mut i = current;
+
     if item.open {
         for item in item.sorted_children() {
             i = paint_file_node_item(
                 ctx,
+                env,
                 item,
                 min,
                 max,
@@ -143,6 +222,10 @@ pub fn paint_file_node_item(
                 i + 1,
                 active,
                 hovered,
+                naming,
+                name_edit_input,
+                drawn_name_input,
+                data,
                 config,
                 toggle_rects,
             );
@@ -154,6 +237,27 @@ pub fn paint_file_node_item(
     i
 }
 
+fn draw_name_input(
+    ctx: &mut PaintCtx,
+    data: &LapceTabData,
+    env: &Env,
+    i: &mut usize,
+    naming: &Naming,
+    name_edit_input: &mut NameEditInput,
+) {
+    match naming {
+        Naming::Renaming { .. } => {
+            name_edit_input.paint(ctx, data, env);
+        }
+        Naming::Naming { .. } | Naming::Duplicating { .. } => {
+            name_edit_input.paint(ctx, data, env);
+            // Skip forward by an entry
+            // This is fine since we aren't using i as an index, but as an offset-multiple in painting
+            *i += 1;
+        }
+    }
+}
+
 pub fn get_item_children(
     i: usize,
     index: usize,
@@ -178,6 +282,27 @@ pub fn get_item_children(
     (i, None)
 }
 
+/// Get a FileDiff for the given FileNodeItem. If the given item is a folder
+/// that contains changes, returns a "fake" FileDiff that can be used to style
+/// the item accordingly.
+fn get_item_diff<'data>(
+    item: &'data FileNodeItem,
+    data: &'data LapceTabData,
+) -> Option<FileDiff> {
+    if item.is_dir {
+        data.source_control
+            .file_diffs
+            .keys()
+            .find(|path| path.as_path().starts_with(&item.path_buf))
+            .map(|path| FileDiff::Modified(path.clone()))
+    } else {
+        data.source_control
+            .file_diffs
+            .get(&item.path_buf)
+            .map(|d| d.0.clone())
+    }
+}
+
 pub fn get_item_children_mut(
     i: usize,
     index: usize,
@@ -204,32 +329,72 @@ pub fn get_item_children_mut(
 
 pub struct FileExplorer {
     widget_id: WidgetId,
-    file_list: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    file_list:
+        WidgetPod<LapceTabData, LapceScroll<LapceTabData, FileExplorerFileList>>,
+    pending_scroll: Option<(f64, f64)>,
+    pending_layout: bool,
 }
 
 impl FileExplorer {
-    pub fn new(data: &FileExplorerData) -> Self {
-        let file_list = LapceScroll::new(FileExplorerFileList::new());
+    pub fn new(data: &mut LapceTabData) -> Self {
+        // Create the input editor for renaming/naming files/directories
+        let editor = LapceEditorData::new(
+            Some(data.file_explorer.renaming_editor_view_id),
+            None,
+            None,
+            BufferContent::Local(LocalBufferKind::PathName),
+            &data.config,
+        );
+
+        let input = LapceEditorView::new(editor.view_id, editor.editor_id, None)
+            .hide_header()
+            .hide_gutter()
+            .hide_border()
+            .set_background_color(LapceTheme::PANEL_HOVERED_BACKGROUND);
+        let view_id = editor.view_id;
+        data.main_split.editors.insert(view_id, Arc::new(editor));
+        // Create the file listing
+        let file_list = LapceScroll::new(FileExplorerFileList::new(WidgetPod::new(
+            input.boxed(),
+        )));
+
         Self {
-            widget_id: data.widget_id,
-            file_list: WidgetPod::new(file_list.boxed()),
+            widget_id: data.file_explorer.widget_id,
+            file_list: WidgetPod::new(file_list),
+            pending_scroll: None,
+            pending_layout: true,
         }
     }
 
-    pub fn new_panel(data: &LapceTabData) -> LapcePanel {
+    pub fn new_panel(data: &mut LapceTabData) -> LapcePanel {
         let split_id = WidgetId::next();
         LapcePanel::new(
             PanelKind::FileExplorer,
             data.file_explorer.widget_id,
             split_id,
-            SplitDirection::Vertical,
-            PanelHeaderKind::Simple("File Explorer".into()),
-            vec![(
-                split_id,
-                PanelHeaderKind::None,
-                Self::new(&data.file_explorer).boxed(),
-                None,
-            )],
+            vec![
+                (
+                    WidgetId::next(),
+                    PanelHeaderKind::Simple("Open Editors".into()),
+                    LapceScroll::new(OpenEditorList::new()).boxed(),
+                    PanelSizing::Size(200.0),
+                ),
+                (
+                    split_id,
+                    PanelHeaderKind::Simple(
+                        data.workspace
+                            .path
+                            .as_ref()
+                            .and_then(|p| p.file_name())
+                            .and_then(|s| s.to_str())
+                            .map(|s| s.to_string())
+                            .unwrap_or_else(|| "No Folder Open".to_string())
+                            .into(),
+                    ),
+                    Self::new(data).boxed(),
+                    PanelSizing::Flex(true),
+                ),
+            ],
         )
     }
 }
@@ -246,6 +411,34 @@ impl Widget<LapceTabData> for FileExplorer {
         data: &mut LapceTabData,
         env: &Env,
     ) {
+        match event {
+            Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
+                let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
+
+                if let LapceUICommand::ScrollTo(point) = command {
+                    self.pending_scroll = Some(point.to_owned());
+                    self.pending_layout = true;
+                    ctx.request_anim_frame();
+                    return;
+                }
+            }
+
+            Event::AnimFrame(_) => {
+                if self.pending_layout {
+                    ctx.request_anim_frame();
+                } else {
+                    // make sure layout is updated before we scroll
+                    if let Some(scroll) = self.pending_scroll.take() {
+                        let target = Point::from(scroll);
+
+                        self.file_list.widget_mut().scroll_to(target);
+                    }
+                }
+            }
+
+            _ => (),
+        }
+
         self.file_list.event(ctx, event, data, env);
     }
 
@@ -280,6 +473,7 @@ impl Widget<LapceTabData> for FileExplorer {
         self.file_list.layout(ctx, bc, data, env);
         self.file_list
             .set_origin(ctx, data, env, Point::new(0.0, 0.0));
+        self.pending_layout = false;
         self_size
     }
 
@@ -288,23 +482,91 @@ impl Widget<LapceTabData> for FileExplorer {
     }
 }
 
+type NameEditInput = WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>;
+
 struct FileExplorerFileList {
     line_height: f64,
     hovered: Option<usize>,
+    name_edit_input: NameEditInput,
 }
 
 impl FileExplorerFileList {
-    pub fn new() -> Self {
+    pub fn new(input: NameEditInput) -> Self {
         Self {
             line_height: 25.0,
             hovered: None,
+            name_edit_input: input,
         }
     }
-}
 
-impl Default for FileExplorerFileList {
-    fn default() -> Self {
-        Self::new()
+    pub fn reveal_path(
+        &self,
+        path: &Path,
+        file_explorer: &mut FileExplorerData,
+        tab_id: WidgetId,
+        proxy: &LapceProxy,
+        target: Target,
+        ctx: &mut EventCtx,
+    ) {
+        let paths = match file_explorer.node_tree(path) {
+            Some(paths) => paths,
+            None => return,
+        };
+
+        for node_path in paths.iter().rev() {
+            log::debug!("visiting node: {}", node_path.display());
+
+            let node = file_explorer.get_node_mut(node_path).unwrap();
+
+            if !node.is_dir {
+                continue;
+            }
+
+            if !node.read {
+                let event_sink = ctx.get_external_handle();
+                let event_sink_read = ctx.get_external_handle();
+                let path = path.to_path_buf();
+
+                FileExplorerData::read_dir_cb(
+                    &node.path_buf,
+                    true,
+                    tab_id,
+                    proxy,
+                    event_sink_read,
+                    Some(move || {
+                        let _ = event_sink.submit_command(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::ExplorerRevealPath { path },
+                            target,
+                        );
+                    }),
+                );
+
+                return;
+            }
+
+            if !node.open {
+                node.open = true;
+
+                let path = node.path_buf.clone();
+
+                for current_path in path.ancestors() {
+                    file_explorer.update_node_count(current_path);
+                }
+            }
+        }
+
+        let index = file_explorer.get_node_index(path);
+
+        if let Some(index) = index {
+            let point = Point::new(0f64, (index - 3) as f64 * self.line_height);
+
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::ScrollTo(point.into()),
+                target,
+            ));
+        }
     }
 }
 
@@ -314,25 +576,90 @@ impl Widget<LapceTabData> for FileExplorerFileList {
         ctx: &mut EventCtx,
         event: &Event,
         data: &mut LapceTabData,
-        _env: &Env,
+        env: &Env,
     ) {
         match event {
             Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
                 let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
 
-                if let LapceUICommand::ActiveFileChanged { path } = command {
-                    let file_explorer = Arc::make_mut(&mut data.file_explorer);
-                    file_explorer.active_selected = path.clone();
-                    ctx.request_paint();
+                match command {
+                    LapceUICommand::ActiveFileChanged { path } => {
+                        let file_explorer = Arc::make_mut(&mut data.file_explorer);
+                        file_explorer.active_selected = path.clone();
+                        ctx.request_paint();
+                    }
+                    LapceUICommand::FileExplorerRefresh => {
+                        data.file_explorer.reload();
+                    }
+
+                    LapceUICommand::ExplorerRevealPath { path } => {
+                        let file_explorer = Arc::make_mut(&mut data.file_explorer);
+
+                        self.reveal_path(
+                            path,
+                            file_explorer,
+                            data.id,
+                            data.proxy.as_ref(),
+                            cmd.target(),
+                            ctx,
+                        );
+                    }
+                    _ => (),
                 }
             }
             _ => {}
         }
-        if !ctx.is_hot() {
+
+        // Finish any renaming if the user presses enter
+        if let Event::KeyDown(key_ev) = event {
+            if self.name_edit_input.has_focus() {
+                if key_ev.key == KbKey::Enter {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::ExplorerEndNaming { apply_naming: true },
+                        Target::Auto,
+                    ));
+                } else if key_ev.key == KbKey::Escape {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::ExplorerEndNaming {
+                            apply_naming: false,
+                        },
+                        Target::Auto,
+                    ));
+                }
+            }
+        }
+
+        if data.file_explorer.naming.is_some() {
+            self.name_edit_input.event(ctx, event, data, env);
+            // If the input handled the event, then we just ignore it.
+            if ctx.is_handled() {
+                return;
+            }
+        }
+
+        // We can catch these here because they'd be consumed by name edit input if they were for/on it
+        if matches!(
+            event,
+            Event::MouseDown(_) | Event::KeyUp(_) | Event::KeyDown(_)
+        ) && data.file_explorer.naming.is_some()
+            && !self.name_edit_input.has_focus()
+        {
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::ExplorerEndNaming { apply_naming: true },
+                Target::Auto,
+            ));
             return;
         }
+
         match event {
             Event::MouseMove(mouse_event) => {
+                if !ctx.is_hot() {
+                    return;
+                }
+
                 if let Some(workspace) = data.file_explorer.workspace.as_ref() {
                     let y = mouse_event.pos.y;
                     if y <= self.line_height
@@ -356,60 +683,267 @@ impl Widget<LapceTabData> for FileExplorerFileList {
                 }
             }
             Event::MouseDown(mouse_event) => {
+                if !ctx.is_hot() {
+                    return;
+                }
+
+                let double_click_mode = data.config.editor.double_click.clone();
                 let file_explorer = Arc::make_mut(&mut data.file_explorer);
                 let index = ((mouse_event.pos.y + self.line_height)
                     / self.line_height) as usize;
-                if let Some(node) = file_explorer.get_node_by_index(index) {
-                    if node.is_dir {
-                        if node.read {
-                            node.open = !node.open;
+
+                if mouse_event.button.is_left() {
+                    if let Some((_, node)) =
+                        file_explorer.get_node_by_index_mut(index)
+                    {
+                        if node.is_dir {
+                            let cont_open = !(matches!(
+                                double_click_mode,
+                                ClickMode::DoubleClickAll
+                            ) && mouse_event.count < 2);
+                            if cont_open {
+                                if node.read {
+                                    node.open = !node.open;
+                                } else {
+                                    let tab_id = data.id;
+                                    let event_sink = ctx.get_external_handle();
+                                    FileExplorerData::read_dir(
+                                        &node.path_buf,
+                                        true,
+                                        tab_id,
+                                        &data.proxy,
+                                        event_sink,
+                                    );
+                                }
+                                let path = node.path_buf.clone();
+                                if let Some(paths) = file_explorer.node_tree(&path) {
+                                    for path in paths.iter() {
+                                        file_explorer.update_node_count(path);
+                                    }
+                                }
+                            }
                         } else {
-                            let tab_id = data.id;
-                            let event_sink = ctx.get_external_handle();
-                            FileExplorerData::read_dir(
-                                &node.path_buf,
-                                true,
+                            let cont_open =
+                                matches!(double_click_mode, ClickMode::SingleClick)
+                                    || mouse_event.count > 1;
+                            if cont_open {
+                                ctx.submit_command(Command::new(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::OpenFile(
+                                        node.path_buf.clone(),
+                                        false,
+                                    ),
+                                    Target::Widget(data.id),
+                                ));
+                                ctx.submit_command(Command::new(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::ActiveFileChanged {
+                                        path: Some(node.path_buf.clone()),
+                                    },
+                                    Target::Widget(file_explorer.widget_id),
+                                ));
+                            }
+                        }
+                    }
+                }
+
+                if mouse_event.button.is_right() {
+                    if let Some((indent_level, node)) = file_explorer
+                        .get_node_by_index(index)
+                        .or_else(|| file_explorer.workspace.as_ref().map(|x| (0, x)))
+                    {
+                        let workspace_path = file_explorer
+                            .workspace
+                            .as_ref()
+                            .map(|x| &x.path_buf)
+                            .unwrap();
+                        let is_workspace = &node.path_buf == workspace_path;
+
+                        // The folder that it is, or is within
+                        let base = if node.is_dir {
+                            Some(node.path_buf.clone())
+                        } else {
+                            node.path_buf.parent().map(ToOwned::to_owned)
+                        };
+
+                        // If there's no reasonable path at the point, then ignore it
+                        let base = if let Some(base) = base {
+                            base
+                        } else {
+                            return;
+                        };
+
+                        // Create a context menu with different actions that can be performed on a file/dir
+                        // or in the directory
+                        let mut menu = druid::Menu::<LapceData>::new("Explorer");
+
+                        // The ids are so that the correct LapceTabData can be acquired inside the menu event cb
+                        // since the context menu only gets access to LapceData
+                        let window_id = *data.window_id;
+                        let tab_id = data.id;
+                        let item = druid::MenuItem::new("New File").on_activate(
+                            make_new_file_cb(
+                                ctx,
+                                &base,
+                                window_id,
                                 tab_id,
-                                &data.proxy,
-                                event_sink,
-                            );
+                                is_workspace,
+                                index,
+                                indent_level,
+                                false,
+                            ),
+                        );
+
+                        menu = menu.entry(item);
+
+                        let item = druid::MenuItem::new("New Directory")
+                            .on_activate(make_new_file_cb(
+                                ctx,
+                                &base,
+                                window_id,
+                                tab_id,
+                                is_workspace,
+                                index,
+                                indent_level,
+                                true,
+                            ));
+                        menu = menu.entry(item);
+
+                        // Separator between non destructive and destructive actions
+                        menu = menu.separator();
+
+                        if !data.workspace.kind.is_remote() {
+                            let item =
+                                druid::MenuItem::new("Reveal in file explorer")
+                                    .command(Command::new(
+                                        LAPCE_UI_COMMAND,
+                                        LapceUICommand::RevealInFileExplorer(
+                                            node.path_buf.clone(),
+                                        ),
+                                        Target::Auto,
+                                    ));
+                            menu = menu.entry(item);
                         }
-                        let path = node.path_buf.clone();
-                        if let Some(paths) = file_explorer.node_tree(&path) {
-                            for path in paths.iter() {
-                                file_explorer.update_node_count(path);
+
+                        // Don't allow us to rename or delete the current workspace
+                        if !is_workspace {
+                            let item = druid::MenuItem::new("Rename").command(
+                                Command::new(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::ExplorerStartRename {
+                                        list_index: index,
+                                        indent_level,
+                                        text: node
+                                            .path_buf
+                                            .file_name()
+                                            .map(|x| x.to_string_lossy().to_string())
+                                            .unwrap_or_else(String::new),
+                                    },
+                                    Target::Auto,
+                                ),
+                            );
+                            menu = menu.entry(item);
+
+                            if !node.is_dir {
+                                let item = druid::MenuItem::new("Duplicate")
+                                    .command(Command::new(
+                                        LAPCE_UI_COMMAND,
+                                        LapceUICommand::ExplorerStartDuplicate {
+                                            list_index: index,
+                                            indent_level,
+                                            base_path: node
+                                                .path_buf
+                                                .parent()
+                                                .expect("file without parent")
+                                                .to_owned(),
+                                            name: node
+                                                .path_buf
+                                                .file_name()
+                                                .expect("file without name")
+                                                .to_string_lossy()
+                                                .into_owned(),
+                                        },
+                                        Target::Auto,
+                                    ));
+                                menu = menu.entry(item);
                             }
+
+                            let trash_text = if node.is_dir {
+                                "Move Directory to Trash"
+                            } else {
+                                "Move File to Trash"
+                            };
+                            let item = druid::MenuItem::new(trash_text).command(
+                                Command::new(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::TrashPath {
+                                        path: node.path_buf.clone(),
+                                    },
+                                    Target::Auto,
+                                ),
+                            );
+                            menu = menu.entry(item);
                         }
-                    } else {
-                        ctx.submit_command(Command::new(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::OpenFile(node.path_buf.clone()),
-                            Target::Widget(data.id),
-                        ));
-                        ctx.submit_command(Command::new(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::ActiveFileChanged {
-                                path: Some(node.path_buf.clone()),
-                            },
-                            Target::Widget(file_explorer.widget_id),
-                        ));
+
+                        menu = menu.separator();
+                        let path_to_file = node.path_buf.clone();
+                        let item =
+                            druid::MenuItem::new("Copy Path").command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::PutToClipboard(
+                                    path_to_file.to_str().unwrap().to_string(),
+                                ),
+                                Target::Auto,
+                            ));
+                        menu = menu.entry(item);
+
+                        let relative_path = node
+                            .path_buf
+                            .strip_prefix(workspace_path)
+                            .unwrap()
+                            .to_path_buf();
+                        let item = druid::MenuItem::new("Copy Relative Path")
+                            .command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::PutToClipboard(
+                                    relative_path.to_str().unwrap().to_string(),
+                                ),
+                                Target::Auto,
+                            ));
+                        menu = menu.entry(item);
+
+                        menu = menu.separator();
+                        let item =
+                            druid::MenuItem::new("Refresh").command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::FileExplorerRefresh,
+                                Target::Auto,
+                            ));
+                        menu = menu.entry(item);
+
+                        ctx.show_context_menu::<LapceData>(
+                            menu,
+                            ctx.to_window(mouse_event.pos),
+                        );
                     }
                 }
             }
-            _ => (),
+            _ => {}
         }
     }
 
     fn lifecycle(
         &mut self,
-        _ctx: &mut LifeCycleCtx,
+        ctx: &mut LifeCycleCtx,
         event: &LifeCycle,
-        _data: &LapceTabData,
-        _env: &Env,
+        data: &LapceTabData,
+        env: &Env,
     ) {
         if let LifeCycle::HotChanged(false) = event {
             self.hovered = None;
         }
+
+        self.name_edit_input.lifecycle(ctx, event, data, env);
     }
 
     fn update(
@@ -417,7 +951,7 @@ impl Widget<LapceTabData> for FileExplorerFileList {
         ctx: &mut UpdateCtx,
         old_data: &LapceTabData,
         data: &LapceTabData,
-        _env: &Env,
+        env: &Env,
     ) {
         if data
             .file_explorer
@@ -432,26 +966,70 @@ impl Widget<LapceTabData> for FileExplorerFileList {
         {
             ctx.request_layout();
         }
+
+        if data.file_explorer.naming.is_some() {
+            self.name_edit_input.update(ctx, data, env);
+        }
     }
 
     fn layout(
         &mut self,
-        _ctx: &mut LayoutCtx,
+        ctx: &mut LayoutCtx,
         bc: &BoxConstraints,
         data: &LapceTabData,
-        _env: &Env,
+        env: &Env,
     ) -> Size {
-        let height = data
+        if let Some(naming) = &data.file_explorer.naming {
+            let (&index, &level) = match naming {
+                Naming::Renaming {
+                    list_index,
+                    indent_level,
+                }
+                | Naming::Naming {
+                    list_index,
+                    indent_level,
+                    ..
+                }
+                | Naming::Duplicating {
+                    list_index,
+                    indent_level,
+                    ..
+                } => (list_index, indent_level),
+            };
+
+            let max = bc.max();
+            let input_bc = bc.shrink(Size::new(max.width / 2.0, 0.0));
+            self.name_edit_input.layout(ctx, &input_bc, data, env);
+
+            let y_pos = (index as f64 * self.line_height) - self.line_height;
+            let x_pos = 38.0 + (15.0 * level as f64);
+            self.name_edit_input.set_origin(
+                ctx,
+                data,
+                env,
+                Point::new(x_pos, y_pos),
+            );
+        }
+
+        let mut height = data
             .file_explorer
             .workspace
             .as_ref()
             .map(|w| w.children_open_count)
-            .unwrap_or(0) as f64
-            * self.line_height;
+            .unwrap_or(0);
+        if matches!(data.file_explorer.naming, Some(Naming::Naming { .. })) {
+            height += 1;
+        }
+        let height = height as f64 * self.line_height;
+        // Choose whichever one is larger
+        // We want to use bc.max().height when the number of entries is smaller than the window
+        // height, because receiving right click events requires reporting that we fill the panel
+        let height = height.max(bc.max().height);
+
         Size::new(bc.max().width, height)
     }
 
-    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
         let rect = ctx.region().bounding_box();
         let size = ctx.size();
         let width = size.width;
@@ -459,12 +1037,14 @@ impl Widget<LapceTabData> for FileExplorerFileList {
         let min = (rect.y0 / self.line_height).floor() as usize;
         let max = (rect.y1 / self.line_height) as usize + 2;
         let level = 0;
+        let mut drawn_name_input = false;
 
         if let Some(item) = data.file_explorer.workspace.as_ref() {
             let mut i = 0;
             for item in item.sorted_children() {
                 i = paint_file_node_item(
                     ctx,
+                    env,
                     item,
                     min,
                     max,
@@ -474,6 +1054,10 @@ impl Widget<LapceTabData> for FileExplorerFileList {
                     i + 1,
                     active,
                     self.hovered,
+                    data.file_explorer.naming.as_ref(),
+                    &mut self.name_edit_input,
+                    &mut drawn_name_input,
+                    data,
                     &data.config,
                     &mut HashMap::new(),
                 );
@@ -481,6 +1065,503 @@ impl Widget<LapceTabData> for FileExplorerFileList {
                     return;
                 }
             }
+
+            // If we didn't draw the name input then we'll have to draw it here
+            if let Some(naming) = &data.file_explorer.naming {
+                if i == 0
+                    || (naming.list_index() >= min && naming.list_index() < max)
+                {
+                    draw_name_input(
+                        ctx,
+                        data,
+                        env,
+                        // This value does not matter here
+                        &mut 0,
+                        naming,
+                        &mut self.name_edit_input,
+                    );
+                }
+            }
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+/// Create a callback for the context menu when creating a file/directory
+/// This is the same function for both, besides one change in parameter
+fn make_new_file_cb(
+    ctx: &mut EventCtx,
+    base: &Path,
+    window_id: WindowId,
+    tab_id: WidgetId,
+    is_workspace: bool,
+    index: usize,
+    indent_level: usize,
+    is_dir: bool,
+) -> impl FnMut(&mut MenuEventCtx, &mut LapceData, &Env) + 'static {
+    // If the node we're on is the workspace then we'll appear at the very start
+    let display_index = if is_workspace { 1 } else { index + 1 };
+
+    let event_sink = ctx.get_external_handle();
+    let base_path = base.to_owned();
+    move |_ctx, data: &mut LapceData, _env| {
+        // Clone the handle within, since on_active is an FnMut, so we can't move it into the second
+        // closure
+        let event_sink = event_sink.clone();
+        let base_path = base_path.clone();
+
+        // Acquire the LapceTabData instance we were within
+        let tab_data = data
+            .windows
+            .get_mut(&window_id)
+            .unwrap()
+            .tabs
+            .get_mut(&tab_id)
+            .unwrap();
+
+        // Expand the directory, if it is one and if it needs to
+        expand_dir(
+            event_sink.clone(),
+            &tab_data.proxy,
+            tab_id,
+            Arc::make_mut(&mut tab_data.file_explorer),
+            index,
+            move || {
+                // After we send the command to update the directory, we submit the command to display the new file
+                // input box
+                // We ignore any error coming from submit command as failing here shouldn't crash lapce
+                let res = event_sink.submit_command(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::ExplorerNew {
+                        list_index: display_index,
+                        indent_level,
+                        is_dir,
+                        base_path,
+                    },
+                    Target::Auto,
+                );
+
+                if let Err(err) = res {
+                    log::warn!(
+                        "Failed to start constructing new/file directory: {:?}",
+                        err
+                    );
+                }
+            },
+        );
+    }
+}
+
+/// Expand the directory in the view
+/// `on_finished` is called when its done, but the files in the list are not yet updated
+/// but the command has been sent. This lets the user queue commands to occur right after it.
+/// Note: `on_finished` is also called when there is no dir it didn't need reading
+fn expand_dir(
+    event_sink: ExtEventSink,
+    proxy: &LapceProxy,
+    tab_id: WidgetId,
+    file_explorer: &mut FileExplorerData,
+    index: usize,
+    on_finished: impl FnOnce() + Send + 'static,
+) {
+    if let Some((_, node)) = file_explorer.get_node_by_index_mut(index) {
+        if node.is_dir {
+            if node.read {
+                node.open = true;
+                on_finished();
+            } else {
+                FileExplorerData::read_dir_cb(
+                    &node.path_buf,
+                    true,
+                    tab_id,
+                    proxy,
+                    event_sink,
+                    Some(on_finished),
+                );
+            }
+            let path = node.path_buf.clone();
+            if let Some(paths) = file_explorer.node_tree(&path) {
+                for path in paths.iter() {
+                    file_explorer.update_node_count(path);
+                }
+            }
+        } else {
+            on_finished();
+        }
+    } else {
+        on_finished();
+    }
+}
+
+struct OpenEditorList {
+    line_height: f64,
+    mouse_pos: Point,
+    in_view_tab_children: HashMap<usize, (Rect, WidgetId)>,
+    mouse_down: Option<(usize, Option<Rect>)>,
+    hover_index: Option<usize>,
+}
+
+impl OpenEditorList {
+    fn new() -> Self {
+        Self {
+            line_height: 25.0,
+            mouse_pos: Point::ZERO,
+            in_view_tab_children: HashMap::new(),
+            mouse_down: None,
+            hover_index: None,
+        }
+    }
+
+    fn paint_editor(
+        &mut self,
+        ctx: &mut PaintCtx,
+        i: usize,
+        data: &LapceTabData,
+        child: &EditorTabChild,
+        active: bool,
+    ) {
+        let size = ctx.size();
+        let mut text = "".to_string();
+        let mut hint = "".to_string();
+        let mut svg = data.config.ui_svg(LapceIcons::FILE);
+        let mut svg_color = Some(
+            data.config
+                .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+        );
+        let mut pristine = true;
+        match child {
+            EditorTabChild::Editor(view_id, _, _) => {
+                let editor_buffer = data.editor_view_content(*view_id);
+                pristine = editor_buffer.doc.buffer().is_pristine();
+
+                if let BufferContent::File(path) = &editor_buffer.editor.content {
+                    (svg, svg_color) = data.config.file_svg(path);
+                    if let Some(file_name) = path.file_name() {
+                        if let Some(s) = file_name.to_str() {
+                            text = s.to_string();
+                        }
+                    }
+                    let mut path = path.to_path_buf();
+                    if let Some(workspace_path) = data.workspace.path.as_ref() {
+                        path = path
+                            .strip_prefix(workspace_path)
+                            .unwrap_or(&path)
+                            .to_path_buf();
+                    }
+                    // TODO: Can be updated to use a disambiguation algorithm.
+                    // For example when opening multiple lib.rs which usually sits
+                    // under src/
+                    hint = path
+                        .parent()
+                        .and_then(|s| s.to_str())
+                        .unwrap_or("")
+                        .to_string();
+                } else if let BufferContent::Scratch(..) =
+                    &editor_buffer.editor.content
+                {
+                    text = editor_buffer.editor.content.file_name().to_string();
+                }
+                if let Some(_compare) = editor_buffer.editor.compare.as_ref() {
+                    text = format!("{text} (Working tree)");
+                }
+            }
+            EditorTabChild::Settings { .. } => {
+                text = "Settings".to_string();
+                hint = format!("ver. {}", *meta::VERSION);
+                svg = data.config.ui_svg(LapceIcons::SETTINGS);
+            }
+            EditorTabChild::Plugin { volt_name, .. } => {
+                text = format!("Plugin: {volt_name}");
+                svg = data.config.ui_svg(LapceIcons::EXTENSIONS);
+            }
+        }
+
+        let font_size = data.config.ui.font_size() as f64;
+
+        let current_item = Size::new(size.width, self.line_height)
+            .to_rect()
+            .with_origin(Point::new(0.0, i as f64 * self.line_height));
+
+        if ctx.is_hot()
+            && i == (self.mouse_pos.y / self.line_height).floor() as usize
+        {
+            ctx.fill(
+                current_item,
+                data.config
+                    .get_color_unchecked(LapceTheme::PANEL_HOVERED_BACKGROUND),
+            );
+        } else if active {
+            ctx.fill(
+                current_item,
+                data.config
+                    .get_color_unchecked(LapceTheme::PANEL_CURRENT_BACKGROUND),
+            );
+        }
+
+        let svg_size = data.config.ui.icon_size() as f64;
+        let close_rect =
+            Size::new(svg_size, svg_size)
+                .to_rect()
+                .with_origin(Point::new(
+                    10.0 + (self.line_height - svg_size) / 2.0,
+                    i as f64 * self.line_height
+                        + (self.line_height - svg_size) / 2.0,
+                ));
+
+        self.in_view_tab_children
+            .insert(i, (close_rect.inflate(2.0, 2.0), child.widget_id()));
+
+        let close_svg = if ctx.is_hot() && current_item.contains(self.mouse_pos) {
+            if close_rect.inflate(2.0, 2.0).contains(self.mouse_pos) {
+                ctx.fill(
+                    close_rect.inflate(2.0, 2.0),
+                    data.config
+                        .get_color_unchecked(LapceTheme::PANEL_CURRENT_BACKGROUND),
+                );
+            }
+            Some(data.config.ui_svg(LapceIcons::CLOSE))
+        } else if pristine {
+            None
+        } else {
+            Some(data.config.ui_svg(LapceIcons::UNSAVED))
+        };
+        if let Some(close_svg) = close_svg {
+            ctx.draw_svg(
+                &close_svg,
+                close_rect,
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+                ),
+            );
+        }
+
+        let svg_rect =
+            Size::new(svg_size, svg_size)
+                .to_rect()
+                .with_origin(Point::new(
+                    10.0 + self.line_height,
+                    i as f64 * self.line_height
+                        + (self.line_height - svg_size) / 2.0,
+                ));
+        ctx.draw_svg(&svg, svg_rect, svg_color);
+
+        if !hint.is_empty() {
+            text = format!("{text} {hint}");
+        }
+        let total_len = text.len();
+        let mut text_layout = ctx
+            .text()
+            .new_text_layout(text)
+            .font(data.config.ui.font_family(), font_size)
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::PANEL_FOREGROUND)
+                    .clone(),
+            );
+        if !hint.is_empty() {
+            text_layout = text_layout.range_attribute(
+                total_len - hint.len()..total_len,
+                TextAttribute::TextColor(
+                    data.config
+                        .get_color_unchecked(LapceTheme::PANEL_FOREGROUND_DIM)
+                        .clone(),
+                ),
+            );
+        }
+        let text_layout = text_layout.build().unwrap();
+        ctx.draw_text(
+            &text_layout,
+            Point::new(
+                svg_rect.x1 + 5.0,
+                i as f64 * self.line_height + text_layout.y_offset(self.line_height),
+            ),
+        );
+    }
+}
+
+impl Widget<LapceTabData> for OpenEditorList {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        _data: &mut LapceTabData,
+        _env: &Env,
+    ) {
+        match event {
+            Event::MouseMove(mouse_event) => {
+                self.mouse_pos = mouse_event.pos;
+                let index = (mouse_event.pos.y / self.line_height).floor() as usize;
+                let hover_index = self.hover_index;
+                if self.in_view_tab_children.contains_key(&index) {
+                    self.hover_index = Some(index);
+                    ctx.set_cursor(&druid::Cursor::Pointer);
+                } else {
+                    self.hover_index = None;
+                    ctx.clear_cursor();
+                }
+                if hover_index != self.hover_index {
+                    ctx.request_paint();
+                }
+            }
+            Event::MouseDown(mouse_event) => {
+                self.mouse_down = None;
+                let index = (mouse_event.pos.y / self.line_height).floor() as usize;
+                if let Some((close_rect, _)) = self.in_view_tab_children.get(&index)
+                {
+                    self.mouse_down = Some((
+                        index,
+                        if close_rect.contains(mouse_event.pos) {
+                            Some(*close_rect)
+                        } else {
+                            None
+                        },
+                    ));
+                }
+            }
+            Event::MouseUp(mouse_event) => {
+                if let Some((down_index, down_close_rect)) = self.mouse_down {
+                    let index =
+                        (mouse_event.pos.y / self.line_height).floor() as usize;
+                    if index == down_index {
+                        if let Some((close_rect, widget_id)) =
+                            self.in_view_tab_children.get(&index)
+                        {
+                            if down_close_rect.is_some()
+                                && close_rect.contains(mouse_event.pos)
+                            {
+                                ctx.submit_command(Command::new(
+                                    LAPCE_COMMAND,
+                                    LapceCommand {
+                                        kind: CommandKind::Focus(
+                                            FocusCommand::SplitClose,
+                                        ),
+                                        data: None,
+                                    },
+                                    Target::Widget(*widget_id),
+                                ));
+                            } else {
+                                ctx.submit_command(Command::new(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::Focus,
+                                    Target::Widget(*widget_id),
+                                ));
+                            }
+                        }
+                    }
+                }
+                self.mouse_down = None;
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        _ctx: &mut LifeCycleCtx,
+        _event: &LifeCycle,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn update(
+        &mut self,
+        _ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn layout(
+        &mut self,
+        _ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        _env: &Env,
+    ) -> Size {
+        let n = data
+            .main_split
+            .editor_tabs
+            .iter()
+            .map(|(_, tab)| tab.children.len())
+            .sum::<usize>();
+
+        // If there are split editor tabs, then we need to consider the group headers
+        let n = if data.main_split.editor_tabs.len() > 1 {
+            n + data.main_split.editor_tabs.len()
+        } else {
+            n
+        };
+        Size::new(bc.max().width, self.line_height * n as f64)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+        self.in_view_tab_children.clear();
+        let rect = ctx.region().bounding_box();
+        let mut i = 0;
+        let mut g = 0;
+
+        for (_, tab) in
+            data.main_split
+                .editor_tabs
+                .iter()
+                .sorted_by(|(_, a), (_, b)| {
+                    let a_rect = a.layout_rect.borrow();
+                    let b_rect = b.layout_rect.borrow();
+
+                    if a_rect.y0 == b_rect.y0 {
+                        a_rect.x0.total_cmp(&b_rect.x0)
+                    } else {
+                        a_rect.y0.total_cmp(&b_rect.y0)
+                    }
+                })
+        {
+            if data.main_split.editor_tabs.len() > 1 {
+                if self.line_height * (i as f64) > rect.y1 {
+                    return;
+                }
+                g += 1;
+                if self.line_height * ((i + 1) as f64) >= rect.y0 {
+                    let text_layout = ctx
+                        .text()
+                        .new_text_layout(format!("Group {g}"))
+                        .font(
+                            data.config.ui.font_family(),
+                            data.config.ui.font_size() as f64,
+                        )
+                        .text_color(
+                            data.config
+                                .get_color_unchecked(LapceTheme::PANEL_FOREGROUND)
+                                .clone(),
+                        )
+                        .build()
+                        .unwrap();
+                    ctx.draw_text(
+                        &text_layout,
+                        Point::new(
+                            10.0,
+                            (i as f64 * self.line_height)
+                                + text_layout.y_offset(self.line_height),
+                        ),
+                    );
+                }
+                i += 1;
+            }
+            for (child_index, child) in tab.children.iter().enumerate() {
+                if self.line_height * ((i + 1) as f64) < rect.y0 {
+                    i += 1;
+                    continue;
+                }
+                if self.line_height * (i as f64) > rect.y1 {
+                    return;
+                }
+                let active = *data.main_split.active_tab == Some(tab.widget_id)
+                    && tab.active == child_index;
+                self.paint_editor(ctx, i, data, child, active);
+                i += 1;
+            }
         }
     }
 }
diff --git a/lapce-ui/src/find.rs b/lapce-ui/src/find.rs
index eccdb3d0bd..5b7ed77aff 100644
--- a/lapce-ui/src/find.rs
+++ b/lapce-ui/src/find.rs
@@ -7,16 +7,17 @@ use druid::{
 use lapce_core::command::FocusCommand;
 use lapce_data::{
     command::{CommandKind, LapceCommand, LAPCE_COMMAND},
-    config::LapceTheme,
+    config::{LapceIcons, LapceTheme},
     data::LapceTabData,
 };
 
-use crate::{editor::view::LapceEditorView, svg::get_svg, tab::LapceIcon};
+use crate::{editor::view::LapceEditorView, tab::LapceIcon};
 
+// Local search widget
 pub struct FindBox {
+    parent_view_id: WidgetId,
     input_width: f64,
     result_width: f64,
-    result_pos: Point,
     input: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
     icons: Vec<LapceIcon>,
     mouse_pos: Point,
@@ -34,7 +35,7 @@ impl FindBox {
             .padding((10.0, 5.0));
         let icons = vec![
             LapceIcon {
-                icon: "arrow-up.svg",
+                icon: LapceIcons::SEARCH_BACKWARD,
                 rect: Rect::ZERO,
                 command: Command::new(
                     LAPCE_COMMAND,
@@ -46,7 +47,7 @@ impl FindBox {
                 ),
             },
             LapceIcon {
-                icon: "arrow-down.svg",
+                icon: LapceIcons::SEARCH_FORWARD,
                 rect: Rect::ZERO,
                 command: Command::new(
                     LAPCE_COMMAND,
@@ -58,7 +59,19 @@ impl FindBox {
                 ),
             },
             LapceIcon {
-                icon: "close.svg",
+                icon: LapceIcons::SEARCH_CASE_SENSITIVE,
+                rect: Rect::ZERO,
+                command: Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Focus(FocusCommand::ToggleCaseSensitive),
+                        data: None,
+                    },
+                    Target::Widget(parent_view_id),
+                ),
+            },
+            LapceIcon {
+                icon: LapceIcons::CLOSE,
                 rect: Rect::ZERO,
                 command: Command::new(
                     LAPCE_COMMAND,
@@ -71,9 +84,9 @@ impl FindBox {
             },
         ];
         Self {
+            parent_view_id,
             input_width: 200.0,
             result_width: 75.0,
-            result_pos: Point::ZERO,
             input: WidgetPod::new(input.boxed()),
             icons,
             mouse_pos: Point::ZERO,
@@ -113,10 +126,8 @@ impl Widget<LapceTabData> for FindBox {
                 self.mouse_pos = mouse_event.pos;
                 if self.icon_hit_test(mouse_event) {
                     ctx.set_cursor(&druid::Cursor::Pointer);
-                    ctx.request_paint();
                 } else {
                     ctx.clear_cursor();
-                    ctx.request_paint();
                 }
             }
             Event::MouseDown(mouse_event) => {
@@ -138,16 +149,18 @@ impl Widget<LapceTabData> for FindBox {
             BoxConstraints::tight(Size::new(self.input_width, bc.max().height));
         let mut input_size = self.input.layout(ctx, &input_bc, data, env);
         self.input.set_origin(ctx, data, env, Point::ZERO);
+        let icons_len = self.icons.len() as f64;
         let height = input_size.height;
-        let mut width = input_size.width + self.result_width + height * 3.0;
+        let mut width = input_size.width + self.result_width + height * icons_len;
 
         if width - 20.0 > bc.max().width {
             let input_bc = BoxConstraints::tight(Size::new(
-                bc.max().width - height * 3.0 - 20.0 - self.result_width,
+                bc.max().width - height * icons_len - 20.0 - self.result_width,
                 bc.max().height,
             ));
             input_size = self.input.layout(ctx, &input_bc, data, env);
-            width = input_size.width + self.result_width + height * 3.0;
+            self.input.set_origin(ctx, data, env, Point::ZERO);
+            width = input_size.width + self.result_width + height * icons_len;
         }
 
         for (i, icon) in self.icons.iter_mut().enumerate() {
@@ -160,11 +173,6 @@ impl Widget<LapceTabData> for FindBox {
                 .inflate(-5.0, -5.0);
         }
 
-        self.result_pos = Point::new(
-            input_size.width,
-            (height - data.config.ui.font_size() as f64) / 2.0,
-        );
-
         Size::new(width, height)
     }
 
@@ -193,20 +201,7 @@ impl Widget<LapceTabData> for FindBox {
             return;
         }
 
-        let buffer = match data
-            .main_split
-            .editor_tabs
-            .get(&data.main_split.active_tab.unwrap())
-            .unwrap()
-            .active_child()
-        {
-            lapce_data::data::EditorTabChild::Editor(view_id, _, _) => {
-                data.editor_view_content(*view_id)
-            }
-            lapce_data::data::EditorTabChild::Settings(view_id, _) => {
-                data.editor_view_content(*view_id)
-            }
-        };
+        let buffer = data.editor_view_content(self.parent_view_id);
 
         let rect = ctx.size().to_rect();
         ctx.with_save(|ctx| {
@@ -274,18 +269,39 @@ impl Widget<LapceTabData> for FindBox {
             .build()
             .unwrap();
 
-        ctx.draw_text(&text_layout, self.result_pos);
+        let input_size = self.input.layout_rect().size();
+        ctx.draw_text(
+            &text_layout,
+            Point::new(input_size.width, text_layout.y_offset(input_size.height)),
+        );
+
+        let case_sensitive = data
+            .main_split
+            .active_editor()
+            .map(|editor| {
+                let editor_data = data.editor_view_content(editor.view_id);
+                editor_data.find.case_sensitive()
+            })
+            .unwrap_or_default();
 
         for icon in self.icons.iter() {
-            if icon.rect.contains(self.mouse_pos) {
+            if icon.icon == LapceIcons::SEARCH_CASE_SENSITIVE && case_sensitive {
                 ctx.fill(
-                    &icon.rect,
+                    icon.rect,
                     data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
+                        .get_color_unchecked(LapceTheme::LAPCE_TAB_ACTIVE_UNDERLINE),
+                );
+            } else if icon.rect.contains(self.mouse_pos) {
+                ctx.fill(
+                    icon.rect,
+                    &data.config.get_hover_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+                    ),
                 );
             }
 
-            let svg = get_svg(icon.icon).unwrap();
+            let svg = data.config.ui_svg(icon.icon);
             ctx.draw_svg(
                 &svg,
                 icon.rect.inflate(-7.0, -7.0),
diff --git a/lapce-ui/src/hover.rs b/lapce-ui/src/hover.rs
index 22f4da30a9..80a166d1ce 100644
--- a/lapce-ui/src/hover.rs
+++ b/lapce-ui/src/hover.rs
@@ -10,6 +10,9 @@ use lapce_data::{
     config::LapceTheme,
     data::LapceTabData,
     hover::{HoverData, HoverStatus},
+    markdown::layout_content::{
+        layout_content_clean_up, layouts_from_contents, LayoutContent,
+    },
     rich_text::RichText,
 };
 
@@ -75,9 +78,17 @@ impl Widget<LapceTabData> for HoverContainer {
         match event {
             Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
                 let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
-                if let LapceUICommand::UpdateHover(request_id, items) = command {
+                if let LapceUICommand::UpdateHover { request_id, items } = command {
+                    // TODO: Should we check whether it has actually changed?
                     let hover = Arc::make_mut(&mut data.hover);
                     hover.receive(*request_id, items.clone());
+
+                    self.hover
+                        .widget_mut()
+                        .inner_mut()
+                        .child_mut()
+                        .update_layouts(ctx, data);
+
                     ctx.request_paint();
                 }
             }
@@ -128,6 +139,7 @@ impl Widget<LapceTabData> for HoverContainer {
             || old_hover.status != hover.status
             || !old_hover.items.same(&hover.items)
         {
+            self.ensure_visible(ctx, data, env);
             ctx.request_layout();
         }
 
@@ -141,11 +153,6 @@ impl Widget<LapceTabData> for HoverContainer {
             ));
         }
 
-        if old_hover.active_item_index != hover.active_item_index {
-            self.ensure_visible(ctx, data, env);
-            ctx.request_paint();
-        }
-
         self.hover.update(ctx, data, env);
     }
 
@@ -161,7 +168,6 @@ impl Widget<LapceTabData> for HoverContainer {
         self.content_size = self.hover.layout(ctx, &bc, data, env);
         *data.hover.content_size.borrow_mut() = self.content_size;
         self.hover.set_origin(ctx, data, env, Point::ZERO);
-        ctx.set_paint_insets((10.0, 10.0, 10.0, 10.0));
         size
     }
 
@@ -190,7 +196,7 @@ impl Widget<LapceTabData> for HoverContainer {
 
 #[derive(Default)]
 struct Hover {
-    active_layout: TextLayout<RichText>,
+    active_layout: Vec<LayoutContent>,
     active_diagnostic_layout: TextLayout<RichText>,
 }
 
@@ -200,11 +206,7 @@ impl Hover {
 
     fn new() -> Self {
         Hover {
-            active_layout: {
-                let mut layout = TextLayout::new();
-                layout.set_text(RichText::new(ArcStr::from("")));
-                layout
-            },
+            active_layout: { Vec::new() },
             active_diagnostic_layout: {
                 let mut layout = TextLayout::new();
                 layout.set_text(RichText::new(ArcStr::from("")));
@@ -212,6 +214,38 @@ impl Hover {
             },
         }
     }
+
+    fn update_layouts(&mut self, ctx: &mut EventCtx, data: &mut LapceTabData) {
+        let items = data.hover.items.clone();
+
+        layout_content_clean_up(&mut self.active_layout, data);
+        self.active_layout = layouts_from_contents(ctx, data, items.iter());
+
+        if let Some(diagnostic_content) = &data.hover.diagnostic_content {
+            self.active_diagnostic_layout
+                .set_text(diagnostic_content.clone());
+        } else {
+            self.active_diagnostic_layout
+                .set_text(RichText::new(ArcStr::from("")));
+        }
+
+        let font = FontDescriptor::new(data.config.ui.hover_font_family())
+            .with_size(data.config.ui.hover_font_size() as f64);
+        let text_color = data
+            .config
+            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+            .clone();
+
+        for layout in self.active_layout.iter_mut() {
+            layout.set_font(font.clone());
+            layout.set_text_color(text_color.clone());
+        }
+
+        self.active_diagnostic_layout.set_font(font);
+        self.active_diagnostic_layout.set_text_color(text_color);
+
+        ctx.request_layout();
+    }
 }
 impl Widget<LapceTabData> for Hover {
     fn event(
@@ -237,58 +271,11 @@ impl Widget<LapceTabData> for Hover {
 
     fn update(
         &mut self,
-        ctx: &mut UpdateCtx,
-        old_data: &LapceTabData,
-        data: &LapceTabData,
+        _ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        _data: &LapceTabData,
         _env: &Env,
     ) {
-        // If the active item has changed or we've switched our current item existence status
-        // or we've gotten new diagnostic text
-        // then update the layout
-        if old_data.hover.request_id != data.hover.request_id
-            || old_data.hover.active_item_index != data.hover.active_item_index
-            || old_data.hover.get_current_item().is_some()
-                != data.hover.get_current_item().is_some()
-            || !old_data
-                .hover
-                .diagnostic_content
-                .same(&data.hover.diagnostic_content)
-        {
-            if let Some(item) = data.hover.get_current_item() {
-                self.active_layout.set_text(item.clone());
-            } else {
-                self.active_layout.set_text(RichText::new(ArcStr::from("")));
-            }
-
-            if let Some(diagnostic_content) = &data.hover.diagnostic_content {
-                self.active_diagnostic_layout
-                    .set_text(diagnostic_content.clone());
-            } else {
-                self.active_diagnostic_layout
-                    .set_text(RichText::new(ArcStr::from("")));
-            }
-
-            let font = FontDescriptor::new(data.config.ui.font_family())
-                .with_size(data.config.ui.font_size() as f64);
-            let text_color = data
-                .config
-                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                .clone();
-
-            self.active_layout.set_font(font.clone());
-            self.active_layout.set_text_color(text_color.clone());
-
-            self.active_diagnostic_layout.set_font(font);
-            self.active_diagnostic_layout.set_text_color(text_color);
-
-            if self.active_layout.needs_rebuild_after_update(ctx)
-                || self
-                    .active_diagnostic_layout
-                    .needs_rebuild_after_update(ctx)
-            {
-                ctx.request_layout();
-            }
-        }
     }
 
     fn layout(
@@ -304,31 +291,61 @@ impl Widget<LapceTabData> for Hover {
             - env.get(theme::SCROLLBAR_WIDTH)
             - env.get(theme::SCROLLBAR_PAD);
 
-        self.active_layout.set_wrap_width(max_width);
-        self.active_layout.rebuild_if_needed(ctx.text(), env);
+        let mut max_layout_width = 0.0;
+        for layout in self.active_layout.iter_mut() {
+            layout.set_max_width(&data.images, max_width);
+            layout.rebuild_if_needed(ctx.text(), env);
+            let layout_width = layout.size(&data.images, &data.config).width;
+            if layout_width > max_layout_width {
+                max_layout_width = layout_width;
+            }
+        }
 
         self.active_diagnostic_layout.set_wrap_width(max_width);
         self.active_diagnostic_layout
             .rebuild_if_needed(ctx.text(), env);
 
-        let text_metrics = self.active_layout.layout_metrics();
-        ctx.set_baseline_offset(
-            text_metrics.size.height - text_metrics.first_baseline,
-        );
+        let items_height = if self.active_layout.is_empty() {
+            0.0
+        } else {
+            let mut height = 0.0;
+            for layout in self.active_layout.iter() {
+                height += layout.size(&data.images, &data.config).height;
+            }
 
-        let diagnostic_height = if self.active_diagnostic_layout.size().is_empty() {
+            if self.active_layout.len() > 1 {
+                let line_height = data.config.editor.line_height() as f64;
+                height += (self.active_layout.len() - 1) as f64 * line_height
+            }
+            height
+        };
+
+        let diagnostic_size = self.active_diagnostic_layout.size();
+        let diagnostic_height = if diagnostic_size.is_empty() {
             0.0
         } else {
             let diagnostic_text_metrics =
                 self.active_diagnostic_layout.layout_metrics();
 
-            diagnostic_text_metrics.size.height
-                + data.config.editor.line_height as f64
+            diagnostic_text_metrics.size.height + Hover::STARTING_Y * 3.0
+        };
+
+        if diagnostic_size.width > max_layout_width {
+            max_layout_width = diagnostic_size.width;
+        }
+
+        let width = if max_layout_width < max_width {
+            max_layout_width
+                + Hover::STARTING_X
+                + env.get(theme::SCROLLBAR_WIDTH)
+                + env.get(theme::SCROLLBAR_PAD)
+        } else {
+            width
         };
 
         Size::new(
             width,
-            text_metrics.size.height + diagnostic_height + Hover::STARTING_Y * 2.0,
+            items_height + diagnostic_height + Hover::STARTING_Y * 2.0,
         )
     }
 
@@ -337,6 +354,9 @@ impl Widget<LapceTabData> for Hover {
             return;
         }
 
+        let side_margin =
+            env.get(theme::SCROLLBAR_WIDTH) + env.get(theme::SCROLLBAR_PAD);
+
         let rect = ctx.region().bounding_box();
         let diagnostic_origin = Point::new(Self::STARTING_X, Self::STARTING_Y);
 
@@ -350,37 +370,42 @@ impl Widget<LapceTabData> for Hover {
         let height = if self.active_diagnostic_layout.size().is_empty() {
             0.0
         } else {
-            // let text_metrics = self.active_layout.layout_metrics();
             let diagnostic_text_metrics =
                 self.active_diagnostic_layout.layout_metrics();
 
-            let side_margin =
-                env.get(theme::SCROLLBAR_WIDTH) + env.get(theme::SCROLLBAR_PAD);
-            let line_height = data.config.editor.line_height as f64;
-
-            // Create a separating line
             let line = {
                 let x0 = rect.x0 + side_margin;
-                let y = diagnostic_text_metrics.size.height + line_height;
+                let y =
+                    diagnostic_text_metrics.size.height + Hover::STARTING_Y * 3.0;
                 let x1 = rect.x1 - side_margin;
                 Line::new(Point::new(x0, y), Point::new(x1, y))
             };
 
-            // Draw the separator
             ctx.stroke(
                 line,
                 data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
                 1.0,
             );
 
-            // Draw the diagnostic text
             self.active_diagnostic_layout.draw(ctx, diagnostic_origin);
 
-            diagnostic_text_metrics.size.height + line_height
+            diagnostic_text_metrics.size.height + Hover::STARTING_Y * 3.0
         };
 
         let doc_origin = diagnostic_origin + (0.0, height);
 
-        self.active_layout.draw(ctx, doc_origin);
+        let mut start_height = 0.0;
+
+        for layout in self.active_layout.iter_mut() {
+            layout.draw(
+                ctx,
+                &data.images,
+                &data.config,
+                doc_origin + (0.0, start_height),
+            );
+
+            let layout_size = layout.size(&data.images, &data.config);
+            start_height += layout_size.height;
+        }
     }
 }
diff --git a/lapce-ui/src/ime.rs b/lapce-ui/src/ime.rs
new file mode 100644
index 0000000000..aa75390976
--- /dev/null
+++ b/lapce-ui/src/ime.rs
@@ -0,0 +1,223 @@
+use std::{
+    cell::{Cell, Ref, RefCell, RefMut},
+    ops::Range,
+    sync::{Arc, Weak},
+};
+
+use druid::{
+    piet::HitTestPoint,
+    text::{EditableText, ImeHandlerRef, InputHandler, Selection},
+    Point, Rect,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum ImeLock {
+    None,
+    ReadWrite,
+    Read,
+}
+
+pub struct ImeComponent {
+    ime_session: Arc<RefCell<ImeSession>>,
+    lock: Arc<Cell<ImeLock>>,
+}
+
+impl Default for ImeComponent {
+    fn default() -> Self {
+        let session = ImeSession {
+            is_active: false,
+            composition_range: None,
+            text: "".to_string(),
+            input_text: None,
+            orgin: Point::ZERO,
+            shift: 0,
+        };
+        ImeComponent {
+            ime_session: Arc::new(RefCell::new(session)),
+            lock: Arc::new(Cell::new(ImeLock::None)),
+        }
+    }
+}
+
+impl ImeComponent {
+    pub fn ime_handler(&self) -> impl ImeHandlerRef {
+        ImeSessionRef {
+            inner: Arc::downgrade(&self.ime_session),
+            lock: self.lock.clone(),
+        }
+    }
+
+    /// Returns `true` if the inner [`ImeSession`] can be read.
+    pub fn can_read(&self) -> bool {
+        self.lock.get() != ImeLock::ReadWrite
+    }
+
+    pub fn borrow(&self) -> Ref<'_, ImeSession> {
+        self.ime_session.borrow()
+    }
+
+    pub fn borrow_mut(&self) -> RefMut<'_, ImeSession> {
+        self.ime_session.borrow_mut()
+    }
+
+    pub fn set_origin(&self, origin: Point) {
+        self.ime_session.borrow_mut().orgin = origin;
+    }
+
+    pub fn set_active(&mut self, active: bool) {
+        self.ime_session.borrow_mut().is_active = active;
+    }
+
+    pub fn clear_text(&self) {
+        self.ime_session.borrow_mut().text.clear();
+    }
+
+    pub fn get_input_text(&self) -> Option<String> {
+        self.ime_session.borrow_mut().input_text.take()
+    }
+
+    pub fn get_shift(&self) -> usize {
+        self.ime_session.borrow().shift
+    }
+
+    /// Returns `true` if the IME is actively composing (or the text is locked.)
+    pub fn is_composing(&self) -> bool {
+        self.can_read() && self.borrow().composition_range.is_some()
+    }
+}
+
+impl ImeHandlerRef for ImeSessionRef {
+    fn is_alive(&self) -> bool {
+        Weak::strong_count(&self.inner) > 0
+    }
+
+    fn acquire(
+        &self,
+        mutable: bool,
+    ) -> Option<Box<dyn druid::text::InputHandler + 'static>> {
+        let lock = if mutable {
+            ImeLock::ReadWrite
+        } else {
+            ImeLock::Read
+        };
+        self.lock.replace(lock);
+        Weak::upgrade(&self.inner)
+            .map(ImeSessionHandle::new)
+            .map(|doc| Box::new(doc) as Box<dyn InputHandler>)
+    }
+
+    fn release(&self) -> bool {
+        self.lock.replace(ImeLock::None) == ImeLock::ReadWrite
+    }
+}
+
+struct ImeSessionRef {
+    inner: Weak<RefCell<ImeSession>>,
+    lock: Arc<Cell<ImeLock>>,
+}
+
+pub struct ImeSession {
+    is_active: bool,
+    /// The portion of the text that is currently marked by the IME.
+    composition_range: Option<Range<usize>>,
+    text: String,
+    input_text: Option<String>,
+    shift: usize,
+    orgin: Point,
+}
+
+impl ImeSession {
+    pub fn text(&self) -> &str {
+        &self.text
+    }
+}
+
+struct ImeSessionHandle {
+    inner: Arc<RefCell<ImeSession>>,
+    selection: Selection,
+    text: String,
+}
+
+impl ImeSessionHandle {
+    fn new(inner: Arc<RefCell<ImeSession>>) -> Self {
+        let text = inner.borrow().text.clone();
+        ImeSessionHandle {
+            inner,
+            text,
+            selection: Selection::default(),
+        }
+    }
+}
+
+impl InputHandler for ImeSessionHandle {
+    fn selection(&self) -> Selection {
+        self.selection
+    }
+
+    fn set_selection(&mut self, selection: Selection) {
+        self.selection = selection;
+        self.inner.borrow_mut().shift = selection.active;
+    }
+
+    fn composition_range(&self) -> Option<std::ops::Range<usize>> {
+        self.inner.borrow().composition_range.clone()
+    }
+
+    fn set_composition_range(&mut self, range: Option<std::ops::Range<usize>>) {
+        if range.is_none() {
+            self.inner.borrow_mut().text.clear();
+            self.text.clear();
+        }
+        self.inner.borrow_mut().composition_range = range;
+    }
+
+    fn is_char_boundary(&self, i: usize) -> bool {
+        self.text.cursor(i).is_some()
+    }
+
+    fn len(&self) -> usize {
+        self.text.len()
+    }
+
+    fn slice(&self, range: std::ops::Range<usize>) -> std::borrow::Cow<str> {
+        self.text.slice(range).unwrap()
+    }
+
+    fn insert_text(&mut self, text: &str) {
+        if self.composition_range().is_some() {
+            self.inner.borrow_mut().input_text = Some(text.to_string());
+        }
+        self.replace_range(0..0, "");
+    }
+
+    fn is_active(&self) -> bool {
+        self.inner.borrow().is_active
+    }
+
+    fn replace_range(&mut self, _range: Range<usize>, text: &str) {
+        self.inner.borrow_mut().text = text.to_string();
+        self.text = self.inner.borrow().text.clone();
+    }
+
+    fn hit_test_point(&self, _point: Point) -> HitTestPoint {
+        HitTestPoint::default()
+    }
+
+    fn line_range(
+        &self,
+        _index: usize,
+        _affinity: druid::text::Affinity,
+    ) -> std::ops::Range<usize> {
+        0..self.len()
+    }
+
+    fn bounding_box(&self) -> Option<Rect> {
+        None
+    }
+
+    fn slice_bounding_box(&self, _range: std::ops::Range<usize>) -> Option<Rect> {
+        Some(Rect::ZERO.with_origin(self.inner.borrow().orgin))
+    }
+
+    fn handle_action(&mut self, _action: druid::text::TextAction) {}
+}
diff --git a/lapce-ui/src/keymap.rs b/lapce-ui/src/keymap.rs
index d8884b840a..f7fa6613eb 100644
--- a/lapce-ui/src/keymap.rs
+++ b/lapce-ui/src/keymap.rs
@@ -28,9 +28,9 @@ pub struct LapceKeymap {
 }
 
 impl LapceKeymap {
-    pub fn new_split(data: &LapceTabData) -> LapceSplit {
+    pub fn new_split(keymap_input_view_id: WidgetId) -> LapceSplit {
         let keymap = Self {
-            widget_id: data.settings.keymap_widget_id,
+            widget_id: WidgetId::next(),
             active_keymap: None,
             line_height: 35.0,
             keymap_confirm: Rect::ZERO,
@@ -38,38 +38,50 @@ impl LapceKeymap {
         };
         let keymap = LapceScroll::new(keymap);
 
-        let input = LapceEditorView::new(
-            data.settings.keymap_view_id,
-            WidgetId::next(),
-            None,
-        )
-        .hide_header()
-        .hide_gutter()
-        .padding((15.0, 15.0));
+        let input =
+            LapceEditorView::new(keymap_input_view_id, WidgetId::next(), None)
+                .hide_header()
+                .hide_gutter()
+                .padding((15.0, 15.0));
         let header = LapceKeymapHeader::new();
-        let split = LapceSplit::new(data.settings.keymap_split_id)
+        let split = LapceSplit::new(WidgetId::next())
             .horizontal()
             .with_child(input.boxed(), None, 100.0)
             .with_child(header.boxed(), None, 100.0)
-            .with_flex_child(keymap.boxed(), None, 1.0);
+            .with_flex_child(keymap.boxed(), None, 1.0, false);
 
         split
     }
 
-    fn mouse_down(&mut self, ctx: &mut EventCtx, pos: Point, data: &LapceTabData) {
-        if let Some((keymap, keys)) = self.active_keymap.as_ref() {
-            if self.keymap_confirm.contains(pos) {
-                ctx.submit_command(Command::new(
-                    LAPCE_UI_COMMAND,
-                    LapceUICommand::UpdateKeymap(keymap.clone(), keys.clone()),
-                    Target::Widget(data.id),
-                ));
-                self.active_keymap = None;
-                return;
-            }
-            if self.keymap_cancel.contains(pos) {
-                self.active_keymap = None;
-                return;
+    fn mouse_down(
+        &mut self,
+        ctx: &mut EventCtx,
+        ev: &druid::MouseEvent,
+        data: &LapceTabData,
+    ) {
+        use druid::MouseButton as Btn;
+
+        if let Some((keymap, keys)) = self.active_keymap.as_mut() {
+            match ev.button {
+                Btn::Left if self.keymap_confirm.contains(ev.pos) => {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::UpdateKeymap(keymap.clone(), keys.clone()),
+                        Target::Widget(data.id),
+                    ));
+                    self.active_keymap = None;
+                }
+                Btn::Left if self.keymap_cancel.contains(ev.pos) => {
+                    self.active_keymap = None;
+                }
+                _other => {
+                    if keys.len() == 2 {
+                        keys.clear();
+                    }
+                    keys.push(KeyPress::mouse(ev));
+                    ctx.request_paint();
+                    ctx.set_handled();
+                }
             }
             return;
         }
@@ -85,7 +97,7 @@ impl LapceKeymap {
             &data.keypress.filtered_commands_without_keymap
         };
 
-        let i = (pos.y / self.line_height).floor() as usize;
+        let i = (ev.pos.y / self.line_height).floor() as usize;
         if i < commands_with_keymap.len() {
             let keymap = commands_with_keymap[i].clone();
             self.active_keymap = Some((keymap, Vec::new()));
@@ -106,7 +118,7 @@ impl LapceKeymap {
     }
 
     fn request_focus(&self, ctx: &mut EventCtx, data: &mut LapceTabData) {
-        data.focus = self.widget_id;
+        data.focus = Arc::new(self.widget_id);
         ctx.request_focus();
     }
 }
@@ -136,7 +148,7 @@ impl Widget<LapceTabData> for LapceKeymap {
             Event::MouseDown(mouse_event) => {
                 ctx.set_handled();
                 self.request_focus(ctx, data);
-                self.mouse_down(ctx, mouse_event.pos, data);
+                self.mouse_down(ctx, mouse_event, data);
                 ctx.request_paint();
             }
             Event::KeyDown(key_event) => {
@@ -274,9 +286,17 @@ impl Widget<LapceTabData> for LapceKeymap {
                         ));
                         let text_layout = ctx
                             .text()
-                            .new_text_layout(
-                                cmd.kind.desc().unwrap_or_else(|| cmd.kind.str()),
-                            )
+                            .new_text_layout(match cmd.kind.desc() {
+                                Some(desc) => desc.to_string(),
+                                None => {
+                                    let mut formatted =
+                                        cmd.kind.str().replace('_', " ");
+                                    format!(
+                                        "{}{formatted}",
+                                        formatted.remove(0).to_uppercase()
+                                    )
+                                }
+                            })
                             .font(
                                 data.config.ui.font_family(),
                                 data.config.ui.font_size() as f64,
@@ -290,13 +310,12 @@ impl Widget<LapceTabData> for LapceKeymap {
                             )
                             .build()
                             .unwrap();
-                        let text_size = text_layout.size();
                         ctx.draw_text(
                             &text_layout,
                             Point::new(
                                 10.0,
                                 i as f64 * self.line_height
-                                    + (self.line_height - text_size.height) / 2.0,
+                                    + text_layout.y_offset(self.line_height),
                             ),
                         );
                     });
@@ -323,24 +342,23 @@ impl Widget<LapceTabData> for LapceKeymap {
                         )
                         .build()
                         .unwrap();
-                    let text_size = text_layout.size();
                     ctx.draw_text(
                         &text_layout,
                         Point::new(
                             size.width / 2.0
                                 + 10.0
-                                + if data.config.lapce.modal {
+                                + if data.config.core.modal {
                                     keypress_width
                                 } else {
                                     0.0
                                 },
                             i as f64 * self.line_height
-                                + (self.line_height - text_size.height) / 2.0,
+                                + text_layout.y_offset(self.line_height),
                         ),
                     )
                 }
 
-                if data.config.lapce.modal && !keymap.modes.is_empty() {
+                if data.config.core.modal && !keymap.modes.is_empty() {
                     let mut origin = Point::new(
                         size.width / 2.0 + 10.0,
                         i as f64 * self.line_height + self.line_height / 2.0,
@@ -378,12 +396,17 @@ impl Widget<LapceTabData> for LapceKeymap {
                         ));
                         let text_layout = ctx
                             .text()
-                            .new_text_layout(
-                                command
-                                    .kind
-                                    .desc()
-                                    .unwrap_or_else(|| command.kind.str()),
-                            )
+                            .new_text_layout(match command.kind.desc() {
+                                Some(desc) => desc.to_string(),
+                                None => {
+                                    let mut formatted =
+                                        command.kind.str().replace('_', " ");
+                                    format!(
+                                        "{}{formatted}",
+                                        formatted.remove(0).to_uppercase()
+                                    )
+                                }
+                            })
                             .font(
                                 data.config.ui.font_family(),
                                 data.config.ui.font_size() as f64,
@@ -423,7 +446,7 @@ impl Widget<LapceTabData> for LapceKeymap {
             data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
             1.0,
         );
-        if data.config.lapce.modal {
+        if data.config.core.modal {
             let x = size.width / 2.0 + keypress_width;
             ctx.stroke(
                 Line::new(Point::new(x, 0.0), Point::new(x, size.height)),
@@ -716,7 +739,7 @@ impl Widget<LapceTabData> for LapceKeymapHeader {
             Point::new(
                 size.width / 2.0
                     + 10.0
-                    + if data.config.lapce.modal {
+                    + if data.config.core.modal {
                         keypress_width
                     } else {
                         0.0
@@ -725,7 +748,7 @@ impl Widget<LapceTabData> for LapceKeymapHeader {
             ),
         );
 
-        if data.config.lapce.modal {
+        if data.config.core.modal {
             let text_layout = ctx
                 .text()
                 .new_text_layout("Modes")
@@ -763,7 +786,7 @@ impl Widget<LapceTabData> for LapceKeymapHeader {
             data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
             1.0,
         );
-        if data.config.lapce.modal {
+        if data.config.core.modal {
             let x = size.width / 2.0 + keypress_width;
             ctx.stroke(
                 Line::new(Point::new(x, 0.0), Point::new(x, size.height)),
diff --git a/lapce-ui/src/lib.rs b/lapce-ui/src/lib.rs
index ac383dfb4f..9b13749e19 100644
--- a/lapce-ui/src/lib.rs
+++ b/lapce-ui/src/lib.rs
@@ -1,13 +1,21 @@
-pub mod activity;
+#![allow(clippy::manual_clamp)]
+
+pub mod about;
 pub mod alert;
 pub mod app;
+pub mod button;
 pub mod completion;
+pub mod diff;
+pub mod dropdown;
 pub mod editor;
 pub mod explorer;
 pub mod find;
 pub mod hover;
+pub mod ime;
 pub mod keymap;
+pub mod list;
 mod logging;
+pub mod message;
 pub mod palette;
 pub mod panel;
 pub mod picker;
@@ -16,10 +24,11 @@ pub mod problem;
 pub mod scroll;
 pub mod search;
 pub mod settings;
+pub mod signature;
 pub mod source_control;
 pub mod split;
 pub mod status;
-mod svg;
+pub mod svg;
 mod tab;
 pub mod terminal;
 pub mod title;
diff --git a/lapce-ui/src/list.rs b/lapce-ui/src/list.rs
new file mode 100644
index 0000000000..d767728b24
--- /dev/null
+++ b/lapce-ui/src/list.rs
@@ -0,0 +1,340 @@
+use std::marker::PhantomData;
+
+use druid::{
+    piet::{Text, TextLayoutBuilder},
+    BoxConstraints, Command, Data, Env, Event, EventCtx, LayoutCtx, LifeCycle,
+    LifeCycleCtx, PaintCtx, Point, Rect, RenderContext, Size, Target, UpdateCtx,
+    Widget, WidgetId, WidgetPod,
+};
+use lapce_data::{
+    command::{LapceUICommand, LAPCE_UI_COMMAND},
+    config::LapceTheme,
+    list::ListData,
+};
+
+use crate::scroll::{LapceIdentityWrapper, LapceScroll};
+
+// TODO: Support optional multi-select
+
+/// Contains a list of choices of type `T`  
+/// The type must be cloneable, list-paintable, and able to be compared.  
+/// `D` is associated data that users of `List` may need, since the painting is only given
+/// `&ListData<T, D>` for use.  
+///  
+/// We let the `KeyPressFocus` be handled by the containing widget, since widgets like palette
+/// want focus for themselves. You can call `ListData::run_command` to use its sensible
+/// defaults for movement and the like.  
+pub struct List<T: Clone + ListPaint<D> + PartialEq + 'static, D: Data> {
+    content_rect: Rect,
+    scroll_id: WidgetId,
+    // I don't see a way to break this apart that doesn't make it less clear
+    #[allow(clippy::type_complexity)]
+    content: WidgetPod<
+        ListData<T, D>,
+        LapceIdentityWrapper<LapceScroll<ListData<T, D>, ListContent<T, D>>>,
+    >,
+}
+impl<T: Clone + ListPaint<D> + PartialEq + 'static, D: Data> List<T, D> {
+    pub fn new(scroll_id: WidgetId) -> List<T, D> {
+        let content = LapceIdentityWrapper::wrap(
+            LapceScroll::new(ListContent::new()).vertical(),
+            scroll_id,
+        );
+        List {
+            content_rect: Rect::ZERO,
+            scroll_id,
+            content: WidgetPod::new(content),
+        }
+    }
+
+    pub fn scroll_to(&mut self, point: Point) -> bool {
+        self.content.widget_mut().inner_mut().scroll_to(point)
+    }
+
+    pub fn scroll_to_visible(&mut self, rect: Rect, env: &Env) -> bool {
+        self.content
+            .widget_mut()
+            .inner_mut()
+            .scroll_to_visible(rect, env)
+    }
+
+    pub fn ensure_item_visible(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        data: &ListData<T, D>,
+        env: &Env,
+    ) {
+        let width = ctx.size().width;
+        let line_height = data.line_height() as f64;
+
+        let rect = Size::new(width, line_height)
+            .to_rect()
+            .with_origin(Point::new(0.0, data.selected_index as f64 * line_height));
+        if self.scroll_to_visible(rect, env) {
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::ResetFade,
+                Target::Widget(self.scroll_id),
+            ));
+        }
+    }
+}
+impl<T: Clone + ListPaint<D> + PartialEq + 'static, D: Data> Widget<ListData<T, D>>
+    for List<T, D>
+{
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut ListData<T, D>,
+        env: &Env,
+    ) {
+        self.content.event(ctx, event, data, env);
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &ListData<T, D>,
+        env: &Env,
+    ) {
+        self.content.lifecycle(ctx, event, data, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &ListData<T, D>,
+        data: &ListData<T, D>,
+        env: &Env,
+    ) {
+        if !data.same(old_data) {
+            self.ensure_item_visible(ctx, data, env);
+            ctx.request_paint();
+        }
+
+        self.content.update(ctx, data, env);
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &ListData<T, D>,
+        env: &Env,
+    ) -> Size {
+        // TODO: Allow restricting the max height? Technically that can just be done by restricting the
+        // maximum number of displayed items
+
+        // The width are given by whatever widget contains the list
+        let width = bc.max().width;
+
+        let line_height = data.line_height() as f64;
+
+        let count = data.max_display_count();
+        // The height of the rendered entries
+        let height = count as f64 * line_height;
+
+        // TODO: Have an option to let us fill the rest of the space with empty background
+        // Since some lists may want to take up all the space they're given
+
+        // Create a bc which only contains the list we're actually rendering
+        let bc = BoxConstraints::tight(Size::new(width, height));
+
+        let content_size = self.content.layout(ctx, &bc, data, env);
+        self.content.set_origin(ctx, data, env, Point::ZERO);
+        let content_height = content_size.height;
+
+        let self_size = Size::new(content_size.width, content_height);
+
+        self.content_rect = self_size.to_rect().with_origin(Point::ZERO);
+
+        self_size
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &ListData<T, D>, env: &Env) {
+        // TODO: We could have the user of this provide a custom color
+        // Or we could say that they have to fill it? Since something like
+        // palette also wants to draw their background behind the other bits
+        // and so, if we painted here, we'd double-paint
+        // which would be annoying for transparent colors.
+        // ctx.fill(
+        //     rect,
+        //     data.config
+        //         .get_color_unchecked(LapceTheme::PALETTE_BACKGROUND),
+        // );
+
+        self.content.paint(ctx, data, env);
+    }
+}
+
+/// The actual list of entries
+struct ListContent<T: Clone + ListPaint<D> + 'static, D: Data> {
+    /// The line the mouse was last down upon
+    mouse_down: usize,
+    _marker: PhantomData<(*const T, *const D)>,
+}
+impl<T: Clone + ListPaint<D> + 'static, D: Data> ListContent<T, D> {
+    pub fn new() -> ListContent<T, D> {
+        ListContent {
+            mouse_down: 0,
+            _marker: PhantomData,
+        }
+    }
+}
+impl<T: Clone + ListPaint<D> + 'static, D: Data> Widget<ListData<T, D>>
+    for ListContent<T, D>
+{
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut ListData<T, D>,
+        _env: &Env,
+    ) {
+        match event {
+            Event::MouseMove(_) => {
+                ctx.set_cursor(&druid::Cursor::Pointer);
+                ctx.set_handled();
+            }
+            Event::MouseDown(mouse_event) => {
+                let line =
+                    (mouse_event.pos.y / data.line_height() as f64).floor() as usize;
+                self.mouse_down = line;
+                ctx.set_handled();
+            }
+            Event::MouseUp(mouse_event) => {
+                // TODO: function for translating mouse pos to the line, so that we don't repeat
+                // this calculation; which makes it harder to change later
+                let line =
+                    (mouse_event.pos.y / data.line_height() as f64).floor() as usize;
+                if line == self.mouse_down {
+                    data.selected_index = line;
+                    data.select(ctx);
+                    ctx.set_handled();
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        _ctx: &mut LifeCycleCtx,
+        _event: &LifeCycle,
+        _data: &ListData<T, D>,
+        _env: &Env,
+    ) {
+    }
+
+    fn update(
+        &mut self,
+        _ctx: &mut UpdateCtx,
+        _old_data: &ListData<T, D>,
+        _data: &ListData<T, D>,
+        _env: &Env,
+    ) {
+    }
+
+    fn layout(
+        &mut self,
+        _ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &ListData<T, D>,
+        _env: &Env,
+    ) -> Size {
+        let line_height = data.line_height() as f64;
+        // We include the total number of items because we should be in a scroll widget
+        // and that needs the overall height, not just the rendered height.
+        let height = line_height * data.items.len() as f64;
+
+        Size::new(bc.max().width, height)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &ListData<T, D>, env: &Env) {
+        let rect = ctx.region().bounding_box();
+        let size = ctx.size();
+
+        let line_height = data.line_height() as f64;
+
+        let start_line = (rect.y0 / line_height).floor() as usize;
+        let end_line = (rect.y1 / line_height).ceil() as usize;
+        let count = end_line - start_line;
+
+        // Get the items, skip over all items before the start line, and
+        // ignore all items after the end line
+        for (line, item) in
+            data.items.iter().enumerate().skip(start_line).take(count)
+        {
+            if line == data.selected_index {
+                // Create a rect covering the entry at the selected index
+                let bg_rect = Rect::ZERO
+                    .with_origin(Point::new(0.0, line as f64 * line_height))
+                    .with_size(Size::new(size.width, line_height));
+
+                // TODO: Give this its own theme name entry
+                ctx.fill(
+                    bg_rect,
+                    data.config
+                        .get_color_unchecked(LapceTheme::PALETTE_CURRENT_BACKGROUND),
+                );
+            }
+
+            item.paint(ctx, data, env, line);
+        }
+    }
+}
+
+/// A trait for painting relatively simple elements that are put in a list  
+/// They don't get a say in their layout or custom handling of events  
+///  
+/// Takes an immutable reference, due to `data` containing this entry
+pub trait ListPaint<D: Data>: Sized + Clone {
+    fn paint(
+        &self,
+        ctx: &mut PaintCtx,
+        data: &ListData<Self, D>,
+        env: &Env,
+        line: usize,
+    );
+}
+
+// A simple implementation of ListPaint for entries which are just strings
+impl<D: Data> ListPaint<D> for String {
+    fn paint(
+        &self,
+        ctx: &mut PaintCtx,
+        data: &ListData<Self, D>,
+        _env: &Env,
+        line: usize,
+    ) {
+        let line_height = data.line_height() as f64;
+        let text_layout = ctx
+            .text()
+            .new_text_layout(self.clone())
+            .font(
+                data.config.ui.font_family(),
+                data.config.ui.font_size() as f64,
+            )
+            .text_color(
+                data.config
+                    .get_color_unchecked(if line == data.selected_index {
+                        LapceTheme::PALETTE_CURRENT_FOREGROUND
+                    } else {
+                        LapceTheme::PALETTE_FOREGROUND
+                    })
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+
+        // The point for the baseline of the text
+        // This is shifted to the right a bit to provide some minor padding
+        let point = Point::new(
+            5.0,
+            line_height * line as f64 + text_layout.y_offset(line_height),
+        );
+        ctx.draw_text(&text_layout, point);
+    }
+}
diff --git a/lapce-ui/src/message.rs b/lapce-ui/src/message.rs
new file mode 100644
index 0000000000..5c901e629d
--- /dev/null
+++ b/lapce-ui/src/message.rs
@@ -0,0 +1,402 @@
+use druid::{
+    piet::{
+        PietText, PietTextLayout, Text, TextAttribute, TextLayout, TextLayoutBuilder,
+    },
+    BoxConstraints, Command, Env, Event, EventCtx, FontWeight, LayoutCtx, LifeCycle,
+    LifeCycleCtx, PaintCtx, Point, Rect, RenderContext, Size, Target, UpdateCtx,
+    Widget, WidgetId, WidgetPod,
+};
+use lapce_data::{
+    command::{LapceUICommand, LAPCE_UI_COMMAND},
+    config::{LapceConfig, LapceIcons, LapceTheme},
+    data::LapceTabData,
+};
+use lsp_types::MessageType;
+
+pub struct LapceMessage {
+    widget_id: WidgetId,
+    items: Vec<WidgetPod<LapceTabData, LapceMessageItem>>,
+}
+
+impl LapceMessage {
+    pub fn new(widget_id: WidgetId) -> Self {
+        Self {
+            widget_id,
+            items: Vec::new(),
+        }
+    }
+
+    pub fn has_items(&self) -> bool {
+        !self.items.is_empty()
+    }
+}
+
+impl Widget<LapceTabData> for LapceMessage {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.widget_id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        match event {
+            Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
+                let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
+                match command {
+                    LapceUICommand::NewMessage {
+                        kind,
+                        title,
+                        message,
+                    } => {
+                        ctx.set_handled();
+                        let item = LapceMessageItem::new(
+                            self.widget_id,
+                            ctx.text(),
+                            *kind,
+                            title.clone(),
+                            message.clone(),
+                            &data.config,
+                        );
+                        self.items.push(WidgetPod::new(item));
+                        ctx.children_changed();
+                        return;
+                    }
+                    LapceUICommand::CloseMessage(item_widget_id) => {
+                        ctx.set_handled();
+                        let mut index = None;
+                        for (i, item) in self.items.iter().enumerate() {
+                            if &item.id() == item_widget_id {
+                                index = Some(i);
+                            }
+                        }
+                        if let Some(index) = index {
+                            self.items.remove(index);
+                            ctx.children_changed();
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            _ => {}
+        }
+        for item in self.items.iter_mut() {
+            item.event(ctx, event, data, env);
+        }
+
+        if ctx.is_handled() {
+            return;
+        }
+
+        match event {
+            Event::MouseMove(_) | Event::MouseDown(_) | Event::MouseUp(_) => {
+                ctx.set_handled();
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        for item in self.items.iter_mut() {
+            item.lifecycle(ctx, event, data, env);
+        }
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        for item in self.items.iter_mut() {
+            item.update(ctx, data, env);
+        }
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let mut width = 0.0;
+        let mut height = 0.0;
+
+        let num_items = self.items.len();
+        for (i, item) in self.items.iter_mut().enumerate() {
+            let size = item.layout(ctx, bc, data, env);
+            item.set_origin(ctx, data, env, Point::new(0.0, height));
+
+            if size.width > width {
+                width = size.width;
+            }
+            height += size.height;
+            if i + 1 < num_items {
+                height += 10.0;
+            }
+        }
+        ctx.set_paint_insets(100.0);
+        Size::new(width, height)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let rect = ctx.region().bounding_box();
+        for item in self.items.iter_mut() {
+            if !item.layout_rect().intersect(rect).is_empty() {
+                item.paint(ctx, data, env);
+            }
+        }
+    }
+}
+
+pub struct LapceMessageItem {
+    message_widget_id: WidgetId,
+    item_widget_id: WidgetId,
+    kind: MessageType,
+    title: String,
+    message: String,
+    icon_rect: Rect,
+    close_rect: Rect,
+    close_clicked: Option<()>,
+    text_layout: PietTextLayout,
+    text_width: f64,
+    text_padding: f64,
+    text_line_height: f64,
+}
+
+impl LapceMessageItem {
+    pub fn new(
+        message_widget_id: WidgetId,
+        piet_text: &mut PietText,
+        kind: MessageType,
+        title: String,
+        message: String,
+        config: &LapceConfig,
+    ) -> Self {
+        let text_width = 300.0;
+        let text_line_height = 2.0;
+        let text_layout = piet_text
+            .new_text_layout("".to_string())
+            .font(config.ui.font_family(), config.ui.font_size() as f64)
+            .max_width(text_width)
+            .set_line_height(text_line_height)
+            .build()
+            .unwrap();
+        Self {
+            message_widget_id,
+            item_widget_id: WidgetId::next(),
+            kind,
+            icon_rect: Rect::ZERO,
+            close_rect: Rect::ZERO,
+            close_clicked: None,
+            title,
+            message,
+            text_layout,
+            text_width,
+            text_padding: 20.0,
+            text_line_height,
+        }
+    }
+
+    fn new_text_layout(
+        &self,
+        piet_text: &mut PietText,
+        config: &LapceConfig,
+    ) -> PietTextLayout {
+        let text = format!("{}\n\n{}", self.title, self.message);
+        let text_layout = piet_text
+            .new_text_layout(text)
+            .font(config.ui.font_family(), config.ui.font_size() as f64)
+            .text_color(
+                config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                    .clone(),
+            )
+            .range_attribute(
+                0..self.title.len(),
+                TextAttribute::Weight(FontWeight::BOLD),
+            )
+            .max_width(self.text_width)
+            .set_line_height(self.text_line_height)
+            .build()
+            .unwrap();
+        text_layout
+    }
+}
+
+impl Widget<LapceTabData> for LapceMessageItem {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.item_widget_id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        _data: &mut LapceTabData,
+        _env: &Env,
+    ) {
+        match event {
+            Event::MouseUp(mouse_event) => {
+                ctx.set_handled();
+                if self.close_clicked.take().is_some()
+                    && self.close_rect.contains(mouse_event.pos)
+                {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::CloseMessage(self.item_widget_id),
+                        Target::Widget(self.message_widget_id),
+                    ));
+                }
+            }
+            Event::MouseDown(mouse_event) => {
+                ctx.set_handled();
+                self.close_clicked = None;
+                if self.close_rect.contains(mouse_event.pos) {
+                    self.close_clicked = Some(());
+                }
+            }
+            Event::MouseMove(mouse_event) => {
+                ctx.set_handled();
+                if self.close_rect.contains(mouse_event.pos) {
+                    ctx.set_cursor(&druid::Cursor::Pointer);
+                } else {
+                    ctx.clear_cursor();
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        _ctx: &mut LifeCycleCtx,
+        _event: &LifeCycle,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn update(
+        &mut self,
+        _ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        _bc: &BoxConstraints,
+        data: &LapceTabData,
+        _env: &Env,
+    ) -> Size {
+        self.text_layout = self.new_text_layout(ctx.text(), &data.config);
+
+        let mut height = self.text_layout.size().height;
+
+        if let Some(metric) = self.text_layout.line_metric(0) {
+            height =
+                height - metric.y_offset + metric.y_offset / self.text_line_height;
+        }
+
+        if let Some(metric) = self
+            .text_layout
+            .line_metric(self.text_layout.line_count().saturating_sub(1))
+        {
+            let descend = metric.height - metric.y_offset;
+            height = height - descend + descend / self.text_line_height;
+        }
+
+        self.icon_rect = Rect::ZERO
+            .with_origin(Point::new(
+                self.text_padding,
+                self.text_padding + data.config.ui.font_size() as f64 / 2.0,
+            ))
+            .inflate(self.text_padding / 2.0, self.text_padding / 2.0);
+
+        let width = self.text_width + self.text_padding * 4.0;
+
+        self.close_rect = Rect::ZERO
+            .with_origin(Point::new(
+                width - self.text_padding,
+                self.text_padding + data.config.ui.font_size() as f64 / 2.0,
+            ))
+            .inflate(self.text_padding / 2.0, self.text_padding / 2.0);
+
+        Size::new(width, height + self.text_padding * 2.0)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+        let mut y = 0.0;
+        if let Some(metric) = self.text_layout.line_metric(0) {
+            y = -metric.y_offset + metric.y_offset / self.text_line_height;
+        }
+        let rect = ctx.size().to_rect().inflate(-0.5, -0.5);
+        ctx.fill(
+            rect,
+            data.config
+                .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+        );
+        ctx.draw_text(
+            &self.text_layout,
+            Point::new(self.text_padding * 2.0, y + self.text_padding),
+        );
+
+        let shadow_width = data.config.ui.drop_shadow_width() as f64;
+        if shadow_width > 0.0 {
+            ctx.with_save(|ctx| {
+                ctx.blurred_rect(
+                    rect,
+                    shadow_width,
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                );
+            });
+        } else {
+            ctx.stroke(
+                rect,
+                data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                1.0,
+            );
+        }
+
+        let inflate =
+            (self.text_padding - data.config.ui.font_size() as f64) / 2.0 - 1.0;
+        let svg = match self.kind {
+            MessageType::ERROR => LapceIcons::ERROR,
+            MessageType::WARNING => LapceIcons::WARNING,
+            _ => LapceIcons::WARNING,
+        };
+        ctx.draw_svg(
+            &data.config.ui_svg(svg),
+            self.icon_rect.inflate(-inflate, -inflate),
+            Some(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+            ),
+        );
+
+        ctx.draw_svg(
+            &data.config.ui_svg(LapceIcons::CLOSE),
+            self.close_rect.inflate(-inflate, -inflate),
+            Some(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+            ),
+        );
+    }
+}
diff --git a/lapce-ui/src/palette.rs b/lapce-ui/src/palette.rs
index dfde811924..a981d573a6 100644
--- a/lapce-ui/src/palette.rs
+++ b/lapce-ui/src/palette.rs
@@ -1,32 +1,29 @@
-use std::path::Path;
-use std::sync::Arc;
+use std::{path::Path, sync::Arc};
 
-use druid::kurbo::Line;
-use druid::piet::{Svg, TextAttribute, TextLayout};
 use druid::{
     kurbo::Rect,
-    piet::{Text, TextLayoutBuilder},
-    BoxConstraints, Command, Data, Env, Event, EventCtx, LayoutCtx, LifeCycle,
-    LifeCycleCtx, PaintCtx, Point, RenderContext, Size, Target, UpdateCtx, Widget,
-    WidgetExt, WidgetId, WidgetPod,
+    piet::{Svg, Text, TextAttribute, TextLayoutBuilder},
+    theme, BoxConstraints, Color, Command, Data, Env, Event, EventCtx, FontWeight,
+    LayoutCtx, LifeCycle, LifeCycleCtx, Modifiers, PaintCtx, Point, RenderContext,
+    Size, Target, UpdateCtx, Widget, WidgetExt, WidgetId, WidgetPod,
 };
-use druid::{FontWeight, Modifiers};
-use lapce_data::command::LAPCE_COMMAND;
-use lapce_data::config::Config;
-use lapce_data::data::LapceWorkspaceType;
-use lapce_data::palette::PaletteItemContent;
 use lapce_data::{
-    command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::LapceTheme,
-    data::LapceTabData,
-    keypress::KeyPressFocus,
-    palette::{PaletteStatus, PaletteType, PaletteViewData, PaletteViewLens},
+    command::{LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND},
+    config::{LapceConfig, LapceTheme},
+    data::{LapceTabData, LapceWorkspaceType},
+    keypress::{Alignment, KeyMap, KeyPressFocus},
+    list::ListData,
+    palette::{
+        PaletteItem, PaletteItemContent, PaletteListData, PaletteStatus,
+        PaletteViewData,
+    },
 };
+use lapce_rpc::source_control::FileDiff;
+use lsp_types::SymbolKind;
 
 use crate::{
     editor::view::LapceEditorView,
-    scroll::{LapceIdentityWrapper, LapceScroll},
-    svg::{file_svg, symbol_svg},
+    list::{List, ListPaint},
 };
 
 pub struct Palette {
@@ -57,30 +54,6 @@ impl Widget<LapceTabData> for Palette {
         env: &Env,
     ) {
         match event {
-            Event::MouseDown(_)
-            | Event::MouseMove(_)
-            | Event::Wheel(_)
-            | Event::MouseUp(_) => {
-                if data.palette.status == PaletteStatus::Inactive {
-                    return;
-                }
-            }
-            _ => (),
-        }
-
-        match event {
-            // Event::KeyDown(key_event) => {
-            //     let mut keypress = data.keypress.clone();
-            //     let mut_keypress = Arc::make_mut(&mut keypress);
-            //     let mut palette_data = data.palette_view_data();
-            //     mut_keypress.key_down(ctx, key_event, &mut palette_data, env);
-            //     data.palette = palette_data.palette.clone();
-            //     data.keypress = keypress;
-            //     data.workspace = palette_data.workspace.clone();
-            //     data.main_split = palette_data.main_split.clone();
-            //     data.find = palette_data.find.clone();
-            //     ctx.set_handled();
-            // }
             Event::Command(cmd) if cmd.is(LAPCE_COMMAND) => {
                 let command = cmd.get_unchecked(LAPCE_COMMAND);
                 let mut palette_data = data.palette_view_data();
@@ -91,6 +64,8 @@ impl Widget<LapceTabData> for Palette {
                     Modifiers::default(),
                     env,
                 );
+                // TODO: manually restoring the changed palette data is unfortunate, it would be
+                // better to have a function to do this to avoid accidents where we forget to update
                 data.palette = palette_data.palette.clone();
                 data.workspace = palette_data.workspace.clone();
                 data.main_split = palette_data.main_split.clone();
@@ -102,7 +77,7 @@ impl Widget<LapceTabData> for Palette {
                     LapceUICommand::RunPalette(palette_type) => {
                         ctx.set_handled();
                         let mut palette_data = data.palette_view_data();
-                        palette_data.run(ctx, palette_type.to_owned());
+                        palette_data.run(ctx, palette_type.to_owned(), None, true);
                         data.palette = palette_data.palette.clone();
                         data.keypress = palette_data.keypress.clone();
                         data.workspace = palette_data.workspace.clone();
@@ -126,37 +101,38 @@ impl Widget<LapceTabData> for Palette {
                             Target::Widget(data.palette.input_editor),
                         ));
                     }
-                    LapceUICommand::CancelPalette => {
-                        let mut palette_data = data.palette_view_data();
-                        palette_data.cancel(ctx);
-                        data.palette = palette_data.palette.clone();
-                    }
-                    LapceUICommand::UpdatePaletteItems(run_id, items) => {
+                    LapceUICommand::UpdatePaletteItems { run_id, items } => {
                         let palette = Arc::make_mut(&mut data.palette);
                         if &palette.run_id == run_id {
-                            palette.items = items.to_owned();
+                            palette.total_items = items.clone();
                             palette.preview(ctx);
-                            if palette.get_input() != "" {
+                            if palette.get_input() == "" {
+                                palette.list_data.items =
+                                    palette.total_items.clone();
+                            } else {
                                 let _ = palette.sender.send((
                                     palette.run_id.clone(),
                                     palette.get_input().to_string(),
-                                    palette.items.clone(),
+                                    palette.total_items.clone(),
                                 ));
                             }
                         }
                     }
-                    LapceUICommand::FilterPaletteItems(
+                    LapceUICommand::FilterPaletteItems {
                         run_id,
                         input,
                         filtered_items,
-                    ) => {
+                    } => {
                         let palette = Arc::make_mut(&mut data.palette);
                         if &palette.run_id == run_id && palette.get_input() == input
                         {
-                            palette.filtered_items = filtered_items.to_owned();
+                            palette.list_data.items = filtered_items.clone();
                             palette.preview(ctx);
                         }
                     }
+                    LapceUICommand::ListItemSelected => {
+                        data.palette_view_data().select(ctx);
+                    }
                     _ => {}
                 }
             }
@@ -185,7 +161,6 @@ impl Widget<LapceTabData> for Palette {
     ) {
         if !old_data.palette.same(&data.palette) {
             ctx.request_layout();
-            ctx.request_paint();
         }
 
         self.container.update(ctx, data, env);
@@ -198,36 +173,28 @@ impl Widget<LapceTabData> for Palette {
         data: &LapceTabData,
         env: &Env,
     ) -> Size {
-        let width = 600.0;
-        let self_size = Size::new(width, bc.max().height);
+        let self_size = bc.max();
 
-        let bc = BoxConstraints::tight(self_size);
-        self.container.layout(ctx, &bc, data, env);
+        self.container.layout(ctx, bc, data, env);
         self.container.set_origin(ctx, data, env, Point::ZERO);
-        ctx.set_paint_insets((10.0, 10.0, 10.0, 10.0));
+
+        ctx.set_paint_insets(4000.0);
 
         self_size
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
-        if data.palette.status == PaletteStatus::Inactive {
-            return;
-        }
-
         self.container.paint(ctx, data, env);
     }
 }
 
 struct PaletteContainer {
-    content_size: Size,
-    line_height: f64,
+    content_rect: Rect,
     input: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
     #[allow(clippy::type_complexity)]
     content: WidgetPod<
-        LapceTabData,
-        LapceIdentityWrapper<
-            LapceScroll<LapceTabData, Box<dyn Widget<LapceTabData>>>,
-        >,
+        ListData<PaletteItem, PaletteListData>,
+        List<PaletteItem, PaletteListData>,
     >,
     preview: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
 }
@@ -243,20 +210,15 @@ impl PaletteContainer {
             LapceEditorView::new(data.palette.input_editor, WidgetId::next(), None)
                 .hide_header()
                 .hide_gutter()
-                .padding(10.0);
-        let content = LapceIdentityWrapper::wrap(
-            LapceScroll::new(PaletteContent::new().lens(PaletteViewLens).boxed())
-                .vertical(),
-            data.palette.scroll_id,
-        );
+                .padding((10.0, 5.0, 10.0, 5.0));
+        let content = List::new(data.palette.scroll_id);
         let preview =
             LapceEditorView::new(preview_editor.view_id, WidgetId::next(), None);
         Self {
-            content_size: Size::ZERO,
+            content_rect: Rect::ZERO,
             input: WidgetPod::new(input.boxed()),
             content: WidgetPod::new(content),
             preview: WidgetPod::new(preview.boxed()),
-            line_height: 25.0,
         }
     }
 
@@ -266,26 +228,11 @@ impl PaletteContainer {
         data: &LapceTabData,
         env: &Env,
     ) {
-        let width = ctx.size().width;
-        let rect =
-            Size::new(width, self.line_height)
-                .to_rect()
-                .with_origin(Point::new(
-                    0.0,
-                    data.palette.index as f64 * self.line_height,
-                ));
-        if self
-            .content
-            .widget_mut()
-            .inner_mut()
-            .scroll_to_visible(rect, env)
-        {
-            ctx.submit_command(Command::new(
-                LAPCE_UI_COMMAND,
-                LapceUICommand::ResetFade,
-                Target::Widget(data.palette.scroll_id),
-            ));
-        }
+        self.content.widget_mut().ensure_item_visible(
+            ctx,
+            &data.palette.list_data.clone_with(data.config.clone()),
+            env,
+        );
     }
 }
 
@@ -298,7 +245,18 @@ impl Widget<LapceTabData> for PaletteContainer {
         env: &Env,
     ) {
         self.input.event(ctx, event, data, env);
-        self.content.event(ctx, event, data, env);
+
+        let mode = data.mode();
+        let palette = Arc::make_mut(&mut data.palette);
+        palette.list_data.update_data(data.config.clone());
+        // Update the stored data on `PaletteListData`, this is so that they can be used
+        // during painting of the list
+        palette.list_data.data.workspace = Some(data.workspace.clone());
+        palette.list_data.data.keymaps = Some(data.keypress.command_keymaps.clone());
+        palette.list_data.data.mode = Some(mode);
+
+        self.content.event(ctx, event, &mut palette.list_data, env);
+
         self.preview.event(ctx, event, data, env);
     }
 
@@ -310,7 +268,12 @@ impl Widget<LapceTabData> for PaletteContainer {
         env: &Env,
     ) {
         self.input.lifecycle(ctx, event, data, env);
-        self.content.lifecycle(ctx, event, data, env);
+        self.content.lifecycle(
+            ctx,
+            event,
+            &data.palette.list_data.clone_with(data.config.clone()),
+            env,
+        );
         self.preview.lifecycle(ctx, event, data, env);
     }
 
@@ -322,12 +285,16 @@ impl Widget<LapceTabData> for PaletteContainer {
         env: &Env,
     ) {
         if old_data.palette.input != data.palette.input
-            || old_data.palette.index != data.palette.index
+            || old_data.palette.run_id != data.palette.run_id
         {
             self.ensure_item_visible(ctx, data, env);
         }
         self.input.update(ctx, data, env);
-        self.content.update(ctx, data, env);
+        self.content.update(
+            ctx,
+            &data.palette.list_data.clone_with(data.config.clone()),
+            env,
+        );
         self.preview.update(ctx, data, env);
     }
 
@@ -338,31 +305,35 @@ impl Widget<LapceTabData> for PaletteContainer {
         data: &LapceTabData,
         env: &Env,
     ) -> Size {
-        let width = 600.0;
+        let width = bc.max().width;
         let max_height = bc.max().height;
 
-        let bc = BoxConstraints::tight(Size::new(width, bc.max().height));
+        let bc = BoxConstraints::tight(Size::new(width, max_height));
+
         let input_size = self.input.layout(ctx, &bc, data, env);
         self.input.set_origin(ctx, data, env, Point::ZERO);
 
-        let max_items = 15;
-        let height = max_items.min(data.palette.len());
-        let height = self.line_height * height as f64;
+        let height = max_height - input_size.height;
         let bc = BoxConstraints::tight(Size::new(width, height));
-        let content_size = self.content.layout(ctx, &bc, data, env);
-        self.content
-            .set_origin(ctx, data, env, Point::new(0.0, input_size.height));
-        let mut content_height = content_size.height;
-        if content_height > 0.0 {
-            content_height += 6.0;
+        let mut content_size =
+            self.content.layout(ctx, &bc, &data.palette.list_data, env);
+        if content_size.height > 0.0 {
+            content_size.height += 5.0;
         }
+        self.content.set_origin(
+            ctx,
+            &data.palette.list_data.clone_with(data.config.clone()),
+            env,
+            Point::new(0.0, input_size.height),
+        );
 
         let max_preview_height = max_height
             - input_size.height
-            - max_items as f64 * self.line_height
-            - 6.0;
+            - data.palette.list_data.max_displayed_items as f64
+                * data.palette.list_data.line_height() as f64
+            - 5.0;
         let preview_height = if data.palette.palette_type.has_preview() {
-            if content_height > 0.0 {
+            if content_size.height > 0.0 {
                 max_preview_height
             } else {
                 0.0
@@ -370,51 +341,73 @@ impl Widget<LapceTabData> for PaletteContainer {
         } else {
             0.0
         };
-        let bc = BoxConstraints::tight(Size::new(width, max_preview_height));
-        let _preview_size = self.preview.layout(ctx, &bc, data, env);
+        let bc = BoxConstraints::tight(Size::new(
+            f64::max(width, data.config.ui.preview_editor_width() as f64),
+            max_preview_height,
+        ));
+        let preview_size = self.preview.layout(ctx, &bc, data, env);
+        let preview_width = if preview_size.width > width {
+            width - preview_size.width
+        } else {
+            0.00
+        };
         self.preview.set_origin(
             ctx,
             data,
             env,
-            Point::new(0.0, input_size.height + content_height),
+            Point::new(preview_width / 2.0, input_size.height + content_size.height),
         );
 
-        ctx.set_paint_insets((10.0, 10.0, 10.0, 10.0));
-        let self_size =
-            Size::new(width, input_size.height + content_height + preview_height);
-        self.content_size = self_size;
+        ctx.set_paint_insets(4000.0);
+
+        let self_size = Size::new(
+            width,
+            input_size.height + content_size.height + preview_height,
+        );
+        self.content_rect = Size::new(width, self_size.height)
+            .to_rect()
+            .with_origin(Point::new(0.0, 0.0));
         self_size
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
-        let rect = self.content_size.to_rect();
-        let shadow_width = data.config.ui.drop_shadow_width() as f64;
-        if shadow_width > 0.0 {
-            ctx.blurred_rect(
+        if data.palette.status != PaletteStatus::Inactive {
+            let rect = self.content_rect;
+            let shadow_width = data.config.ui.drop_shadow_width() as f64;
+            if shadow_width > 0.0 {
+                ctx.blurred_rect(
+                    rect,
+                    shadow_width,
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                );
+            } else {
+                ctx.stroke(
+                    rect.inflate(0.5, 0.5),
+                    data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                    1.0,
+                );
+            }
+            ctx.fill(
                 rect,
-                shadow_width,
                 data.config
-                    .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
-            );
-        } else {
-            ctx.stroke(
-                rect.inflate(0.5, 0.5),
-                data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
-                1.0,
+                    .get_color_unchecked(LapceTheme::PALETTE_BACKGROUND),
             );
         }
-        ctx.fill(
-            rect,
-            data.config
-                .get_color_unchecked(LapceTheme::PALETTE_BACKGROUND),
-        );
 
         self.input.paint(ctx, data, env);
-        self.content.paint(ctx, data, env);
 
-        if !data.palette.current_items().is_empty()
-            && data.palette.palette_type.has_preview()
-        {
+        if data.palette.status == PaletteStatus::Inactive {
+            return;
+        }
+
+        self.content.paint(
+            ctx,
+            &data.palette.list_data.clone_with(data.config.clone()),
+            env,
+        );
+
+        if !data.palette.is_empty() && data.palette.palette_type.has_preview() {
             let rect = self.preview.layout_rect();
             ctx.fill(
                 rect,
@@ -426,21 +419,21 @@ impl Widget<LapceTabData> for PaletteContainer {
     }
 }
 
-pub struct PaletteInput {}
+pub struct PalettePreview {}
 
-impl PaletteInput {
+impl PalettePreview {
     pub fn new() -> Self {
         Self {}
     }
 }
 
-impl Default for PaletteInput {
+impl Default for PalettePreview {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl Widget<PaletteViewData> for PaletteInput {
+impl Widget<PaletteViewData> for PalettePreview {
     fn event(
         &mut self,
         _ctx: &mut EventCtx,
@@ -472,194 +465,222 @@ impl Widget<PaletteViewData> for PaletteInput {
         &mut self,
         _ctx: &mut LayoutCtx,
         bc: &BoxConstraints,
-        _data: &PaletteViewData,
+        data: &PaletteViewData,
         _env: &Env,
     ) -> Size {
-        Size::new(bc.max().width, 14.0)
-    }
-
-    fn paint(&mut self, ctx: &mut PaintCtx, data: &PaletteViewData, _env: &Env) {
-        let text = data.palette.input.clone();
-        let cursor = data.palette.cursor;
-
-        let text_layout = if text.is_empty()
-            && data.palette.palette_type == PaletteType::SshHost
-        {
-            ctx.text()
-                .new_text_layout("Enter your SSH details, like user@host")
-                .font(
-                    data.config.ui.font_family(),
-                    data.config.ui.font_size() as f64,
-                )
-                .text_color(
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_DIM)
-                        .clone(),
-                )
-                .build()
-                .unwrap()
+        if data.palette.palette_type.has_preview() {
+            bc.max()
         } else {
-            ctx.text()
-                .new_text_layout(text)
-                .font(
-                    data.config.ui.font_family(),
-                    data.config.ui.font_size() as f64,
-                )
-                .text_color(
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                        .clone(),
-                )
-                .build()
-                .unwrap()
-        };
-
-        let pos = text_layout.hit_test_text_position(cursor);
-        let line_metric = text_layout.line_metric(0).unwrap();
-        let p0 = (pos.point.x, line_metric.y_offset);
-        let p1 = (pos.point.x, line_metric.y_offset + line_metric.height);
-        let line = Line::new(p0, p1);
-
-        ctx.stroke(
-            line,
-            data.config
-                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
-            1.0,
-        );
-        ctx.draw_text(&text_layout, Point::new(0.0, 0.0));
+            Size::ZERO
+        }
     }
+
+    fn paint(&mut self, _ctx: &mut PaintCtx, _data: &PaletteViewData, _env: &Env) {}
 }
 
-pub struct PaletteContent {
-    mouse_down: usize,
-    line_height: f64,
+struct PaletteItemPaintInfo {
+    svg: Option<Svg>,
+    svg_color: Option<Color>,
+    text: String,
+    text_color: Option<Color>,
+    text_indices: Vec<usize>,
+    hint: String,
+    hint_indices: Vec<usize>,
+    keymap: Option<KeyMap>,
 }
 
-impl PaletteContent {
-    pub fn new() -> Self {
-        Self {
-            mouse_down: 0,
-            line_height: 25.0,
+impl PaletteItemPaintInfo {
+    /// Construct paint info when there is only known text and text indices
+    fn new_text(text: String, text_indices: Vec<usize>) -> PaletteItemPaintInfo {
+        PaletteItemPaintInfo {
+            svg: None,
+            svg_color: None,
+            text,
+            text_color: None,
+            text_indices,
+            hint: String::new(),
+            hint_indices: Vec::new(),
+            keymap: None,
         }
     }
+}
 
-    fn paint_palette_item(
-        palette_item_content: &PaletteItemContent,
+impl ListPaint<PaletteListData> for PaletteItem {
+    fn paint(
+        &self,
         ctx: &mut PaintCtx,
+        data: &ListData<Self, PaletteListData>,
+        env: &Env,
         line: usize,
-        indices: &[usize],
-        line_height: f64,
-        config: &Config,
     ) {
-        let (svg, text, text_indices, hint, hint_indices) =
-            match palette_item_content {
-                PaletteItemContent::File(path, _) => {
-                    Self::file_paint_items(path, indices)
-                }
-                PaletteItemContent::DocumentSymbol {
-                    kind,
-                    name,
-                    container_name,
-                    ..
-                } => {
-                    let text = name.to_string();
-                    let hint =
-                        container_name.clone().unwrap_or_else(|| "".to_string());
-                    let text_indices = indices
-                        .iter()
-                        .filter_map(|i| {
-                            let i = *i;
-                            if i < text.len() {
-                                Some(i)
-                            } else {
-                                None
-                            }
-                        })
-                        .collect();
-                    let hint_indices = indices
-                        .iter()
-                        .filter_map(|i| {
-                            let i = *i;
-                            if i >= text.len() {
-                                Some(i - text.len())
-                            } else {
-                                None
-                            }
-                        })
-                        .collect();
-                    (symbol_svg(kind), text, text_indices, hint, hint_indices)
-                }
-                PaletteItemContent::Line(_, text) => {
-                    (None, text.clone(), indices.to_vec(), "".to_string(), vec![])
-                }
-                PaletteItemContent::ReferenceLocation(rel_path, _location) => {
-                    Self::file_paint_items(rel_path, indices)
-                }
-                PaletteItemContent::Workspace(w) => {
-                    let text = w.path.as_ref().unwrap().to_str().unwrap();
-                    let text = match &w.kind {
-                        LapceWorkspaceType::Local => text.to_string(),
-                        LapceWorkspaceType::RemoteSSH(user, host) => {
-                            format!("[{user}@{host}] {text}")
+        let PaletteItemPaintInfo {
+            svg,
+            svg_color,
+            text,
+            text_color,
+            text_indices,
+            hint,
+            hint_indices,
+            keymap,
+        } = match &self.content {
+            PaletteItemContent::File(path, _, file_diff) => {
+                file_paint_items(path, file_diff, &self.indices, data)
+            }
+            PaletteItemContent::DocumentSymbol {
+                kind,
+                name,
+                container_name,
+                ..
+            } => {
+                let text = name.to_string();
+                let hint = container_name.clone().unwrap_or_default();
+                let text_indices = self
+                    .indices
+                    .iter()
+                    .filter_map(|i| {
+                        let i = *i;
+                        if i < text.len() {
+                            Some(i)
+                        } else {
+                            None
                         }
-                        LapceWorkspaceType::RemoteWSL => {
-                            format!("[wsl] {text}")
+                    })
+                    .collect();
+                let hint_indices = self
+                    .indices
+                    .iter()
+                    .filter_map(|i| {
+                        let i = *i;
+                        if i >= text.len() {
+                            Some(i - text.len())
+                        } else {
+                            None
                         }
-                    };
-                    (None, text, indices.to_vec(), "".to_string(), vec![])
+                    })
+                    .collect();
+                PaletteItemPaintInfo {
+                    svg: data.config.symbol_svg(kind),
+                    svg_color: Some(
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                            .clone(),
+                    ),
+                    text,
+                    text_color: None,
+                    text_indices,
+                    hint,
+                    hint_indices,
+                    keymap: None,
                 }
-                PaletteItemContent::Command(command) => (
-                    None,
-                    command
-                        .kind
-                        .desc()
-                        .map(|m| m.to_string())
-                        .unwrap_or_else(|| "".to_string()),
-                    indices.to_vec(),
-                    "".to_string(),
-                    vec![],
-                ),
-                PaletteItemContent::Theme(theme) => (
-                    None,
-                    theme.to_string(),
-                    indices.to_vec(),
-                    "".to_string(),
-                    vec![],
-                ),
-                PaletteItemContent::TerminalLine(_line, content) => (
-                    None,
+            }
+            PaletteItemContent::WorkspaceSymbol {
+                kind,
+                name,
+                location,
+                ..
+            } => file_paint_symbols(
+                &location.path,
+                &self.indices,
+                data.data
+                    .workspace
+                    .as_ref()
+                    .and_then(|workspace| workspace.path.as_deref()),
+                name.as_str(),
+                *kind,
+                &data.config,
+            ),
+            PaletteItemContent::Line(_, text) => {
+                PaletteItemPaintInfo::new_text(text.clone(), self.indices.to_vec())
+            }
+            PaletteItemContent::ReferenceLocation(rel_path, _location) => {
+                file_paint_items(rel_path, &None, &self.indices, data)
+            }
+            PaletteItemContent::Workspace(w) => {
+                let text = w.path.as_ref().unwrap().to_str().unwrap();
+                let text = match &w.kind {
+                    LapceWorkspaceType::Local => text.to_string(),
+                    LapceWorkspaceType::RemoteSSH(ssh) => {
+                        format!("[{ssh}] {text}")
+                    }
+                    #[cfg(windows)]
+                    LapceWorkspaceType::RemoteWSL => {
+                        format!("[wsl] {text}")
+                    }
+                };
+                PaletteItemPaintInfo::new_text(text, self.indices.to_vec())
+            }
+            PaletteItemContent::Command(command) => {
+                let text = command
+                    .kind
+                    .desc()
+                    .map(|m| m.to_string())
+                    .unwrap_or_else(String::new);
+
+                let keymap = data
+                    .data
+                    .keymaps
+                    .as_ref()
+                    .and_then(|keymaps| keymaps.get(command.kind.str()))
+                    .and_then(|keymaps| keymaps.get(0))
+                    .cloned();
+
+                PaletteItemPaintInfo {
+                    svg: None,
+                    svg_color: None,
+                    text,
+                    text_color: None,
+                    text_indices: self.indices.to_vec(),
+                    hint: String::new(),
+                    hint_indices: Vec::new(),
+                    keymap,
+                }
+            }
+            PaletteItemContent::ColorTheme(theme) => PaletteItemPaintInfo::new_text(
+                theme.to_string(),
+                self.indices.to_vec(),
+            ),
+            PaletteItemContent::IconTheme(theme) => PaletteItemPaintInfo::new_text(
+                theme.to_string(),
+                self.indices.to_vec(),
+            ),
+            PaletteItemContent::Language(name) => PaletteItemPaintInfo::new_text(
+                name.to_string(),
+                self.indices.to_vec(),
+            ),
+            PaletteItemContent::TerminalLine(_line, content) => {
+                PaletteItemPaintInfo::new_text(
                     content.clone(),
-                    indices.to_vec(),
-                    "".to_string(),
-                    vec![],
-                ),
-                PaletteItemContent::SshHost(user, host) => (
-                    None,
-                    format!("{user}@{host}"),
-                    indices.to_vec(),
-                    "".to_string(),
-                    vec![],
-                ),
-            };
+                    self.indices.to_vec(),
+                )
+            }
+            PaletteItemContent::SshHost(ssh) => PaletteItemPaintInfo::new_text(
+                format!("{ssh}"),
+                self.indices.to_vec(),
+            ),
+        };
+
+        let line_height = data.line_height() as f64;
 
         if let Some(svg) = svg.as_ref() {
-            let width = 14.0;
-            let height = 14.0;
-            let rect = Size::new(width, height).to_rect().with_origin(Point::new(
-                (line_height - width) / 2.0 + 5.0,
-                (line_height - height) / 2.0 + line_height * line as f64,
-            ));
-            ctx.draw_svg(svg, rect, None);
+            let svg_size = data.config.ui.icon_size() as f64;
+            let rect =
+                Size::new(svg_size, svg_size)
+                    .to_rect()
+                    .with_origin(Point::new(
+                        (line_height - svg_size) / 2.0 + 5.0,
+                        (line_height - svg_size) / 2.0 + line_height * line as f64,
+                    ));
+            ctx.draw_svg(svg, rect, svg_color.as_ref());
         }
 
-        let svg_x = match palette_item_content {
+        let svg_x = match &self.content {
             &PaletteItemContent::Line(_, _) | &PaletteItemContent::Workspace(_) => {
                 0.0
             }
             _ => line_height,
         };
 
-        let focus_color = config.get_color_unchecked(LapceTheme::EDITOR_FOCUS);
+        let focus_color = data.config.get_color_unchecked(LapceTheme::EDITOR_FOCUS);
 
         let full_text = if hint.is_empty() {
             text.clone()
@@ -669,12 +690,21 @@ impl PaletteContent {
         let mut text_layout = ctx
             .text()
             .new_text_layout(full_text.clone())
-            .font(config.ui.font_family(), config.ui.font_size() as f64)
-            .text_color(
-                config
-                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+            .font(
+                data.config.ui.font_family(),
+                data.config.ui.font_size() as f64,
+            )
+            .text_color(match text_color {
+                Some(ref color) => color.clone(),
+                None => data
+                    .config
+                    .get_color_unchecked(if line == data.selected_index {
+                        LapceTheme::PALETTE_CURRENT_FOREGROUND
+                    } else {
+                        LapceTheme::PALETTE_FOREGROUND
+                    })
                     .clone(),
-            );
+            });
         for &i_start in &text_indices {
             let i_end = full_text
                 .char_indices()
@@ -694,7 +724,10 @@ impl PaletteContent {
 
             text_layout = text_layout.range_attribute(
                 i_start..i_end,
-                TextAttribute::TextColor(focus_color.clone()),
+                TextAttribute::TextColor(match text_color {
+                    Some(ref color) => color.clone(),
+                    None => focus_color.clone(),
+                }),
             );
             text_layout = text_layout.range_attribute(
                 i_start..i_end,
@@ -711,7 +744,9 @@ impl PaletteContent {
                 .range_attribute(
                     text.len() + 1..full_text.len(),
                     TextAttribute::TextColor(
-                        config.get_color_unchecked(LapceTheme::EDITOR_DIM).clone(),
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_DIM)
+                            .clone(),
                     ),
                 );
             for i in &hint_indices {
@@ -729,215 +764,147 @@ impl PaletteContent {
 
         let text_layout = text_layout.build().unwrap();
         let x = svg_x + 5.0;
-        let y = line_height * line as f64
-            + (line_height - text_layout.size().height) / 2.0;
+        let y = line_height * line as f64 + text_layout.y_offset(line_height);
         let point = Point::new(x, y);
         ctx.draw_text(&text_layout, point);
-    }
-
-    fn file_paint_items(
-        path: &Path,
-        indices: &[usize],
-    ) -> (Option<Svg>, String, Vec<usize>, String, Vec<usize>) {
-        let svg = file_svg(path);
-        let file_name = path
-            .file_name()
-            .and_then(|s| s.to_str())
-            .unwrap_or("")
-            .to_string();
-        let folder = path
-            .parent()
-            .and_then(|s| s.to_str())
-            .unwrap_or("")
-            .to_string();
-        let folder_len = folder.len();
-        let text_indices: Vec<usize> = indices
-            .iter()
-            .filter_map(|i| {
-                let i = *i;
-                if folder_len > 0 {
-                    if i > folder_len {
-                        Some(i - folder_len - 1)
-                    } else {
-                        None
-                    }
-                } else {
-                    Some(i)
-                }
-            })
-            .collect();
-        let hint_indices: Vec<usize> = indices
-            .iter()
-            .filter_map(|i| {
-                let i = *i;
-                if i < folder_len {
-                    Some(i)
-                } else {
-                    None
-                }
-            })
-            .collect();
-        (Some(svg), file_name, text_indices, folder, hint_indices)
-    }
-}
-
-impl Default for PaletteContent {
-    fn default() -> Self {
-        Self::new()
-    }
-}
 
-impl Widget<PaletteViewData> for PaletteContent {
-    fn event(
-        &mut self,
-        ctx: &mut EventCtx,
-        event: &Event,
-        data: &mut PaletteViewData,
-        _env: &Env,
-    ) {
-        match event {
-            Event::MouseMove(_mouse_event) => {
-                ctx.set_cursor(&druid::Cursor::Pointer);
-                ctx.set_handled();
-            }
-            Event::MouseDown(mouse_event) => {
-                let line = (mouse_event.pos.y / self.line_height).floor() as usize;
-                self.mouse_down = line;
-                ctx.set_handled();
-            }
-            Event::MouseUp(mouse_event) => {
-                let line = (mouse_event.pos.y / self.line_height).floor() as usize;
-                if line == self.mouse_down {
-                    let palette = Arc::make_mut(&mut data.palette);
-                    palette.index = line;
-                    data.select(ctx);
-                }
-                ctx.set_handled();
-            }
-            _ => (),
-        }
-    }
+        // TODO: make sure that the main text and the keymaps don't overlap
+        // This isn't currently an issue for any added commands, but could become one
 
-    fn lifecycle(
-        &mut self,
-        _ctx: &mut LifeCycleCtx,
-        _event: &LifeCycle,
-        _data: &PaletteViewData,
-        _env: &Env,
-    ) {
-    }
-
-    fn update(
-        &mut self,
-        _ctx: &mut UpdateCtx,
-        _old_data: &PaletteViewData,
-        _data: &PaletteViewData,
-        _env: &Env,
-    ) {
-    }
-
-    fn layout(
-        &mut self,
-        _ctx: &mut LayoutCtx,
-        bc: &BoxConstraints,
-        data: &PaletteViewData,
-        _env: &Env,
-    ) -> Size {
-        let height = self.line_height * data.palette.len() as f64;
-        Size::new(bc.max().width, height)
-    }
-
-    fn paint(&mut self, ctx: &mut PaintCtx, data: &PaletteViewData, _env: &Env) {
-        let rect = ctx.region().bounding_box();
-        let size = ctx.size();
-
-        let items = data.palette.current_items();
-
-        let start_line = (rect.y0 / self.line_height).floor() as usize;
-        let end_line = (rect.y1 / self.line_height).ceil() as usize;
-
-        for line in start_line..end_line {
-            if line >= items.len() {
-                break;
-            }
-            if line == data.palette.index {
-                ctx.fill(
-                    Rect::ZERO
-                        .with_origin(Point::new(0.0, line as f64 * self.line_height))
-                        .with_size(Size::new(size.width, self.line_height)),
-                    data.config.get_color_unchecked(LapceTheme::PALETTE_CURRENT),
-                );
-            }
-
-            let item = &items[line];
-
-            Self::paint_palette_item(
-                &item.content,
+        if let Some(keymap) = keymap {
+            let width = ctx.size().width;
+            keymap.paint(
                 ctx,
-                line,
-                &item.indices,
-                self.line_height,
+                Point::new(
+                    width
+                        - env.get(theme::SCROLLBAR_WIDTH)
+                        - env.get(theme::SCROLLBAR_PAD),
+                    line_height * line as f64 + line_height / 2.0,
+                ),
+                Alignment::Right,
                 &data.config,
             );
         }
     }
 }
 
-pub struct PalettePreview {}
-
-impl PalettePreview {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-impl Default for PalettePreview {
-    fn default() -> Self {
-        Self::new()
+fn file_paint_symbols(
+    path: &Path,
+    indices: &[usize],
+    workspace_path: Option<&Path>,
+    name: &str,
+    kind: SymbolKind,
+    config: &LapceConfig,
+) -> PaletteItemPaintInfo {
+    let text = name.to_string();
+    let hint = path.to_string_lossy();
+    // Remove the workspace prefix from the path
+    let hint = workspace_path
+        .and_then(Path::to_str)
+        .and_then(|x| hint.strip_prefix(x))
+        .map(|x| x.strip_prefix('/').unwrap_or(x))
+        .map(ToString::to_string)
+        .unwrap_or_else(|| hint.to_string());
+    let text_indices = indices
+        .iter()
+        .filter_map(|i| {
+            let i = *i;
+            if i < text.len() {
+                Some(i)
+            } else {
+                None
+            }
+        })
+        .collect();
+    let hint_indices = indices
+        .iter()
+        .filter_map(|i| {
+            let i = *i;
+            if i >= text.len() {
+                Some(i - text.len())
+            } else {
+                None
+            }
+        })
+        .collect();
+    PaletteItemPaintInfo {
+        svg: config.symbol_svg(&kind),
+        svg_color: Some(
+            config
+                .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                .clone(),
+        ),
+        text,
+        text_color: None,
+        text_indices,
+        hint,
+        hint_indices,
+        keymap: Default::default(),
     }
 }
 
-impl Widget<PaletteViewData> for PalettePreview {
-    fn event(
-        &mut self,
-        _ctx: &mut EventCtx,
-        _event: &Event,
-        _data: &mut PaletteViewData,
-        _env: &Env,
-    ) {
-    }
-
-    fn lifecycle(
-        &mut self,
-        _ctx: &mut LifeCycleCtx,
-        _event: &LifeCycle,
-        _data: &PaletteViewData,
-        _env: &Env,
-    ) {
-    }
-
-    fn update(
-        &mut self,
-        _ctx: &mut UpdateCtx,
-        _old_data: &PaletteViewData,
-        _data: &PaletteViewData,
-        _env: &Env,
-    ) {
-    }
-
-    fn layout(
-        &mut self,
-        _ctx: &mut LayoutCtx,
-        bc: &BoxConstraints,
-        data: &PaletteViewData,
-        _env: &Env,
-    ) -> Size {
-        if data.palette.palette_type.has_preview() {
-            bc.max()
-        } else {
-            Size::ZERO
-        }
+fn file_paint_items(
+    path: &Path,
+    file_diff: &Option<FileDiff>,
+    indices: &[usize],
+    data: &ListData<PaletteItem, PaletteListData>,
+) -> PaletteItemPaintInfo {
+    let (svg, svg_color) = data.config.file_svg(path);
+    let file_name = path
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("")
+        .to_string();
+    let folder = path
+        .parent()
+        .and_then(|s| s.to_str())
+        .unwrap_or("")
+        .to_string();
+    let folder_len = folder.len();
+    let text_color = file_diff.as_ref().map(|diff| {
+        let color = match diff {
+            FileDiff::Modified(_) | FileDiff::Renamed(_, _) => {
+                LapceTheme::SOURCE_CONTROL_MODIFIED
+            }
+            FileDiff::Added(_) => LapceTheme::SOURCE_CONTROL_ADDED,
+            FileDiff::Deleted(_) => LapceTheme::SOURCE_CONTROL_REMOVED,
+        };
+        data.config.get_color_unchecked(color).clone()
+    });
+    let text_indices: Vec<usize> = indices
+        .iter()
+        .filter_map(|i| {
+            let i = *i;
+            if folder_len > 0 {
+                if i > folder_len {
+                    Some(i - folder_len - 1)
+                } else {
+                    None
+                }
+            } else {
+                Some(i)
+            }
+        })
+        .collect();
+    let hint_indices: Vec<usize> = indices
+        .iter()
+        .filter_map(|i| {
+            let i = *i;
+            if i < folder_len {
+                Some(i)
+            } else {
+                None
+            }
+        })
+        .collect();
+    PaletteItemPaintInfo {
+        svg: Some(svg),
+        svg_color: svg_color.cloned(),
+        text: file_name,
+        text_color,
+        text_indices,
+        hint: folder,
+        hint_indices,
+        keymap: Default::default(),
     }
-
-    fn paint(&mut self, _ctx: &mut PaintCtx, _data: &PaletteViewData, _env: &Env) {}
 }
diff --git a/lapce-ui/src/panel.rs b/lapce-ui/src/panel.rs
index 1b18f70954..ec6c922b94 100644
--- a/lapce-ui/src/panel.rs
+++ b/lapce-ui/src/panel.rs
@@ -1,25 +1,31 @@
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
 
 use druid::{
     kurbo::Line,
     piet::{Text, TextLayout, TextLayoutBuilder, TextStorage},
-    BoxConstraints, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
-    LifeCycleCtx, MouseEvent, PaintCtx, Point, RenderContext, Size, Target,
-    UpdateCtx, Widget, WidgetExt, WidgetId, WidgetPod,
+    BoxConstraints, Command, Cursor, Env, Event, EventCtx, LayoutCtx, LifeCycle,
+    LifeCycleCtx, PaintCtx, Point, Rect, RenderContext, Size, Target, UpdateCtx,
+    Widget, WidgetExt, WidgetId, WidgetPod,
 };
 use lapce_data::{
-    command::{CommandKind, LapceCommand, LapceWorkbenchCommand, LAPCE_COMMAND},
-    config::LapceTheme,
-    data::{LapceTabData, PanelKind},
-    panel::PanelPosition,
-    split::SplitDirection,
+    command::{
+        CommandKind, LapceCommand, LapceUICommand, LapceWorkbenchCommand,
+        LAPCE_COMMAND, LAPCE_UI_COMMAND,
+    },
+    config::{LapceIcons, LapceTheme},
+    data::{DragContent, LapceTabData},
+    panel::{PanelContainerPosition, PanelKind, PanelPosition},
 };
-use serde_json::json;
 
-use crate::{scroll::LapceScroll, split::LapceSplit, svg::get_svg, tab::LapceIcon};
+use crate::{scroll::LapceScroll, split::LapceSplit, tab::LapceIcon};
+
+pub enum PanelSizing {
+    Size(f64),
+    /// Flex-sized. Bool decides whether it is resizable in the UI or not.
+    Flex(bool),
+}
 
 pub struct LapcePanel {
-    header: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
     split: WidgetPod<LapceTabData, LapceSplit>,
 }
 
@@ -31,7 +37,6 @@ impl Widget<LapceTabData> for LapcePanel {
         data: &mut LapceTabData,
         env: &Env,
     ) {
-        self.header.event(ctx, event, data, env);
         self.split.event(ctx, event, data, env);
     }
 
@@ -42,7 +47,6 @@ impl Widget<LapceTabData> for LapcePanel {
         data: &LapceTabData,
         env: &Env,
     ) {
-        self.header.lifecycle(ctx, event, data, env);
         self.split.lifecycle(ctx, event, data, env);
     }
 
@@ -53,7 +57,6 @@ impl Widget<LapceTabData> for LapcePanel {
         data: &LapceTabData,
         env: &Env,
     ) {
-        self.header.update(ctx, data, env);
         self.split.update(ctx, data, env);
     }
 
@@ -66,23 +69,14 @@ impl Widget<LapceTabData> for LapcePanel {
     ) -> Size {
         let self_size = bc.max();
 
-        let header_size = self.header.layout(ctx, bc, data, env);
-        self.header.set_origin(ctx, data, env, Point::ZERO);
-
-        let bc = BoxConstraints::tight(Size::new(
-            self_size.width,
-            self_size.height - header_size.height,
-        ));
-        self.split.layout(ctx, &bc, data, env);
-        self.split
-            .set_origin(ctx, data, env, Point::new(0.0, header_size.height));
+        self.split.layout(ctx, bc, data, env);
+        self.split.set_origin(ctx, data, env, Point::ZERO);
 
         self_size
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
         self.split.paint(ctx, data, env);
-        self.header.paint(ctx, data, env);
     }
 }
 
@@ -90,23 +84,17 @@ impl LapcePanel {
     #[allow(clippy::type_complexity)]
     pub fn new(
         kind: PanelKind,
-        widget_id: WidgetId,
+        _widget_id: WidgetId,
         split_id: WidgetId,
-        split_direction: SplitDirection,
-        header: PanelHeaderKind,
         sections: Vec<(
             WidgetId,
             PanelHeaderKind,
             Box<dyn Widget<LapceTabData>>,
-            Option<f64>,
+            PanelSizing,
         )>,
     ) -> Self {
-        let mut split = LapceSplit::new(split_id).direction(split_direction);
-        match split_direction {
-            SplitDirection::Vertical => {}
-            SplitDirection::Horizontal => split = split.hide_border(),
-        };
-        for (section_widget_id, header, content, size) in sections {
+        let mut split = LapceSplit::new(split_id).panel(kind);
+        for (section_id, header, content, size) in sections {
             let header = match header {
                 PanelHeaderKind::None => None,
                 PanelHeaderKind::Simple(s) => {
@@ -114,27 +102,19 @@ impl LapcePanel {
                 }
                 PanelHeaderKind::Widget(w) => Some(w),
             };
-            let section =
-                PanelSection::new(section_widget_id, header, content).boxed();
+            let section = PanelSection::new(kind, header, content).boxed();
 
-            if let Some(size) = size {
-                split = split.with_child(section, Some(section_widget_id), size);
-            } else {
-                split = split.with_flex_child(section, Some(section_widget_id), 1.0);
-            }
+            split = match size {
+                PanelSizing::Size(size) => {
+                    split.with_child(section, Some(section_id), size)
+                }
+                PanelSizing::Flex(resizable) => {
+                    split.with_flex_child(section, Some(section_id), 1.0, resizable)
+                }
+            };
         }
-        let header = match header {
-            PanelHeaderKind::None => {
-                PanelMainHeader::new(widget_id, kind, "".into()).boxed()
-            }
-            PanelHeaderKind::Simple(s) => {
-                PanelMainHeader::new(widget_id, kind, s).boxed()
-            }
-            PanelHeaderKind::Widget(w) => w,
-        };
         Self {
             split: WidgetPod::new(split),
-            header: WidgetPod::new(header),
         }
     }
 }
@@ -161,7 +141,7 @@ impl From<String> for ReadOnlyString {
 impl TextStorage for ReadOnlyString {
     fn as_str(&self) -> &str {
         match self {
-            ReadOnlyString::Static(str) => *str,
+            ReadOnlyString::Static(str) => str,
             ReadOnlyString::String(str) => str.as_ref(),
         }
     }
@@ -174,6 +154,9 @@ pub enum PanelHeaderKind {
 }
 
 struct PanelSection {
+    kind: PanelKind,
+    display_content: bool,
+    mouse_down: bool,
     header: Option<WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>>,
     content: WidgetPod<
         LapceTabData,
@@ -183,18 +166,23 @@ struct PanelSection {
 
 impl PanelSection {
     pub fn new(
-        _widget_id: WidgetId,
+        kind: PanelKind,
         header: Option<Box<dyn Widget<LapceTabData>>>,
         content: Box<dyn Widget<LapceTabData>>,
     ) -> Self {
         let content = LapceScroll::new(content).vertical();
         Self {
+            kind,
+            display_content: true,
+            mouse_down: true,
             header: header.map(WidgetPod::new),
             content: WidgetPod::new(content),
         }
     }
 }
 
+const HEADER_HEIGHT: f64 = 30.0f64;
+
 impl Widget<LapceTabData> for PanelSection {
     fn event(
         &mut self,
@@ -203,6 +191,38 @@ impl Widget<LapceTabData> for PanelSection {
         data: &mut LapceTabData,
         env: &Env,
     ) {
+        match event {
+            Event::MouseMove(mouse_event) => {
+                ctx.clear_cursor();
+                if let Some(header) = self.header.as_ref() {
+                    let rect = header.layout_rect();
+                    if rect.contains(mouse_event.pos) {
+                        ctx.set_cursor(&Cursor::Pointer);
+                    }
+                }
+            }
+            Event::MouseDown(mouse_event) => {
+                self.mouse_down = false;
+                if let Some(header) = self.header.as_ref() {
+                    let rect = header.layout_rect();
+                    if rect.contains(mouse_event.pos) {
+                        self.mouse_down = true
+                    }
+                }
+            }
+            Event::MouseUp(mouse_event) => {
+                if let Some(header) = self.header.as_ref() {
+                    let rect = header.layout_rect();
+                    if self.mouse_down && rect.contains(mouse_event.pos) {
+                        self.mouse_down = false;
+                        self.display_content = !self.display_content;
+                        ctx.request_layout();
+                    }
+                }
+            }
+            _ => {}
+        }
+
         if let Some(header) = self.header.as_mut() {
             header.event(ctx, event, data, env);
         }
@@ -243,39 +263,99 @@ impl Widget<LapceTabData> for PanelSection {
         env: &Env,
     ) -> Size {
         let self_size = bc.max();
-        let header_height = if let Some(header) = self.header.as_mut() {
-            let header_height = 30.0;
-            header.layout(
+
+        let header_size = if let Some(header) = self.header.as_mut() {
+            let size = if !self.display_content
+                && data
+                    .panel
+                    .panel_position(&self.kind)
+                    .map(|(_, pos)| pos.is_bottom())
+                    .unwrap_or(false)
+            {
+                header.layout(
+                    ctx,
+                    &BoxConstraints::tight(Size::new(
+                        HEADER_HEIGHT,
+                        self_size.height,
+                    )),
+                    data,
+                    env,
+                )
+            } else {
+                header.layout(
+                    ctx,
+                    &BoxConstraints::tight(Size::new(
+                        self_size.width,
+                        HEADER_HEIGHT,
+                    )),
+                    data,
+                    env,
+                )
+            };
+            header.set_origin(ctx, data, env, Point::ZERO);
+            size
+        } else {
+            Size::ZERO
+        };
+
+        let content_size = if self.display_content {
+            let s = self.content.layout(
                 ctx,
-                &BoxConstraints::tight(Size::new(self_size.width, header_height)),
+                &BoxConstraints::new(
+                    Size::ZERO,
+                    Size::new(self_size.width, self_size.height - HEADER_HEIGHT),
+                ),
                 data,
                 env,
             );
-            header.set_origin(ctx, data, env, Point::ZERO);
-            header_height
+            self.content.set_origin(
+                ctx,
+                data,
+                env,
+                Point::new(0.0, header_size.height),
+            );
+            s
         } else {
-            0.0
+            Size::ZERO
         };
 
-        let content_size = self.content.layout(
-            ctx,
-            &BoxConstraints::new(
-                Size::ZERO,
-                Size::new(self_size.width, self_size.height - header_height),
-            ),
-            data,
-            env,
-        );
-        self.content
-            .set_origin(ctx, data, env, Point::new(0.0, header_height));
-
-        Size::new(content_size.width, header_height + content_size.height)
+        Size::new(
+            header_size.width.max(content_size.width),
+            header_size.height + content_size.height,
+        )
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
-        self.content.paint(ctx, data, env);
         if let Some(header) = self.header.as_mut() {
             header.paint(ctx, data, env);
+
+            let icon_name = if self.display_content {
+                LapceIcons::PANEL_RESTORE
+            } else {
+                LapceIcons::PANEL_MAXIMISE
+            };
+
+            let header_rect = header.layout_rect();
+
+            let icon_size = data.config.ui.icon_size();
+            let icon_rect = Size::ZERO
+                .to_rect()
+                .with_origin(Point::new(
+                    header_rect.width() - HEADER_HEIGHT / 2.0,
+                    HEADER_HEIGHT / 2.0,
+                ))
+                .inflate(icon_size as f64 / 2.0, icon_size as f64 / 2.0);
+            ctx.draw_svg(
+                &data.config.ui_svg(icon_name),
+                icon_rect,
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                ),
+            );
+        }
+        if self.display_content {
+            self.content.paint(ctx, data, env);
         }
     }
 }
@@ -331,37 +411,32 @@ impl Widget<LapceTabData> for PanelSectionHeader {
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
         let rect = ctx.size().to_rect();
-        ctx.with_save(|ctx| {
-            ctx.fill(
-                rect,
-                data.config
-                    .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
-            );
-            let shadow_width = data.config.ui.drop_shadow_width() as f64;
-            if shadow_width > 0.0 {
+
+        ctx.fill(
+            rect,
+            data.config
+                .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+        );
+        let shadow_width = data.config.ui.drop_shadow_width() as f64;
+        if shadow_width > 0.0 {
+            ctx.with_save(|ctx| {
+                let (_, pos) = data.panel.panel_position(&self.kind).unwrap();
+                if pos.is_bottom() {
+                    ctx.clip(rect.inset((0.0, 0.0, 0.0, 50.0)));
+                } else {
+                    ctx.clip(rect.inset((0.0, 50.0, 0.0, 50.0)));
+                }
+
                 ctx.blurred_rect(
                     rect,
                     shadow_width,
                     data.config
                         .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
                 );
-            } else if let Some(position) = data.panel_position(self.kind) {
-                match position {
-                    PanelPosition::BottomLeft | PanelPosition::BottomRight => {
-                        ctx.stroke(
-                            Line::new(
-                                Point::new(rect.x0, rect.y0 + 0.5),
-                                Point::new(rect.x1, rect.y0 + 0.5),
-                            ),
-                            data.config
-                                .get_color_unchecked(LapceTheme::LAPCE_BORDER),
-                            1.0,
-                        );
-                    }
-                    _ => {}
-                }
-            }
+            });
+        }
 
+        ctx.with_save(|ctx| {
             ctx.clip(rect);
             let text_layout = ctx
                 .text()
@@ -378,138 +453,749 @@ impl Widget<LapceTabData> for PanelSectionHeader {
                 .build()
                 .unwrap();
             let height = ctx.size().height;
-            let y = (height - text_layout.size().height) / 2.0;
+            let y = text_layout.y_offset(height);
             ctx.draw_text(&text_layout, Point::new(10.0, y));
         });
     }
 }
 
-/// This struct is used as the outer container for a panel,
-/// it contains the heading such as "Terminal" or "File Explorer".
-pub struct PanelMainHeader {
-    text: ReadOnlyString,
-    icons: Vec<LapceIcon>,
-
-    kind: PanelKind,
-    mouse_pos: Point,
+pub struct PanelContainer {
+    pub widget_id: WidgetId,
+    switcher0: WidgetPod<LapceTabData, PanelSwitcher>,
+    switcher1: WidgetPod<LapceTabData, PanelSwitcher>,
+    position: PanelContainerPosition,
+    pub panels:
+        HashMap<PanelKind, WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>>,
 }
 
-impl PanelMainHeader {
-    pub fn new(
-        _panel_widget_id: WidgetId,
-        kind: PanelKind,
-        text: ReadOnlyString,
-    ) -> Self {
+impl PanelContainer {
+    pub fn new(position: PanelContainerPosition) -> Self {
+        let (switcher0, switcher1) = match position {
+            PanelContainerPosition::Left => (
+                PanelSwitcher::new(PanelPosition::LeftTop),
+                PanelSwitcher::new(PanelPosition::LeftBottom),
+            ),
+            PanelContainerPosition::Right => (
+                PanelSwitcher::new(PanelPosition::RightTop),
+                PanelSwitcher::new(PanelPosition::RightBottom),
+            ),
+            PanelContainerPosition::Bottom => (
+                PanelSwitcher::new(PanelPosition::BottomLeft),
+                PanelSwitcher::new(PanelPosition::BottomRight),
+            ),
+        };
         Self {
-            kind,
-            text,
-            icons: Vec::new(),
-            mouse_pos: Point::ZERO,
+            widget_id: WidgetId::next(),
+            switcher0: WidgetPod::new(switcher0),
+            switcher1: WidgetPod::new(switcher1),
+            position,
+            panels: HashMap::new(),
         }
     }
 
-    fn update_icons(&mut self, self_size: Size, data: &LapceTabData) {
-        let icon_size = 24.0;
-        let gap = (self_size.height - icon_size) / 2.0;
+    pub fn insert_panel(
+        &mut self,
+        kind: PanelKind,
+        panel: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    ) {
+        self.panels.insert(kind, panel);
+    }
+}
 
-        let mut icons = Vec::new();
-        let x = self_size.width - ((icons.len() + 1) as f64) * (gap + icon_size);
-        let icon = LapceIcon {
-            icon: "close.svg",
-            rect: Size::new(icon_size, icon_size)
-                .to_rect()
-                .with_origin(Point::new(x, gap)),
-            command: Command::new(
-                LAPCE_COMMAND,
-                LapceCommand {
-                    kind: CommandKind::Workbench(LapceWorkbenchCommand::HidePanel),
-                    data: Some(json!(self.kind)),
-                },
-                Target::Widget(data.id),
-            ),
-        };
-        icons.push(icon);
+impl Widget<LapceTabData> for PanelContainer {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.widget_id)
+    }
 
-        if let Some(position) = data.panel_position(self.kind) {
-            if position == PanelPosition::BottomLeft
-                || position == PanelPosition::BottomRight
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        match event {
+            Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
+                ctx.set_handled();
+                let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
+                if let LapceUICommand::ChildrenChanged = &command {
+                    ctx.children_changed();
+                }
+            }
+            _ => {}
+        }
+
+        self.switcher0.event(ctx, event, data, env);
+        self.switcher1.event(ctx, event, data, env);
+        if event.should_propagate_to_hidden() {
+            for (_, panel) in self.panels.iter_mut() {
+                panel.event(ctx, event, data, env);
+            }
+        } else {
+            if let Some((panel, shown)) =
+                data.panel.active_panel_at_position(&self.position.first())
             {
-                let mut icon_svg = "chevron-up.svg";
-                for (_, panel) in data.panels.iter() {
-                    if panel.widgets.contains(&self.kind) {
-                        if panel.maximized {
-                            icon_svg = "chevron-down.svg";
-                        }
-                        break;
+                if shown {
+                    if let Some(panel) = self.panels.get_mut(&panel) {
+                        panel.event(ctx, event, data, env);
                     }
                 }
+            }
+            if let Some((panel, shown)) =
+                data.panel.active_panel_at_position(&self.position.second())
+            {
+                if shown {
+                    if let Some(panel) = self.panels.get_mut(&panel) {
+                        panel.event(ctx, event, data, env);
+                    }
+                }
+            }
+        }
+    }
 
-                let x =
-                    self_size.width - ((icons.len() + 1) as f64) * (gap + icon_size);
-                let icon = LapceIcon {
-                    icon: icon_svg,
-                    rect: Size::new(icon_size, icon_size)
-                        .to_rect()
-                        .with_origin(Point::new(x, gap)),
-                    command: Command::new(
-                        LAPCE_COMMAND,
-                        LapceCommand {
-                            kind: CommandKind::Workbench(
-                                LapceWorkbenchCommand::ToggleMaximizedPanel,
-                            ),
-                            data: Some(json!(self.kind)),
-                        },
-                        Target::Widget(data.id),
-                    ),
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.switcher0.lifecycle(ctx, event, data, env);
+        self.switcher1.lifecycle(ctx, event, data, env);
+        for (_, panel) in self.panels.iter_mut() {
+            panel.lifecycle(ctx, event, data, env);
+        }
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.switcher0.update(ctx, data, env);
+        self.switcher1.update(ctx, data, env);
+        if let Some((panel, shown)) =
+            data.panel.active_panel_at_position(&self.position.first())
+        {
+            if shown {
+                if let Some(panel) = self.panels.get_mut(&panel) {
+                    panel.update(ctx, data, env);
+                }
+            }
+        }
+        if let Some((panel, shown)) =
+            data.panel.active_panel_at_position(&self.position.second())
+        {
+            if shown {
+                if let Some(panel) = self.panels.get_mut(&panel) {
+                    panel.update(ctx, data, env);
+                }
+            }
+        }
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let self_size = bc.max();
+        let is_bottom = self.position.is_bottom();
+
+        let (should_shown0, should_shown1) = match self.position {
+            PanelContainerPosition::Left => (
+                data.panel.position_has_panels(&PanelPosition::LeftTop),
+                data.panel.position_has_panels(&PanelPosition::LeftBottom),
+            ),
+            PanelContainerPosition::Right => (
+                data.panel.position_has_panels(&PanelPosition::RightTop),
+                data.panel.position_has_panels(&PanelPosition::RightBottom),
+            ),
+            PanelContainerPosition::Bottom => (
+                data.panel.position_has_panels(&PanelPosition::BottomLeft),
+                data.panel.position_has_panels(&PanelPosition::BottomRight),
+            ),
+        };
+
+        let switcher0_size = if should_shown0 {
+            data.config.ui.header_height() as f64
+        } else {
+            0.0
+        };
+        let switcher1_size = if should_shown1 {
+            data.config.ui.header_height() as f64
+        } else {
+            0.0
+        };
+
+        self.switcher0.layout(ctx, bc, data, env);
+        self.switcher0.set_origin(ctx, data, env, Point::ZERO);
+
+        self.switcher1.layout(ctx, bc, data, env);
+        if self.position.is_bottom() {
+            self.switcher1.set_origin(
+                ctx,
+                data,
+                env,
+                Point::new(self_size.width - switcher1_size, 0.0),
+            );
+        } else {
+            self.switcher1.set_origin(
+                ctx,
+                data,
+                env,
+                Point::new(0.0, self_size.height - switcher1_size),
+            );
+        }
+
+        let panel_first = data
+            .panel
+            .active_panel_at_position(&self.position.first())
+            .and_then(|(panel, shown)| if shown { Some(panel) } else { None });
+        let panel_second = data
+            .panel
+            .active_panel_at_position(&self.position.second())
+            .and_then(|(panel, shown)| if shown { Some(panel) } else { None });
+
+        match (panel_first, panel_second) {
+            (Some(panel_first), Some(panel_second)) => {
+                let split = match self.position {
+                    PanelContainerPosition::Left => data.panel.size.left_split,
+                    PanelContainerPosition::Bottom => data.panel.size.bottom_split,
+                    PanelContainerPosition::Right => data.panel.size.right_split,
                 };
-                icons.push(icon);
+                let separator = 4.0;
+                if is_bottom {
+                    let size_fist = ((self_size.width
+                        - switcher0_size
+                        - switcher1_size
+                        - separator)
+                        * split)
+                        .round();
+                    let size_second = self_size.width
+                        - separator
+                        - switcher0_size
+                        - switcher1_size
+                        - size_fist;
+                    let panel_first = self.panels.get_mut(&panel_first).unwrap();
+                    panel_first.layout(
+                        ctx,
+                        &BoxConstraints::tight(Size::new(
+                            size_fist,
+                            self_size.height,
+                        )),
+                        data,
+                        env,
+                    );
+                    panel_first.set_origin(
+                        ctx,
+                        data,
+                        env,
+                        Point::new(switcher0_size, 0.0),
+                    );
+                    let panel_second = self.panels.get_mut(&panel_second).unwrap();
+                    panel_second.layout(
+                        ctx,
+                        &BoxConstraints::tight(Size::new(
+                            size_second,
+                            self_size.height,
+                        )),
+                        data,
+                        env,
+                    );
+                    panel_second.set_origin(
+                        ctx,
+                        data,
+                        env,
+                        Point::new(size_fist + switcher0_size + separator, 0.0),
+                    );
+                } else {
+                    let size_fist = ((self_size.height
+                        - switcher0_size
+                        - switcher1_size
+                        - separator)
+                        * split)
+                        .round();
+                    let size_second = self_size.height
+                        - separator
+                        - switcher0_size
+                        - switcher1_size
+                        - size_fist;
+                    let panel_first = self.panels.get_mut(&panel_first).unwrap();
+                    panel_first.layout(
+                        ctx,
+                        &BoxConstraints::tight(Size::new(
+                            self_size.width,
+                            size_fist,
+                        )),
+                        data,
+                        env,
+                    );
+                    panel_first.set_origin(
+                        ctx,
+                        data,
+                        env,
+                        Point::new(0.0, switcher0_size),
+                    );
+
+                    let panel_second = self.panels.get_mut(&panel_second).unwrap();
+                    panel_second.layout(
+                        ctx,
+                        &BoxConstraints::tight(Size::new(
+                            self_size.width,
+                            size_second,
+                        )),
+                        data,
+                        env,
+                    );
+                    panel_second.set_origin(
+                        ctx,
+                        data,
+                        env,
+                        Point::new(0.0, size_fist + switcher0_size + separator),
+                    );
+                }
             }
+            (Some(panel), None) | (None, Some(panel)) => {
+                let panel = self.panels.get_mut(&panel).unwrap();
+                if is_bottom {
+                    panel.layout(
+                        ctx,
+                        &BoxConstraints::tight(Size::new(
+                            self_size.width - switcher0_size - switcher1_size,
+                            self_size.height,
+                        )),
+                        data,
+                        env,
+                    );
+                    panel.set_origin(
+                        ctx,
+                        data,
+                        env,
+                        Point::new(switcher0_size, 0.0),
+                    );
+                } else {
+                    panel.layout(
+                        ctx,
+                        &BoxConstraints::tight(Size::new(
+                            self_size.width,
+                            self_size.height - switcher0_size - switcher1_size,
+                        )),
+                        data,
+                        env,
+                    );
+                    panel.set_origin(
+                        ctx,
+                        data,
+                        env,
+                        Point::new(0.0, switcher0_size),
+                    );
+                }
+            }
+            (None, None) => {}
         }
 
-        self.icons = icons;
+        self_size
     }
 
-    fn mouse_down(&self, ctx: &mut EventCtx, mouse_event: &MouseEvent) {
-        for icon in self.icons.iter() {
-            if icon.rect.contains(mouse_event.pos) {
-                ctx.submit_command(icon.command.clone());
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let shadow_width = data.config.ui.drop_shadow_width() as f64;
+        let rect = ctx.size().to_rect();
+        match self.position {
+            PanelContainerPosition::Left => {
+                ctx.fill(
+                    rect,
+                    data.config
+                        .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+                );
+                if shadow_width > 0.0 {
+                    ctx.blurred_rect(
+                        rect,
+                        shadow_width,
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                    );
+                } else {
+                    ctx.stroke(
+                        Line::new(
+                            Point::new(rect.x1 + 0.5, rect.y0),
+                            Point::new(rect.x1 + 0.5, rect.y1),
+                        ),
+                        data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                        1.0,
+                    );
+                }
+            }
+            PanelContainerPosition::Right => {
+                ctx.fill(
+                    rect,
+                    data.config
+                        .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+                );
+                if shadow_width > 0.0 {
+                    ctx.blurred_rect(
+                        rect,
+                        shadow_width,
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                    );
+                } else {
+                    ctx.stroke(
+                        Line::new(
+                            Point::new(rect.x0 - 0.5, rect.y0),
+                            Point::new(rect.x0 - 0.5, rect.y1),
+                        ),
+                        data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                        1.0,
+                    );
+                }
+            }
+            PanelContainerPosition::Bottom => {
+                ctx.fill(
+                    rect,
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+                );
+                if shadow_width > 0.0 {
+                    ctx.blurred_rect(
+                        rect,
+                        shadow_width,
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                    );
+                } else {
+                    ctx.stroke(
+                        Line::new(
+                            Point::new(rect.x0, rect.y0 - 0.5),
+                            Point::new(rect.x1, rect.y0 - 0.5),
+                        ),
+                        data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                        1.0,
+                    );
+                }
+            }
+        }
+
+        if let Some((panel, shown)) =
+            data.panel.active_panel_at_position(&self.position.first())
+        {
+            if shown {
+                let panel = self.panels.get_mut(&panel).unwrap();
+                panel.paint(ctx, data, env);
+            }
+        }
+        if let Some((panel, shown)) =
+            data.panel.active_panel_at_position(&self.position.second())
+        {
+            if shown {
+                let panel = self.panels.get_mut(&panel).unwrap();
+                panel.paint(ctx, data, env);
+            }
+        }
+
+        let is_bottom = self.position.is_bottom();
+        if let Some((panel0, shown0)) =
+            data.panel.active_panel_at_position(&self.position.first())
+        {
+            if shown0 {
+                if let Some((panel1, shown1)) =
+                    data.panel.active_panel_at_position(&self.position.second())
+                {
+                    if shown1 {
+                        let panel0 = self.panels.get_mut(&panel0).unwrap();
+                        let panel0_rect = panel0.layout_rect();
+                        let panel1 = self.panels.get_mut(&panel1).unwrap();
+                        let panel1_rect = panel1.layout_rect();
+                        if is_bottom {
+                            ctx.stroke(
+                                Line::new(
+                                    Point::new(panel0_rect.x1 + 0.5, panel0_rect.y0),
+                                    Point::new(panel0_rect.x1 + 0.5, panel0_rect.y1),
+                                ),
+                                data.config
+                                    .get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                                1.0,
+                            );
+                            ctx.stroke(
+                                Line::new(
+                                    Point::new(panel1_rect.x0 - 0.5, panel1_rect.y0),
+                                    Point::new(panel1_rect.x0 - 0.5, panel1_rect.y1),
+                                ),
+                                data.config
+                                    .get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                                1.0,
+                            );
+                        } else {
+                            ctx.stroke(
+                                Line::new(
+                                    Point::new(panel0_rect.x0, panel0_rect.y1 + 0.5),
+                                    Point::new(panel0_rect.x1, panel0_rect.y1 + 0.5),
+                                ),
+                                data.config
+                                    .get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                                1.0,
+                            );
+                            ctx.stroke(
+                                Line::new(
+                                    Point::new(panel1_rect.x0, panel1_rect.y0 - 0.5),
+                                    Point::new(panel1_rect.x1, panel1_rect.y0 - 0.5),
+                                ),
+                                data.config
+                                    .get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                                1.0,
+                            );
+                        }
+                    }
+                }
             }
         }
+
+        self.switcher0.paint(ctx, data, env);
+        self.switcher1.paint(ctx, data, env);
+
+        if self.panels.is_empty() {
+            let text_layout = ctx
+                .text()
+                .new_text_layout("You can drag panel icon here")
+                .font(
+                    data.config.ui.font_family(),
+                    data.config.ui.font_size() as f64,
+                )
+                .text_color(
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                        .clone(),
+                )
+                .build()
+                .unwrap();
+            let x = (rect.width() - text_layout.size().width) / 2.0;
+            ctx.draw_text(
+                &text_layout,
+                Point::new(x, text_layout.y_offset(rect.height())),
+            );
+        }
+    }
+}
+
+pub struct PanelSwitcher {
+    position: PanelPosition,
+    icons: Vec<(PanelKind, LapceIcon)>,
+    mouse_pos: Point,
+    on_icon: bool,
+    clicked_icon: Option<usize>,
+    maximise_toggle: Option<Rect>,
+    clicked_maximise: bool,
+}
+
+impl PanelSwitcher {
+    pub fn new(position: PanelPosition) -> Self {
+        Self {
+            position,
+            icons: Vec::new(),
+            mouse_pos: Point::ZERO,
+            on_icon: false,
+            clicked_icon: None,
+            maximise_toggle: None,
+            clicked_maximise: false,
+        }
     }
 
-    fn icon_hit_test(&self, mouse_event: &MouseEvent) -> bool {
-        for icon in self.icons.iter() {
-            if icon.rect.contains(mouse_event.pos) {
-                return true;
+    fn icon_padding(data: &LapceTabData) -> f64 {
+        ((data.config.ui.header_height() - data.config.ui.font_size()) as f64 * 0.5
+            / 2.0)
+            .round()
+    }
+
+    fn update_icons(&mut self, self_size: Size, data: &LapceTabData) {
+        let mut icons = Vec::new();
+        if let Some(order) = data.panel.order.get(&self.position) {
+            for kind in order.iter() {
+                icons.push(Self::panel_icon(kind, data));
             }
         }
-        false
+        let switcher_size = data.config.ui.header_height() as f64;
+        let icon_size = data.config.ui.font_size() as f64;
+        self.maximise_toggle = None;
+        if self.position.is_bottom() {
+            for (i, (_, icon)) in icons.iter_mut().enumerate() {
+                icon.rect = Rect::ZERO
+                    .with_origin(Point::new(
+                        self_size.width / 2.0,
+                        (i as f64 + 0.5) * switcher_size,
+                    ))
+                    .inflate(icon_size / 2.0, icon_size / 2.0);
+            }
+            self.maximise_toggle = Some(
+                Rect::ZERO
+                    .with_origin(Point::new(
+                        self_size.width / 2.0,
+                        self_size.height - switcher_size / 2.0,
+                    ))
+                    .inflate(icon_size / 2.0, icon_size / 2.0),
+            );
+        } else {
+            for (i, (_, icon)) in icons.iter_mut().enumerate() {
+                icon.rect = Rect::ZERO
+                    .with_origin(Point::new(
+                        (i as f64 + 0.5) * switcher_size,
+                        self_size.height / 2.0,
+                    ))
+                    .inflate(icon_size / 2.0, icon_size / 2.0);
+            }
+        }
+        self.icons = icons;
+    }
+
+    fn panel_icon(kind: &PanelKind, data: &LapceTabData) -> (PanelKind, LapceIcon) {
+        let cmd = match kind {
+            PanelKind::FileExplorer => {
+                LapceWorkbenchCommand::ToggleFileExplorerVisual
+            }
+            PanelKind::SourceControl => {
+                LapceWorkbenchCommand::ToggleSourceControlVisual
+            }
+            PanelKind::Plugin => LapceWorkbenchCommand::TogglePluginVisual,
+            PanelKind::Terminal => LapceWorkbenchCommand::ToggleTerminalVisual,
+            PanelKind::Search => LapceWorkbenchCommand::ToggleSearchVisual,
+            PanelKind::Problem => LapceWorkbenchCommand::ToggleProblemVisual,
+        };
+        (
+            *kind,
+            LapceIcon {
+                icon: kind.svg_name(),
+                rect: Rect::ZERO,
+                command: Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Workbench(cmd),
+                        data: None,
+                    },
+                    Target::Widget(data.id),
+                ),
+            },
+        )
     }
 }
 
-impl Widget<LapceTabData> for PanelMainHeader {
+impl Widget<LapceTabData> for PanelSwitcher {
     fn event(
         &mut self,
         ctx: &mut EventCtx,
         event: &Event,
-        _data: &mut LapceTabData,
+        data: &mut LapceTabData,
         _env: &Env,
     ) {
         match event {
             Event::MouseMove(mouse_event) => {
+                if ctx.is_active() {
+                    if let Some(i) = self.clicked_icon {
+                        ctx.set_active(false);
+                        let (kind, icon) = &self.icons[i];
+                        let offset =
+                            mouse_event.pos.to_vec2() - icon.rect.origin().to_vec2();
+                        *Arc::make_mut(&mut data.drag) = Some((
+                            offset,
+                            mouse_event.window_pos.to_vec2(),
+                            DragContent::Panel(*kind, icon.rect),
+                        ));
+                    }
+                }
                 self.mouse_pos = mouse_event.pos;
-                if self.icon_hit_test(mouse_event) {
-                    ctx.set_cursor(&druid::Cursor::Pointer);
-                    ctx.request_paint();
-                } else {
+                let icon_padding = Self::icon_padding(data);
+                for (_, icon) in self.icons.iter() {
+                    let rect = icon.rect.inflate(icon_padding, icon_padding);
+                    if rect.contains(self.mouse_pos) {
+                        if !self.on_icon {
+                            ctx.set_cursor(&Cursor::Pointer);
+                            self.on_icon = true;
+                            ctx.request_paint();
+                        }
+                        return;
+                    }
+                }
+                if self
+                    .maximise_toggle
+                    .map(|r| {
+                        r.inflate(icon_padding, icon_padding)
+                            .contains(mouse_event.pos)
+                    })
+                    .unwrap_or(false)
+                {
+                    if !self.on_icon {
+                        ctx.set_cursor(&Cursor::Pointer);
+                        self.on_icon = true;
+                        ctx.request_paint();
+                    }
+                    return;
+                }
+                if self.on_icon {
+                    self.on_icon = false;
                     ctx.clear_cursor();
                     ctx.request_paint();
                 }
             }
             Event::MouseDown(mouse_event) => {
-                self.mouse_down(ctx, mouse_event);
+                let icon_padding = Self::icon_padding(data);
+                for (i, (_, icon)) in self.icons.iter().enumerate() {
+                    let rect = icon.rect.inflate(icon_padding, icon_padding);
+                    if rect.contains(mouse_event.pos) {
+                        self.clicked_icon = Some(i);
+                        ctx.set_active(true);
+                        break;
+                    }
+                }
+                self.clicked_maximise = false;
+                if self
+                    .maximise_toggle
+                    .map(|r| {
+                        r.inflate(icon_padding, icon_padding)
+                            .contains(mouse_event.pos)
+                    })
+                    .unwrap_or(false)
+                {
+                    self.clicked_maximise = true;
+                }
             }
-            _ => {}
+            Event::MouseUp(mouse_event) => {
+                ctx.set_active(false);
+                let icon_padding = Self::icon_padding(data);
+                for (i, (_, icon)) in self.icons.iter().enumerate() {
+                    let rect = icon.rect.inflate(icon_padding, icon_padding);
+                    if rect.contains(mouse_event.pos) {
+                        if self.clicked_icon == Some(i) {
+                            ctx.submit_command(icon.command.clone());
+                        }
+                        break;
+                    }
+                }
+                if self.clicked_maximise
+                    && self
+                        .maximise_toggle
+                        .map(|r| {
+                            r.inflate(icon_padding, icon_padding)
+                                .contains(mouse_event.pos)
+                        })
+                        .unwrap_or(false)
+                {
+                    ctx.submit_command(Command::new(
+                        LAPCE_COMMAND,
+                        LapceCommand {
+                            kind: CommandKind::Workbench(
+                                LapceWorkbenchCommand::ToggleMaximizedPanel,
+                            ),
+                            data: None,
+                        },
+                        Target::Widget(data.id),
+                    ));
+                }
+                self.clicked_icon = None;
+                self.clicked_maximise = false;
+            }
+            _ => (),
         }
     }
 
@@ -538,96 +1224,254 @@ impl Widget<LapceTabData> for PanelMainHeader {
         data: &LapceTabData,
         _env: &Env,
     ) -> Size {
-        let self_size =
-            Size::new(bc.max().width, data.config.ui.header_height() as f64);
+        let self_size = if self.position.is_bottom() {
+            Size::new(data.config.ui.header_height() as f64, bc.max().height)
+        } else {
+            Size::new(bc.max().width, data.config.ui.header_height() as f64)
+        };
         self.update_icons(self_size, data);
         self_size
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+        let should_show = data
+            .panel
+            .order
+            .get(&self.position)
+            .map(|p| !p.is_empty())
+            .unwrap_or(false);
+        if !should_show {
+            return;
+        }
+
         let rect = ctx.size().to_rect();
-        let position = data.panel_position(self.kind);
-        ctx.with_save(|ctx| {
-            let shadow_width = data.config.ui.drop_shadow_width() as f64;
-            if shadow_width > 0.0 {
-                ctx.clip(rect.inset((0.0, 0.0, 0.0, 50.0)));
-                ctx.blurred_rect(
-                    rect,
-                    shadow_width,
-                    data.config
-                        .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
-                );
-            } else if let Some(position) = position {
-                ctx.stroke(
-                    Line::new(
-                        Point::new(rect.x0, rect.y1 + 0.5),
-                        Point::new(rect.x1, rect.y1 + 0.5),
-                    ),
-                    data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
-                    1.0,
+        ctx.fill(
+            rect,
+            data.config
+                .get_color_unchecked(if self.position.is_bottom() {
+                    LapceTheme::EDITOR_BACKGROUND
+                } else {
+                    LapceTheme::PANEL_BACKGROUND
+                }),
+        );
+        let shadow_width = data.config.ui.drop_shadow_width() as f64;
+        match self.position {
+            PanelPosition::LeftTop | PanelPosition::RightTop => {
+                if shadow_width > 0.0 {
+                    ctx.with_save(|ctx| {
+                        ctx.clip(rect.inset((0.0, 0.0, 0.0, 50.0)));
+                        ctx.blurred_rect(
+                            rect,
+                            shadow_width,
+                            data.config.get_color_unchecked(
+                                LapceTheme::LAPCE_DROPDOWN_SHADOW,
+                            ),
+                        );
+                    });
+                } else {
+                    ctx.stroke(
+                        Line::new(
+                            Point::new(rect.x0, rect.y1 + 0.5),
+                            Point::new(rect.x1, rect.y1 + 0.5),
+                        ),
+                        data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                        1.0,
+                    );
+                }
+            }
+            PanelPosition::LeftBottom | PanelPosition::RightBottom => {
+                if shadow_width > 0.0 {
+                    ctx.with_save(|ctx| {
+                        ctx.clip(rect.inset((0.0, 50.0, 0.0, 0.0)));
+                        ctx.blurred_rect(
+                            rect,
+                            shadow_width,
+                            data.config.get_color_unchecked(
+                                LapceTheme::LAPCE_DROPDOWN_SHADOW,
+                            ),
+                        );
+                    });
+                } else {
+                    ctx.stroke(
+                        Line::new(
+                            Point::new(rect.x0, rect.y0 - 0.5),
+                            Point::new(rect.x1, rect.y0 - 0.5),
+                        ),
+                        data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                        1.0,
+                    );
+                }
+            }
+            PanelPosition::BottomLeft => {
+                if shadow_width > 0.0 {
+                    ctx.with_save(|ctx| {
+                        ctx.clip(rect.inset((0.0, 0.0, 50.0, 0.0)));
+                        ctx.blurred_rect(
+                            rect,
+                            shadow_width,
+                            data.config.get_color_unchecked(
+                                LapceTheme::LAPCE_DROPDOWN_SHADOW,
+                            ),
+                        );
+                    });
+                } else {
+                    ctx.stroke(
+                        Line::new(
+                            Point::new(rect.x1 + 0.5, rect.y0),
+                            Point::new(rect.x1 + 0.5, rect.y1),
+                        ),
+                        data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                        1.0,
+                    );
+                }
+            }
+            PanelPosition::BottomRight => {
+                if shadow_width > 0.0 {
+                    ctx.with_save(|ctx| {
+                        ctx.clip(rect.inset((50.0, 0.0, 0.0, 0.0)));
+                        ctx.blurred_rect(
+                            rect,
+                            shadow_width,
+                            data.config.get_color_unchecked(
+                                LapceTheme::LAPCE_DROPDOWN_SHADOW,
+                            ),
+                        );
+                    });
+                } else {
+                    ctx.stroke(
+                        Line::new(
+                            Point::new(rect.x0 - 0.5, rect.y0),
+                            Point::new(rect.x0 - 0.5, rect.y1),
+                        ),
+                        data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                        1.0,
+                    );
+                }
+            }
+        }
+
+        let icon_padding = Self::icon_padding(data);
+        let is_bottom = self.position.is_bottom();
+        let mut active_kinds = Vec::new();
+        if let Some((panel, shown)) =
+            data.panel.active_panel_at_position(&self.position)
+        {
+            if shown {
+                active_kinds.push(panel);
+            }
+        }
+        for (kind, icon) in self.icons.iter() {
+            let mouse_rect = icon.rect.inflate(icon_padding, icon_padding);
+            if mouse_rect.contains(self.mouse_pos) {
+                ctx.fill(
+                    mouse_rect,
+                    &data.config.get_hover_color(if is_bottom {
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
+                    } else {
+                        data.config
+                            .get_color_unchecked(LapceTheme::PANEL_BACKGROUND)
+                    }),
                 );
-                match position {
-                    PanelPosition::BottomLeft | PanelPosition::BottomRight => {
+            }
+            if active_kinds.contains(kind) {
+                match self.position {
+                    PanelPosition::LeftTop | PanelPosition::RightTop => {
                         ctx.stroke(
                             Line::new(
-                                Point::new(rect.x0, rect.y0 - 0.5),
-                                Point::new(rect.x1, rect.y0 - 0.5),
+                                Point::new(mouse_rect.x0, mouse_rect.y1 + 1.0),
+                                Point::new(mouse_rect.x1, mouse_rect.y1 + 1.0),
                             ),
                             data.config
-                                .get_color_unchecked(LapceTheme::LAPCE_BORDER),
-                            1.0,
+                                .get_color_unchecked(LapceTheme::EDITOR_CARET),
+                            2.0,
+                        );
+                    }
+                    PanelPosition::LeftBottom | PanelPosition::RightBottom => {
+                        ctx.stroke(
+                            Line::new(
+                                Point::new(mouse_rect.x0, mouse_rect.y0 - 1.0),
+                                Point::new(mouse_rect.x1, mouse_rect.y0 - 1.0),
+                            ),
+                            data.config
+                                .get_color_unchecked(LapceTheme::EDITOR_CARET),
+                            2.0,
+                        );
+                    }
+                    PanelPosition::BottomLeft => {
+                        ctx.stroke(
+                            Line::new(
+                                Point::new(mouse_rect.x0 - 1.0, mouse_rect.y0),
+                                Point::new(mouse_rect.x0 - 1.0, mouse_rect.y1),
+                            ),
+                            data.config
+                                .get_color_unchecked(LapceTheme::EDITOR_CARET),
+                            2.0,
+                        );
+                    }
+                    PanelPosition::BottomRight => {
+                        ctx.stroke(
+                            Line::new(
+                                Point::new(mouse_rect.x1 + 1.0, mouse_rect.y0),
+                                Point::new(mouse_rect.x1 + 1.0, mouse_rect.y1),
+                            ),
+                            data.config
+                                .get_color_unchecked(LapceTheme::EDITOR_CARET),
+                            2.0,
                         );
                     }
-                    _ => {}
                 }
             }
-
-            ctx.clip(rect);
-            let background = match position {
-                Some(PanelPosition::BottomLeft)
-                | Some(PanelPosition::BottomRight) => LapceTheme::EDITOR_BACKGROUND,
-                _ => LapceTheme::PANEL_BACKGROUND,
-            };
-            ctx.fill(rect, data.config.get_color_unchecked(background));
-
-            let text_layout = ctx
-                .text()
-                .new_text_layout(self.text.clone())
-                .font(
-                    data.config.ui.font_family(),
-                    data.config.ui.font_size() as f64,
-                )
-                .text_color(
+            let svg = data.config.ui_svg(icon.icon);
+            ctx.draw_svg(
+                &svg,
+                icon.rect,
+                Some(
                     data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                        .clone(),
-                )
-                .build()
-                .unwrap();
-            let height = ctx.size().height;
-            let y = (height - text_layout.size().height) / 2.0;
-            ctx.draw_text(&text_layout, Point::new(10.0, y));
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+                ),
+            );
+        }
 
-            let icon_padding = 4.0;
-            for icon in self.icons.iter() {
-                if icon.rect.contains(self.mouse_pos) {
-                    ctx.fill(
-                        &icon.rect,
+        if let Some(rect) = self.maximise_toggle {
+            let maximized = data
+                .panel
+                .style
+                .get(&PanelPosition::BottomLeft)
+                .map(|s| s.maximized)
+                .unwrap_or(false)
+                || data
+                    .panel
+                    .style
+                    .get(&PanelPosition::BottomRight)
+                    .map(|s| s.maximized)
+                    .unwrap_or(false);
+            let mouse_rect = rect.inflate(icon_padding, icon_padding);
+            if mouse_rect.contains(self.mouse_pos) {
+                ctx.fill(
+                    mouse_rect,
+                    &data.config.get_hover_color(if is_bottom {
                         data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
-                    );
-                }
-                if let Some(svg) = get_svg(icon.icon) {
-                    ctx.draw_svg(
-                        &svg,
-                        icon.rect.inflate(-icon_padding, -icon_padding),
-                        Some(
-                            data.config
-                                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
-                        ),
-                    );
-                }
+                            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
+                    } else {
+                        data.config
+                            .get_color_unchecked(LapceTheme::PANEL_BACKGROUND)
+                    }),
+                );
             }
-        });
+            let svg = if maximized {
+                data.config.ui_svg(LapceIcons::PANEL_RESTORE)
+            } else {
+                data.config.ui_svg(LapceIcons::PANEL_MAXIMISE)
+            };
+            ctx.draw_svg(
+                &svg,
+                rect,
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+                ),
+            );
+        }
     }
 }
diff --git a/lapce-ui/src/picker.rs b/lapce-ui/src/picker.rs
index c419cfd052..ecc2abfd6a 100644
--- a/lapce-ui/src/picker.rs
+++ b/lapce-ui/src/picker.rs
@@ -9,7 +9,7 @@ use druid::{
 };
 use lapce_data::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::{Config, LapceTheme},
+    config::{LapceConfig, LapceIcons, LapceTheme},
     data::LapceTabData,
     picker::FilePickerData,
 };
@@ -19,7 +19,6 @@ use crate::{
     editor::view::LapceEditorView,
     explorer::{get_item_children, get_item_children_mut},
     scroll::LapceScroll,
-    svg::{file_svg, get_svg},
     tab::LapceButton,
 };
 
@@ -216,10 +215,8 @@ impl Widget<LapceTabData> for FilePickerPwd {
                 ctx.set_handled();
                 if self.icon_hit_test(mouse_event) {
                     ctx.set_cursor(&druid::Cursor::Pointer);
-                    ctx.request_paint();
                 } else {
                     ctx.clear_cursor();
-                    ctx.request_paint();
                 }
             }
             Event::MouseDown(mouse_event) => {
@@ -257,7 +254,7 @@ impl Widget<LapceTabData> for FilePickerPwd {
         data: &LapceTabData,
         env: &Env,
     ) -> Size {
-        let line_height = data.config.editor.line_height as f64;
+        let line_height = data.config.editor.line_height() as f64;
         let input_bc = BoxConstraints::tight(Size::new(
             bc.max().width - 20.0 - line_height - 30.0,
             bc.max().height,
@@ -279,7 +276,7 @@ impl Widget<LapceTabData> for FilePickerPwd {
         let rect = Size::new(icon_size, icon_size)
             .to_rect()
             .with_origin(Point::new(x, gap));
-        let svg = get_svg("arrow-up.svg").unwrap();
+        let svg = data.config.ui_svg(LapceIcons::FILE_PICKER_UP);
         self.icons.push((rect, svg));
 
         self_size
@@ -396,7 +393,10 @@ impl FilePickerExplorer {
                             self.last_left_click = None;
                             ctx.submit_command(Command::new(
                                 LAPCE_UI_COMMAND,
-                                LapceUICommand::OpenFile(node.path_buf.clone()),
+                                LapceUICommand::OpenFile(
+                                    node.path_buf.clone(),
+                                    false,
+                                ),
                                 Target::Widget(data.id),
                             ));
                             picker.active = false;
@@ -440,7 +440,7 @@ impl Widget<LapceTabData> for FilePickerExplorer {
                 let index = ((mouse_event.pos.y + self.line_height)
                     / self.line_height) as usize;
                 ctx.request_paint();
-                if let Some(item) = picker.root.get_file_node_mut(&pwd) {
+                if let Some(item) = picker.root.get_file_node(&pwd) {
                     let (_, node) = get_item_children(0, index, item);
                     if let Some(_node) = node {
                         ctx.set_cursor(&druid::Cursor::Pointer);
@@ -546,7 +546,7 @@ pub fn paint_file_node_item_by_index(
     current: usize,
     active: usize,
     hovered: Option<usize>,
-    config: &Config,
+    config: &LapceConfig,
     toggle_rects: &mut HashMap<usize, Rect>,
 ) -> usize {
     if current > max {
@@ -557,9 +557,9 @@ pub fn paint_file_node_item_by_index(
     }
     if current >= min {
         let background = if current == active {
-            Some(LapceTheme::PANEL_CURRENT)
+            Some(LapceTheme::PANEL_CURRENT_BACKGROUND)
         } else if Some(current) == hovered {
-            Some(LapceTheme::PANEL_HOVERED)
+            Some(LapceTheme::PANEL_HOVERED_BACKGROUND)
         } else {
             None
         };
@@ -582,11 +582,11 @@ pub fn paint_file_node_item_by_index(
         let padding = 15.0 * level as f64;
         if item.is_dir {
             let icon_name = if item.open {
-                "chevron-down.svg"
+                LapceIcons::ITEM_OPENED
             } else {
-                "chevron-right.svg"
+                LapceIcons::ITEM_CLOSED
             };
-            let svg = get_svg(icon_name).unwrap();
+            let svg = config.ui_svg(icon_name);
             let rect = Size::new(svg_size, svg_size)
                 .to_rect()
                 .with_origin(Point::new(1.0 + padding, svg_y));
@@ -598,21 +598,21 @@ pub fn paint_file_node_item_by_index(
             toggle_rects.insert(current, rect);
 
             let icon_name = if item.open {
-                "default_folder_opened.svg"
+                LapceIcons::DIRECTORY_OPENED
             } else {
-                "default_folder.svg"
+                LapceIcons::DIRECTORY_CLOSED
             };
-            let svg = get_svg(icon_name).unwrap();
+            let svg = config.ui_svg(icon_name);
             let rect = Size::new(svg_size, svg_size)
                 .to_rect()
                 .with_origin(Point::new(1.0 + 16.0 + padding, svg_y));
             ctx.draw_svg(&svg, rect, None);
         } else {
-            let svg = file_svg(&item.path_buf);
+            let (svg, svg_color) = config.file_svg(&item.path_buf);
             let rect = Size::new(svg_size, svg_size)
                 .to_rect()
                 .with_origin(Point::new(1.0 + 16.0 + padding, svg_y));
-            ctx.draw_svg(&svg, rect, None);
+            ctx.draw_svg(&svg, rect, svg_color);
         }
         let text_layout = ctx
             .text()
@@ -634,10 +634,7 @@ pub fn paint_file_node_item_by_index(
             .unwrap();
         ctx.draw_text(
             &text_layout,
-            Point::new(
-                38.0 + padding,
-                y + (line_height - text_layout.size().height) / 2.0,
-            ),
+            Point::new(38.0 + padding, y + text_layout.y_offset(line_height)),
         );
     }
     let mut i = current;
@@ -716,6 +713,7 @@ impl FilePickerControl {
                                         LAPCE_UI_COMMAND,
                                         LapceUICommand::OpenFile(
                                             node.path_buf.clone(),
+                                            false,
                                         ),
                                         Target::Widget(data.id),
                                     ));
@@ -753,10 +751,8 @@ impl Widget<LapceTabData> for FilePickerControl {
                 ctx.set_handled();
                 if self.icon_hit_test(mouse_event) {
                     ctx.set_cursor(&druid::Cursor::Pointer);
-                    ctx.request_paint();
                 } else {
                     ctx.clear_cursor();
-                    ctx.request_paint();
                 }
             }
             Event::MouseDown(mouse_event) => {
@@ -871,14 +867,14 @@ impl Widget<LapceTabData> for FilePickerControl {
 
         for btn in self.buttons.iter() {
             ctx.stroke(
-                &btn.rect,
+                btn.rect,
                 data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
                 1.0,
             );
             let text_size = btn.text_layout.size();
             let btn_size = btn.rect.size();
             let x = btn.rect.x0 + (btn_size.width - text_size.width) / 2.0;
-            let y = btn.rect.y0 + (btn_size.height - text_size.height) / 2.0;
+            let y = btn.rect.y0 + btn.text_layout.y_offset(btn_size.height);
             ctx.draw_text(&btn.text_layout, Point::new(x, y));
         }
     }
diff --git a/lapce-ui/src/plugin.rs b/lapce-ui/src/plugin.rs
index f8f647ce17..d4f95177cb 100644
--- a/lapce-ui/src/plugin.rs
+++ b/lapce-ui/src/plugin.rs
@@ -1,33 +1,65 @@
+use std::{collections::HashMap, sync::Arc, time::Duration};
+
 use druid::{
-    piet::{Text, TextAttribute, TextLayout as PietTextLayout, TextLayoutBuilder},
-    BoxConstraints, Color, Cursor, Env, Event, EventCtx, FontWeight, LayoutCtx,
-    LifeCycle, LifeCycleCtx, MouseEvent, PaintCtx, Point, RenderContext, Size,
-    UpdateCtx, Widget, WidgetExt, WidgetId,
+    kurbo::Line,
+    piet::{
+        InterpolationMode, PietImage, PietTextLayout, Text, TextAttribute,
+        TextLayout as TextLayoutTrait, TextLayoutBuilder,
+    },
+    BoxConstraints, Command, Cursor, Env, Event, EventCtx, FontDescriptor,
+    FontWeight, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, Point, Rect,
+    RenderContext, Size, Target, TimerToken, UpdateCtx, Widget, WidgetExt, WidgetId,
 };
+use lapce_core::command::FocusCommand;
 use lapce_data::{
-    config::LapceTheme,
-    data::{LapceTabData, PanelKind},
-    split::SplitDirection,
+    command::{CommandKind, LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND},
+    config::{LapceConfig, LapceIcons, LapceTheme},
+    data::{FocusArea, LapceData, LapceTabData},
+    markdown::layout_content::{
+        layout_content_clean_up, layouts_from_contents, LayoutContent,
+    },
+    panel::PanelKind,
+    plugin::{
+        plugin_install_status::PluginInstallType, PluginData, PluginLoadStatus,
+        PluginStatus, VoltIconKind,
+    },
+    settings::LapceSettingsFocusData,
 };
-use lapce_rpc::plugin::PluginDescription;
-use strum_macros::Display;
+use lapce_rpc::plugin::VoltID;
+use once_cell::sync::Lazy;
 
-use crate::panel::{LapcePanel, PanelHeaderKind};
+use crate::{
+    editor::view::LapceEditorView,
+    panel::{LapcePanel, PanelHeaderKind, PanelSizing},
+    scroll::LapceScroll,
+    split::LapceSplit,
+};
 
-#[derive(Display, PartialEq)]
-enum PluginStatus {
-    Installed,
-    Install,
-    Upgrade,
-}
+const VOLT_PNG: &[u8] = include_bytes!("../../extra/images/volt.png");
+static VOLT_IMAGE: Lazy<Arc<PietImage>> =
+    Lazy::new(|| Arc::new(PietImage::from_bytes(VOLT_PNG).unwrap()));
 
 pub struct Plugin {
     line_height: f64,
+    width: f64,
+    installed: bool,
+    rects: HashMap<usize, (Rect, VoltID, PluginStatus)>,
+    gap: f64,
+    height: f64,
+    last_idle_timer: TimerToken,
 }
 
 impl Plugin {
-    pub fn new() -> Self {
-        Self { line_height: 25.0 }
+    pub fn new(installed: bool) -> Self {
+        Self {
+            line_height: 25.0,
+            width: 0.0,
+            height: 0.0,
+            installed,
+            rects: HashMap::new(),
+            gap: 10.0,
+            last_idle_timer: TimerToken::INVALID,
+        }
     }
 
     pub fn new_panel(data: &LapceTabData) -> LapcePanel {
@@ -36,64 +68,488 @@ impl Plugin {
             PanelKind::Plugin,
             data.plugin.widget_id,
             split_id,
-            SplitDirection::Vertical,
-            PanelHeaderKind::Simple("Plugin".into()),
-            vec![(split_id, PanelHeaderKind::None, Self::new().boxed(), None)],
+            vec![
+                (
+                    data.plugin.installed_id,
+                    PanelHeaderKind::Simple("Installed".into()),
+                    LapceScroll::new(Self::new(true)).boxed(),
+                    PanelSizing::Flex(true),
+                ),
+                (
+                    data.plugin.uninstalled_id,
+                    PanelHeaderKind::Simple("Available".into()),
+                    LapceSplit::new(WidgetId::next())
+                        .horizontal()
+                        .with_child(
+                            LapceEditorView::new(
+                                data.plugin.search_editor,
+                                WidgetId::next(),
+                                None,
+                            )
+                            .hide_header()
+                            .hide_gutter()
+                            .padding((15.0, 15.0))
+                            .boxed(),
+                            None,
+                            100.0,
+                        )
+                        .with_flex_child(
+                            LapceScroll::new(Self::new(false)).boxed(),
+                            None,
+                            1.0,
+                            false,
+                        )
+                        .hide_border()
+                        .boxed(),
+                    PanelSizing::Flex(true),
+                ),
+            ],
         )
     }
 
-    fn hit_test<'a>(
-        &self,
-        ctx: &mut EventCtx,
-        data: &'a LapceTabData,
-        mouse_event: &MouseEvent,
-    ) -> Option<(&'a PluginDescription, PluginStatus)> {
-        let index = (mouse_event.pos.y / (self.line_height * 3.0)) as usize;
-        let plugin = data.plugins.get(index)?;
-        let status = match data
-            .installed_plugins
-            .get(&plugin.name)
-            .map(|installed| plugin.version.clone() == installed.version.clone())
-        {
-            Some(true) => PluginStatus::Installed,
-            Some(false) => PluginStatus::Upgrade,
-            None => PluginStatus::Install,
-        };
+    fn paint_install_progress_element(
+        &mut self,
+        ctx: &mut PaintCtx,
+        display_name: &str,
+        install_type: &PluginInstallType,
+        error_string: &str,
+        config: &LapceConfig,
+        i: usize,
+    ) {
+        let rect = ctx.region().bounding_box();
+
+        let y = self.line_height * i as f64 + rect.y0;
+        let x = 0.0; //0.5 * self.line_height;
+
+        let text_layout = ctx
+            .text()
+            .new_text_layout(display_name.to_string())
+            .font(config.ui.font_family(), config.ui.font_size() as f64)
+            .text_color(
+                config
+                    .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+
+        let full_percent_width = self.width;
+
+        let mut color_background =
+            config.get_color_unchecked(LapceTheme::EDITOR_FOREGROUND);
+        let rect_background = Size::new(full_percent_width, self.line_height)
+            .to_rect()
+            .with_origin(Point::new(x, y));
 
-        if status == PluginStatus::Installed {
-            return None;
+        // [INSTALLING / UNINSTALLING]
+        let mut status_text = "Installing...";
+        if !error_string.is_empty() {
+            status_text = error_string;
+            color_background = config.get_color_unchecked(LapceTheme::LAPCE_ERROR);
+        } else if *install_type == PluginInstallType::Uninstallation {
+            status_text = "Removing...";
         }
 
-        let padding = 10.0;
+        let status_text_layout = ctx
+            .text()
+            .new_text_layout(status_text.to_string())
+            .font(config.ui.font_family(), config.ui.font_size() as f64)
+            .default_attribute(TextAttribute::Style(druid::FontStyle::Italic))
+            .text_color(
+                config
+                    .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+        let text_size = status_text_layout.size();
         let text_padding = 5.0;
+        let x_state_text =
+            full_percent_width - text_size.width - text_padding * 2.0 - 0.0;
+
+        ctx.fill(rect_background, color_background);
+        ctx.draw_text(
+            &text_layout,
+            Point::new(x + text_padding, y + text_layout.y_offset(self.line_height)),
+        );
+        ctx.draw_text(
+            &status_text_layout,
+            Point::new(x_state_text, y + text_layout.y_offset(self.line_height)),
+        );
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn paint_plugin(
+        &mut self,
+        ctx: &mut PaintCtx,
+        data: &LapceTabData,
+        i: usize,
+        id: &VoltID,
+        display_name: &str,
+        description: &str,
+        author: &str,
+        version: &str,
+        status: PluginStatus,
+    ) -> Rect {
+        let y = (3.0 * self.line_height + self.gap) * i as f64 + self.gap / 2.0;
+        let x = 3.0 * self.line_height;
+
+        let icon_rect = Rect::ZERO
+            .with_origin(Point::new(x / 2.0, y + self.line_height))
+            .inflate(self.line_height * 0.75, self.line_height * 0.75);
+        if let Some(icon) = data
+            .plugin
+            .installed_icons
+            .get(id)
+            .or_else(|| data.plugin.volts.icons.get(id))
+        {
+            match icon {
+                VoltIconKind::Svg(svg) => {
+                    ctx.draw_svg(svg, icon_rect, None);
+                }
+                VoltIconKind::Image(image) => {
+                    ctx.draw_image(
+                        image,
+                        icon_rect,
+                        InterpolationMode::NearestNeighbor,
+                    );
+                }
+            }
+        } else {
+            ctx.draw_image(
+                &VOLT_IMAGE,
+                icon_rect,
+                InterpolationMode::NearestNeighbor,
+            );
+        }
 
         let text_layout = ctx
             .text()
-            .new_text_layout(status.to_string())
+            .new_text_layout(display_name.to_string())
             .font(
                 data.config.ui.font_family(),
                 data.config.ui.font_size() as f64,
             )
+            .default_attribute(TextAttribute::Weight(FontWeight::BOLD))
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::LAPCE_PLUGIN_NAME)
+                    .clone(),
+            )
             .build()
             .unwrap();
+        ctx.draw_text(
+            &text_layout,
+            Point::new(x, y + text_layout.y_offset(self.line_height)),
+        );
 
-        let text_size = text_layout.size();
-        let x = ctx.size().width - text_size.width - text_padding * 2.0 - padding;
-        let y = 3.0 * self.line_height * index as f64 + self.line_height * 2.0;
-        let rect = Size::new(text_size.width + text_padding * 2.0, self.line_height)
-            .to_rect()
-            .with_origin(Point::new(x, y));
-        if rect.contains(mouse_event.pos) {
-            Some((plugin, status))
+        // display description
+        let text_layout = ctx
+            .text()
+            .new_text_layout(description.to_string())
+            .font(
+                data.config.ui.font_family(),
+                data.config.ui.font_size() as f64,
+            )
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::LAPCE_PLUGIN_DESCRIPTION)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+        // check if text is longer than plugin panel. If so, add ellipsis after description.
+        if text_layout.layout.width() > (self.width - x - 15.0) as f32 {
+            let hit_point =
+                text_layout.hit_test_point(Point::new(self.width - x - 15.0, 0.0));
+            let end = description
+                .char_indices()
+                .filter(|(i, _)| hit_point.idx.overflowing_sub(*i).0 < 4)
+                .collect::<Vec<(usize, char)>>();
+            let end = if end.is_empty() {
+                description.len()
+            } else {
+                end[0].0
+            };
+            let description = format!("{}...", (&description[0..end]));
+            let text_layout = ctx
+                .text()
+                .new_text_layout(description)
+                .font(
+                    data.config.ui.font_family(),
+                    data.config.ui.font_size() as f64,
+                )
+                .text_color(
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_PLUGIN_DESCRIPTION)
+                        .clone(),
+                )
+                .build()
+                .unwrap();
+            ctx.draw_text(
+                &text_layout,
+                Point::new(
+                    x,
+                    y + self.line_height + text_layout.y_offset(self.line_height),
+                ),
+            );
+        } else {
+            ctx.draw_text(
+                &text_layout,
+                Point::new(
+                    x,
+                    y + self.line_height + text_layout.y_offset(self.line_height),
+                ),
+            );
+        }
+
+        let text_layout = ctx
+            .text()
+            .new_text_layout(author.to_string())
+            .font(
+                data.config.ui.font_family(),
+                data.config.ui.font_size() as f64,
+            )
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::LAPCE_PLUGIN_AUTHOR)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+        ctx.draw_text(
+            &text_layout,
+            Point::new(
+                x,
+                y + self.line_height * 2.0 + text_layout.y_offset(self.line_height),
+            ),
+        );
+
+        let size = ctx.size();
+        let padding = 10.0;
+
+        if status == PluginStatus::Install {
+            let text_layout = ctx
+                .text()
+                .new_text_layout(status.to_string())
+                .font(
+                    data.config.ui.font_family(),
+                    data.config.ui.font_size() as f64,
+                )
+                .text_color(
+                    data.config
+                        .get_color_unchecked(
+                            LapceTheme::LAPCE_BUTTON_PRIMARY_FOREGROUND,
+                        )
+                        .clone(),
+                )
+                .build()
+                .unwrap();
+            let text_size = text_layout.size();
+            let text_padding = 5.0;
+            let x = size.width - text_size.width - text_padding * 2.0 - padding;
+            let y = y + self.line_height * 2.0;
+            let rect =
+                Size::new(text_size.width + text_padding * 2.0, self.line_height)
+                    .to_rect()
+                    .with_origin(Point::new(x, y));
+            ctx.fill(
+                rect,
+                data.config.get_color_unchecked(
+                    LapceTheme::LAPCE_BUTTON_PRIMARY_BACKGROUND,
+                ),
+            );
+            ctx.draw_text(
+                &text_layout,
+                Point::new(
+                    x + text_padding,
+                    y + text_layout.y_offset(self.line_height),
+                ),
+            );
+            rect
         } else {
-            None
+            // if status is [installed, disabled, upgrade(x)], display the settings.svg
+            let rect = Size::new(15.0, 15.0).to_rect().with_origin(Point::new(
+                self.width - 24.0,
+                y + self.line_height * 2.2,
+            ));
+            ctx.draw_svg(
+                &data.config.ui_svg(LapceIcons::SETTINGS),
+                rect,
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+                ),
+            );
+
+            let color = match status {
+                PluginStatus::Installed => LapceTheme::LAPCE_PLUGIN_AUTHOR,
+                PluginStatus::Upgrade(_) => LapceTheme::LAPCE_WARN,
+                _ => LapceTheme::EDITOR_DIM,
+            };
+
+            let text_layout = ctx
+                .text()
+                .new_text_layout(if status == PluginStatus::Installed {
+                    format!("v{version}")
+                } else {
+                    format!("{status}")
+                })
+                .font(
+                    data.config.ui.font_family(),
+                    data.config.ui.font_size() as f64,
+                )
+                .text_color(data.config.get_color_unchecked(color).clone())
+                .build()
+                .unwrap();
+            let size = text_layout.size();
+            let status_x = rect.x0 - size.width - 10.0;
+            ctx.draw_text(
+                &text_layout,
+                Point::new(
+                    status_x,
+                    y + self.line_height * 2.0
+                        + text_layout.y_offset(self.line_height),
+                ),
+            );
+
+            rect
+        }
+    }
+
+    fn paint_installed(&mut self, ctx: &mut PaintCtx, data: &LapceTabData) {
+        self.rects.clear();
+
+        let rect = ctx.region().bounding_box();
+
+        let height = 3.0 * self.line_height + self.gap;
+        let start = (rect.y0 / height).floor() as usize;
+        let end = (rect.y1 / height).ceil() as usize;
+
+        for i in start..end + 1 {
+            if let Some((id, volt)) = data.plugin.installed.get_index(i) {
+                let status = data.plugin.plugin_status(id);
+                let rect = self.paint_plugin(
+                    ctx,
+                    data,
+                    i,
+                    id,
+                    &volt.display_name,
+                    &volt.description,
+                    &volt.author,
+                    &volt.version,
+                    status.clone(),
+                );
+                self.rects.insert(i, (rect, id.clone(), status));
+            }
+        }
+    }
+
+    fn paint_installation_progress(
+        &mut self,
+        ctx: &mut PaintCtx,
+        data: &LapceTabData,
+    ) {
+        for (i, (_, install_status)) in data.plugin.installing.iter().enumerate() {
+            self.paint_install_progress_element(
+                ctx,
+                install_status.plugin_name(),
+                install_status.install_type(),
+                install_status.error_string(),
+                &data.config,
+                i,
+            );
+        }
+    }
+
+    fn paint_available(&mut self, ctx: &mut PaintCtx, data: &LapceTabData) {
+        self.rects.clear();
+        match data.plugin.volts.status {
+            PluginLoadStatus::Loading => {
+                let y = self.line_height;
+                let x = self.line_height;
+                let layout = ctx
+                    .text()
+                    .new_text_layout("Loading plugin information...")
+                    .font(
+                        data.config.ui.font_family(),
+                        data.config.ui.font_size() as f64,
+                    )
+                    .default_attribute(TextAttribute::Weight(FontWeight::SEMI_BOLD))
+                    .text_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_WARN)
+                            .clone(),
+                    )
+                    .build()
+                    .unwrap();
+                ctx.draw_text(&layout, Point::new(x, y));
+            }
+            PluginLoadStatus::Failed => {
+                let y = self.line_height;
+                let x = self.line_height;
+                let layout = ctx
+                    .text()
+                    .new_text_layout("Failed to load plugin information.")
+                    .font(
+                        data.config.ui.font_family(),
+                        data.config.ui.font_size() as f64,
+                    )
+                    .default_attribute(TextAttribute::Weight(FontWeight::SEMI_BOLD))
+                    .text_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_WARN)
+                            .clone(),
+                    )
+                    .build()
+                    .unwrap();
+                ctx.draw_text(&layout, Point::new(x, y));
+            }
+            PluginLoadStatus::Success => {
+                let rect = ctx.region().bounding_box();
+                if rect.y1 + 30.0 > self.height {
+                    data.plugin.volts.load_more();
+                }
+
+                let height = 3.0 * self.line_height + self.gap;
+
+                let mut i = 0;
+                for (id, volt) in data.plugin.volts.volts.iter() {
+                    if data.plugin.installed.contains_key(id) {
+                        continue;
+                    }
+
+                    let end_height = (i + 1) as f64 * height;
+                    if end_height < rect.y0 {
+                        i += 1;
+                        continue;
+                    }
+                    if end_height - height > rect.y1 {
+                        break;
+                    }
+                    let status = data.plugin.plugin_status(id);
+                    let rect = self.paint_plugin(
+                        ctx,
+                        data,
+                        i,
+                        id,
+                        &volt.display_name,
+                        &volt.description,
+                        &volt.author,
+                        &volt.version,
+                        status.clone(),
+                    );
+                    self.rects.insert(i, (rect, id.clone(), status));
+                    i += 1;
+                }
+            }
         }
     }
 }
 
 impl Default for Plugin {
     fn default() -> Self {
-        Self::new()
+        Self::new(true)
     }
 }
 
@@ -106,16 +562,53 @@ impl Widget<LapceTabData> for Plugin {
         _env: &Env,
     ) {
         match event {
+            Event::Timer(token) if token == &self.last_idle_timer => {
+                ctx.set_handled();
+                let editor_data =
+                    data.editor_view_content(data.plugin.search_editor);
+                let query = editor_data.doc.buffer().text().to_string();
+                Arc::make_mut(&mut data.plugin).volts.update_query(query);
+            }
             Event::MouseMove(mouse_event) => {
-                if self.hit_test(ctx, data, mouse_event).is_some() {
+                if mouse_event.pos.y <= self.height {
                     ctx.set_cursor(&Cursor::Pointer);
                 } else {
                     ctx.clear_cursor();
                 }
             }
             Event::MouseDown(mouse_event) => {
-                if let Some((plugin, _)) = self.hit_test(ctx, data, mouse_event) {
-                    data.proxy.install_plugin(plugin);
+                if mouse_event.button.is_left() {
+                    let index = (mouse_event.pos.y
+                        / (self.line_height * 3.0 + self.gap))
+                        as usize;
+
+                    if let Some((rect, id, _)) = self.rects.get(&index) {
+                        if rect.contains(mouse_event.pos) {
+                            status_on_click(ctx, data, id, mouse_event.pos);
+                        } else {
+                            let volt = if self.installed {
+                                data.plugin.installed.get(id).map(|v| v.info())
+                            } else {
+                                data.plugin.volts.volts.get(id).cloned()
+                            };
+                            if let Some(volt) = volt {
+                                ctx.submit_command(Command::new(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::OpenPluginInfo(volt),
+                                    Target::Widget(data.id),
+                                ));
+                            }
+                        }
+                    }
+                }
+                if mouse_event.button.is_right() {
+                    let index = (mouse_event.pos.y
+                        / (self.line_height * 3.0 + self.gap))
+                        as usize;
+
+                    if let Some((_, id, _)) = self.rects.get(&index) {
+                        status_on_click(ctx, data, id, mouse_event.pos);
+                    }
                 }
             }
             _ => (),
@@ -133,105 +626,337 @@ impl Widget<LapceTabData> for Plugin {
 
     fn update(
         &mut self,
-        _ctx: &mut UpdateCtx,
-        _old_data: &LapceTabData,
-        _data: &LapceTabData,
+        ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
         _env: &Env,
     ) {
+        if !self.installed {
+            let old_editor_data =
+                old_data.editor_view_content(data.plugin.search_editor);
+            let editor_data = data.editor_view_content(data.plugin.search_editor);
+            if editor_data.doc.buffer().len() != old_editor_data.doc.buffer().len()
+                || editor_data.doc.buffer().text().slice_to_cow(..)
+                    != old_editor_data.doc.buffer().text().slice_to_cow(..)
+            {
+                self.last_idle_timer =
+                    ctx.request_timer(Duration::from_millis(500), None);
+            }
+        }
     }
 
     fn layout(
         &mut self,
         _ctx: &mut LayoutCtx,
         bc: &BoxConstraints,
-        _data: &LapceTabData,
+        data: &LapceTabData,
         _env: &Env,
     ) -> Size {
-        bc.max()
+        let len = if self.installed {
+            data.plugin.installed.len()
+        } else {
+            data.plugin
+                .volts
+                .volts
+                .iter()
+                .filter(|(id, _)| !data.plugin.installed.contains_key(*id))
+                .count()
+        };
+
+        self.height = (3.0 * self.line_height + self.gap) * len as f64;
+        self.width = bc.max().width;
+        Size::new(bc.max().width, bc.max().height.max(self.height))
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
-        let size = ctx.size();
-        let padding = 10.0;
+        if self.installed {
+            self.paint_installed(ctx, data);
+            self.paint_installation_progress(ctx, data);
+        } else {
+            self.paint_available(ctx, data);
+        }
+    }
+}
 
-        ctx.with_save(|ctx| {
-            let viewport = ctx.size().to_rect().inflate(-padding, 0.0);
-            ctx.clip(viewport);
+pub struct PluginInfo {
+    widget_id: WidgetId,
+    editor_tab_id: WidgetId,
+    volt_id: VoltID,
 
-            if data.plugins.is_empty() {
-                let y = self.line_height;
-                let x = self.line_height;
-                let layout = ctx
-                    .text()
-                    .new_text_layout("Failed to load plugin information")
+    padding: f64,
+    gap: f64,
+    name_text_layout: Option<PietTextLayout>,
+    desc_text_layout: Option<PietTextLayout>,
+    author_text_layout: Option<PietTextLayout>,
+    version_text_layout: Option<PietTextLayout>,
+    repo_text_layout: Option<PietTextLayout>,
+    repo: Option<(Rect, String)>,
+    line_height: f64,
+    icon_width: f64,
+    title_width: f64,
+    readme_layout: Vec<LayoutContent>,
+    status_rect: Rect,
+}
+
+impl PluginInfo {
+    fn new(widget_id: WidgetId, editor_tab_id: WidgetId, volt_id: VoltID) -> Self {
+        // TODO: Should this be an empty vec or a single string entry?
+        // let mut readme_layout = TextLayout::new();
+        // readme_layout.set_text(RichText::new(ArcStr::from("")));
+        let readme_layout = Vec::new();
+        Self {
+            widget_id,
+            editor_tab_id,
+            volt_id,
+            padding: 50.0,
+            gap: 30.0,
+            line_height: 25.0,
+            name_text_layout: None,
+            desc_text_layout: None,
+            author_text_layout: None,
+            version_text_layout: None,
+            repo_text_layout: None,
+            repo: None,
+            icon_width: 0.0,
+            title_width: 0.0,
+            readme_layout,
+            status_rect: Rect::ZERO,
+        }
+    }
+
+    pub fn new_scroll(
+        widget_id: WidgetId,
+        editor_tab_id: WidgetId,
+        volt_id: VoltID,
+    ) -> LapceScroll<LapceTabData, PluginInfo> {
+        LapceScroll::new(PluginInfo::new(widget_id, editor_tab_id, volt_id))
+    }
+
+    fn get_margin(&self, actual_width: f64) -> f64 {
+        let width = self.icon_width + self.title_width + self.padding * 4.0;
+        let width = width.max(740.0);
+        let width = width.min(actual_width - self.padding * 2.0);
+
+        (actual_width - width) / 2.0
+    }
+
+    fn request_focus(&self, ctx: &mut EventCtx, data: &mut LapceTabData) {
+        let editor_tab = data
+            .main_split
+            .editor_tabs
+            .get_mut(&self.editor_tab_id)
+            .unwrap();
+        let editor_tab = Arc::make_mut(editor_tab);
+        if let Some(index) = editor_tab
+            .children
+            .iter()
+            .position(|child| child.widget_id() == self.widget_id)
+        {
+            editor_tab.active = index;
+        }
+
+        data.main_split.active_tab = Arc::new(Some(self.editor_tab_id));
+        data.focus = Arc::new(self.widget_id);
+        data.focus_area = FocusArea::Editor;
+        ctx.request_focus();
+    }
+}
+
+impl Widget<LapceTabData> for PluginInfo {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.widget_id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        match event {
+            Event::KeyDown(key_event) => {
+                if ctx.is_focused() {
+                    let mut keypress = data.keypress.clone();
+                    let mut focus = LapceSettingsFocusData {
+                        widget_id: self.widget_id,
+                        editor_tab_id: self.editor_tab_id,
+                        main_split: data.main_split.clone(),
+                        config: data.config.clone(),
+                    };
+                    let mut_keypress = Arc::make_mut(&mut keypress);
+                    let performed_action =
+                        mut_keypress.key_down(ctx, key_event, &mut focus, env);
+                    data.keypress = keypress;
+                    data.main_split = focus.main_split;
+                    if performed_action {
+                        ctx.set_handled();
+                    }
+                }
+            }
+            Event::MouseMove(mouse_event) => {
+                let on_repo = self
+                    .repo
+                    .as_ref()
+                    .map(|(r, _)| r.contains(mouse_event.pos))
+                    .unwrap_or(false);
+                if on_repo || self.status_rect.contains(mouse_event.pos) {
+                    ctx.set_cursor(&Cursor::Pointer);
+                } else {
+                    ctx.clear_cursor();
+                }
+            }
+            Event::MouseDown(mouse_event) => {
+                if let Some((r, s)) = self.repo.as_ref() {
+                    if r.contains(mouse_event.pos) {
+                        ctx.submit_command(Command::new(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::OpenURI(s.to_string()),
+                            Target::Widget(data.id),
+                        ));
+                    }
+                }
+                if self.status_rect.contains(mouse_event.pos) {
+                    status_on_click(ctx, data, &self.volt_id, mouse_event.pos);
+                }
+            }
+            Event::Command(cmd) if cmd.is(LAPCE_COMMAND) => {
+                let cmd = cmd.get_unchecked(LAPCE_COMMAND);
+                if let CommandKind::Focus(FocusCommand::SplitClose) = &cmd.kind {
+                    data.main_split.widget_close(
+                        ctx,
+                        self.widget_id,
+                        self.editor_tab_id,
+                    );
+                }
+            }
+            Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
+                let cmd = cmd.get_unchecked(LAPCE_UI_COMMAND);
+                match cmd {
+                    LapceUICommand::Focus => {
+                        ctx.set_handled();
+                        self.request_focus(ctx, data);
+                    }
+                    LapceUICommand::UpdateVoltReadme(text) => {
+                        layout_content_clean_up(&mut self.readme_layout, data);
+                        self.readme_layout =
+                            layouts_from_contents(ctx, data, text.iter());
+                        ctx.request_layout();
+                    }
+                    _ => {}
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        _env: &Env,
+    ) {
+        if let LifeCycle::WidgetAdded = event {
+            if let Some(volt) = data.plugin.volts.volts.get(&self.volt_id) {
+                let volt = volt.clone();
+                let event_sink = ctx.get_external_handle();
+                let widget_id = self.widget_id;
+                let config = data.config.clone();
+                std::thread::spawn(move || {
+                    let _ = PluginData::download_readme(
+                        widget_id, &volt, &config, event_sink,
+                    );
+                });
+            }
+        }
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        _env: &Env,
+    ) {
+        if old_data.plugin.volts.status == PluginLoadStatus::Loading
+            && data.plugin.volts.status == PluginLoadStatus::Success
+        {
+            if let Some(volt) = data.plugin.volts.volts.get(&self.volt_id) {
+                let volt = volt.clone();
+                let event_sink = ctx.get_external_handle();
+                let widget_id = self.widget_id;
+                let config = data.config.clone();
+                std::thread::spawn(move || {
+                    let _ = PluginData::download_readme(
+                        widget_id, &volt, &config, event_sink,
+                    );
+                });
+            }
+        }
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let (width, height) = if let Some(volt) =
+            data.plugin.volts.volts.get(&self.volt_id)
+        {
+            self.name_text_layout = Some(
+                ctx.text()
+                    .new_text_layout(volt.display_name.clone())
                     .font(
                         data.config.ui.font_family(),
-                        data.config.ui.font_size() as f64,
+                        data.config.ui.font_size() as f64 * 1.5,
                     )
-                    .default_attribute(TextAttribute::Weight(FontWeight::SEMI_BOLD))
+                    .default_attribute(TextAttribute::Weight(FontWeight::BOLD))
                     .text_color(
                         data.config
-                            .get_color_unchecked(LapceTheme::LAPCE_WARN)
+                            .get_color_unchecked(LapceTheme::LAPCE_PLUGIN_NAME)
                             .clone(),
                     )
                     .build()
-                    .unwrap();
-                ctx.draw_text(&layout, Point::new(x, y));
-                return;
-            }
-
-            for (i, plugin) in data.plugins.iter().enumerate() {
-                let y = 3.0 * self.line_height * i as f64;
-                let x = 3.0 * self.line_height;
-                let text_layout = ctx
-                    .text()
-                    .new_text_layout(plugin.display_name.clone())
+                    .unwrap(),
+            );
+            self.desc_text_layout = Some(
+                ctx.text()
+                    .new_text_layout(volt.description.clone())
                     .font(
                         data.config.ui.font_family(),
                         data.config.ui.font_size() as f64,
                     )
-                    .default_attribute(TextAttribute::Weight(FontWeight::BOLD))
                     .text_color(
                         data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOCUS)
+                            .get_color_unchecked(
+                                LapceTheme::LAPCE_PLUGIN_DESCRIPTION,
+                            )
                             .clone(),
                     )
                     .build()
-                    .unwrap();
-                ctx.draw_text(
-                    &text_layout,
-                    Point::new(
-                        x,
-                        y + (self.line_height - text_layout.size().height) / 2.0,
-                    ),
-                );
-
-                let text_layout = ctx
-                    .text()
-                    .new_text_layout(plugin.description.clone())
+                    .unwrap(),
+            );
+            self.author_text_layout = Some(
+                ctx.text()
+                    .new_text_layout(volt.author.clone())
                     .font(
                         data.config.ui.font_family(),
                         data.config.ui.font_size() as f64,
                     )
                     .text_color(
                         data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                            .get_color_unchecked(LapceTheme::LAPCE_PLUGIN_AUTHOR)
                             .clone(),
                     )
                     .build()
-                    .unwrap();
-                ctx.draw_text(
-                    &text_layout,
-                    Point::new(
-                        x,
-                        y + self.line_height
-                            + (self.line_height - text_layout.size().height) / 2.0,
-                    ),
-                );
-
-                let text_layout = ctx
-                    .text()
-                    .new_text_layout(plugin.author.clone())
+                    .unwrap(),
+            );
+            self.version_text_layout = Some(
+                ctx.text()
+                    .new_text_layout(format!("v{}", volt.version))
                     .font(
                         data.config.ui.font_family(),
                         data.config.ui.font_size() as f64,
@@ -242,68 +967,395 @@ impl Widget<LapceTabData> for Plugin {
                             .clone(),
                     )
                     .build()
-                    .unwrap();
-                ctx.draw_text(
-                    &text_layout,
-                    Point::new(
-                        x,
-                        y + self.line_height * 2.0
-                            + (self.line_height - text_layout.size().height) / 2.0,
-                    ),
-                );
+                    .unwrap(),
+            );
+
+            self.icon_width = self.name_text_layout.as_ref().unwrap().size().height
+                * 2.0
+                + self.line_height * 4.0;
+            self.title_width = self
+                .name_text_layout
+                .as_ref()
+                .unwrap()
+                .size()
+                .width
+                .max(self.desc_text_layout.as_ref().unwrap().size().width);
+
+            let font = FontDescriptor::new(data.config.ui.font_family())
+                .with_size(data.config.ui.font_size() as f64);
+            let text_color = data
+                .config
+                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                .clone();
+            for layout in &mut self.readme_layout {
+                layout.set_font(font.clone());
+                layout.set_text_color(text_color.clone());
+            }
+
+            let info_width = self.padding * 4.0 + self.icon_width + self.title_width;
+
+            let actual_width = bc.max().width.max(info_width);
 
-                let status = match data
-                    .installed_plugins
-                    .get(&plugin.name)
-                    .map(|installed| installed.version == plugin.version)
-                {
-                    Some(true) => PluginStatus::Installed,
-                    Some(false) => PluginStatus::Upgrade,
-                    None => PluginStatus::Install,
-                };
-
-                let text_layout = ctx
+            let margin = self.get_margin(actual_width);
+
+            let readme_width = actual_width - margin * 2.0 - self.padding * 2.0;
+
+            let mut height = self.gap + self.icon_width + self.gap + self.gap;
+            for layout in &mut self.readme_layout {
+                layout.set_max_width(&data.images, readme_width);
+                layout.rebuild_if_needed(ctx.text(), env);
+
+                height += layout.size(&data.images, &data.config).height;
+            }
+
+            height += self.gap;
+
+            self.repo_text_layout = {
+                let text = format!(
+                    "Repository: {}",
+                    volt.repository.as_deref().unwrap_or("")
+                );
+                let layout = ctx
                     .text()
-                    .new_text_layout(status.to_string())
+                    .new_text_layout(text)
                     .font(
                         data.config.ui.font_family(),
                         data.config.ui.font_size() as f64,
                     )
                     .text_color(
                         data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
+                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
                             .clone(),
                     )
+                    .range_attribute(
+                        12..,
+                        TextAttribute::TextColor(
+                            data.config
+                                .get_color_unchecked(LapceTheme::EDITOR_LINK)
+                                .clone(),
+                        ),
+                    )
                     .build()
                     .unwrap();
-                let text_size = text_layout.size();
-                let text_padding = 5.0;
-                let x = size.width - text_size.width - text_padding * 2.0 - padding;
-                let y = y + self.line_height * 2.0;
-                let color = if status == PluginStatus::Installed {
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_DIM)
-                        .clone()
-                } else {
-                    Color::rgb8(80, 161, 79)
-                };
-                ctx.fill(
-                    Size::new(
-                        text_size.width + text_padding * 2.0,
-                        self.line_height,
-                    )
-                    .to_rect()
-                    .with_origin(Point::new(x, y)),
-                    &color,
-                );
-                ctx.draw_text(
-                    &text_layout,
-                    Point::new(
-                        x + text_padding,
-                        y + (self.line_height - text_layout.size().height) / 2.0,
-                    ),
+
+                if let Some(repo) = volt.repository.as_ref() {
+                    let padding = self.get_margin(bc.max().width.max(info_width));
+                    let shift = layout.hit_test_text_position(12).point.x;
+                    let x = padding + self.padding + self.icon_width + shift;
+                    let y = self.gap
+                        + self.name_text_layout.as_ref().unwrap().size().height
+                            * 2.0
+                        + self.line_height;
+                    let rect =
+                        Size::new(layout.size().width - shift, self.line_height)
+                            .to_rect()
+                            .with_origin(Point::new(x, y));
+                    self.repo = Some((rect, repo.to_string()));
+                }
+
+                Some(layout)
+            };
+
+            (info_width, height)
+        } else {
+            (0.0, 0.0)
+        };
+
+        Size::new(bc.max().width.max(width), bc.max().height.max(height))
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+        if let Some(name_text_layout) = self.name_text_layout.as_ref() {
+            let padding = self.get_margin(ctx.size().width);
+
+            let mut y = self.gap;
+            let size = name_text_layout.size();
+            let name_y = y;
+            y += size.height * 2.0;
+
+            let desc_text_layout = self.desc_text_layout.as_ref().unwrap();
+            let desc_y = y;
+            y += self.line_height;
+
+            let repo_text_layout = self.repo_text_layout.as_ref().unwrap();
+            let repo_y = y;
+            y += self.line_height;
+
+            let author_text_layout = self.author_text_layout.as_ref().unwrap();
+            let author_y = y;
+            y += self.line_height;
+
+            let version_text_layout = self.version_text_layout.as_ref().unwrap();
+            let button_y = y;
+
+            let icon_rect = Rect::ZERO
+                .with_origin(Point::new(
+                    padding + self.padding + self.icon_width / 2.0,
+                    name_y + self.icon_width / 2.0,
+                ))
+                .inflate(self.icon_width / 2.0 * 0.8, self.icon_width / 2.0 * 0.8);
+
+            if let Some(icon) = data.plugin.volts.icons.get(&self.volt_id) {
+                match icon {
+                    VoltIconKind::Svg(svg) => {
+                        ctx.draw_svg(svg, icon_rect, None);
+                    }
+                    VoltIconKind::Image(image) => {
+                        ctx.draw_image(
+                            image,
+                            icon_rect,
+                            InterpolationMode::NearestNeighbor,
+                        );
+                    }
+                }
+            } else {
+                ctx.draw_image(
+                    &VOLT_IMAGE,
+                    icon_rect,
+                    InterpolationMode::NearestNeighbor,
                 );
             }
-        });
+
+            let name_y_offset =
+                name_text_layout.y_offset(name_text_layout.size().height * 2.0);
+            ctx.draw_text(
+                name_text_layout,
+                Point::new(
+                    padding + self.padding + self.icon_width,
+                    name_y + name_y_offset,
+                ),
+            );
+            ctx.draw_text(
+                desc_text_layout,
+                Point::new(
+                    padding + self.padding + self.icon_width,
+                    desc_y + desc_text_layout.y_offset(self.line_height),
+                ),
+            );
+            ctx.draw_text(
+                author_text_layout,
+                Point::new(
+                    padding + self.padding + self.icon_width,
+                    author_y + author_text_layout.y_offset(self.line_height),
+                ),
+            );
+            ctx.draw_text(
+                repo_text_layout,
+                Point::new(
+                    padding + self.padding + self.icon_width,
+                    repo_y + repo_text_layout.y_offset(self.line_height),
+                ),
+            );
+
+            ctx.draw_text(
+                version_text_layout,
+                Point::new(
+                    padding + self.padding + self.icon_width,
+                    button_y + version_text_layout.y_offset(self.line_height),
+                ),
+            );
+
+            let status = data.plugin.plugin_status(&self.volt_id);
+            let text = if status == PluginStatus::Install {
+                status.to_string()
+            } else {
+                format!("{status} ▼")
+            };
+            let button_text_layout = ctx
+                .text()
+                .new_text_layout(text)
+                .font(
+                    data.config.ui.font_family(),
+                    data.config.ui.font_size() as f64,
+                )
+                .text_color(
+                    data.config
+                        .get_color_unchecked(
+                            LapceTheme::LAPCE_BUTTON_PRIMARY_FOREGROUND,
+                        )
+                        .clone(),
+                )
+                .build()
+                .unwrap();
+            let size = button_text_layout.size();
+            let rect = Size::new(size.width + 5.0 * 2.0, 0.0)
+                .to_rect()
+                .with_origin(Point::new(
+                    padding
+                        + self.padding
+                        + self.icon_width
+                        + version_text_layout.size().width
+                        + 10.0,
+                    button_y + self.line_height / 2.0,
+                ))
+                .inflate(0.0, self.line_height / 2.0);
+            ctx.fill(
+                rect,
+                data.config.get_color_unchecked(
+                    LapceTheme::LAPCE_BUTTON_PRIMARY_BACKGROUND,
+                ),
+            );
+            self.status_rect = rect;
+            ctx.draw_text(
+                &button_text_layout,
+                Point::new(
+                    rect.x0 + 5.0,
+                    button_y + button_text_layout.y_offset(self.line_height),
+                ),
+            );
+
+            y += self.line_height;
+            y += self.gap;
+
+            let line = Line::new(
+                Point::new(padding, y + 0.5),
+                Point::new(ctx.size().width - padding, y + 0.5),
+            );
+            ctx.stroke(
+                line,
+                data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                1.0,
+            );
+
+            y += self.gap;
+
+            for layout in &self.readme_layout {
+                let origin = Point::new(padding + self.padding, y);
+                layout.draw(ctx, &data.images, &data.config, origin);
+                y += layout.size(&data.images, &data.config).height;
+            }
+        }
+    }
+}
+
+fn status_on_click(
+    ctx: &mut EventCtx,
+    data: &LapceTabData,
+    id: &VoltID,
+    pos: Point,
+) {
+    let status = data.plugin.plugin_status(id);
+    if let Some(meta) = data.plugin.installed.get(id) {
+        let mut menu = druid::Menu::<LapceData>::new("Plugin");
+
+        if let PluginStatus::Upgrade(latest_version) = status {
+            let mut info = meta.info();
+            info.version = latest_version;
+            let proxy = data.proxy.clone();
+            let item = druid::MenuItem::new("Upgrade Plugin").on_activate(
+                move |_ctx, _data, _env| {
+                    let _ = PluginData::install_volt(proxy.clone(), info.clone());
+                },
+            );
+            menu = menu.entry(item);
+            menu = menu.separator();
+        }
+
+        let proxy = data.proxy.clone();
+        let local_meta = meta.clone();
+        let item = druid::MenuItem::new("Reload Plugin").on_activate(
+            move |_ctx, _data, _env| {
+                proxy.proxy_rpc.reload_volt(local_meta.clone());
+            },
+        );
+        menu = menu.entry(item);
+        if !data.workspace.kind.is_remote() {
+            let tab_id = data.id;
+            let local_meta = meta.clone();
+            let item = druid::MenuItem::new("Open Plugin Directory").on_activate(
+                move |ctx, _data, _env| {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::OpenURI(
+                            local_meta
+                                .clone()
+                                .dir
+                                .unwrap()
+                                .to_string_lossy()
+                                .to_string(),
+                        ),
+                        Target::Widget(tab_id),
+                    ));
+                },
+            );
+            menu = menu.entry(item);
+        }
+        menu = menu.separator();
+
+        let local_volt = meta.info();
+        let tab_id = data.id;
+        let item = druid::MenuItem::new("Enable")
+            .on_activate(move |ctx, _data, _env| {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::EnableVolt(local_volt.clone()),
+                    Target::Widget(tab_id),
+                ));
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::ReloadConfig,
+                    Target::Auto,
+                ));
+            })
+            .enabled(data.plugin.disabled.contains(id));
+        menu = menu.entry(item);
+
+        let local_volt = meta.info();
+        let tab_id = data.id;
+        let item = druid::MenuItem::new("Disable")
+            .on_activate(move |ctx, _data, _env| {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::DisableVolt(local_volt.clone()),
+                    Target::Widget(tab_id),
+                ));
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::ReloadConfig,
+                    Target::Auto,
+                ));
+            })
+            .enabled(!data.plugin.disabled.contains(id));
+        menu = menu.entry(item);
+
+        menu = menu.separator();
+
+        let local_volt = meta.info();
+        let tab_id = data.id;
+        let item = druid::MenuItem::new("Enable For Workspace")
+            .on_activate(move |ctx, _data, _env| {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::EnableVoltWorkspace(local_volt.clone()),
+                    Target::Widget(tab_id),
+                ));
+            })
+            .enabled(data.plugin.workspace_disabled.contains(id));
+        menu = menu.entry(item);
+
+        let local_volt = meta.info();
+        let tab_id = data.id;
+        let item = druid::MenuItem::new("Disable For Workspace")
+            .on_activate(move |ctx, _data, _env| {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::DisableVoltWorkspace(local_volt.clone()),
+                    Target::Widget(tab_id),
+                ));
+            })
+            .enabled(!data.plugin.workspace_disabled.contains(id));
+        menu = menu.entry(item);
+
+        let local_meta = meta.clone();
+        let proxy = data.proxy.clone();
+        let item = druid::MenuItem::new("Uninstall").on_activate(
+            move |_ctx, _data: &mut LapceData, _env| {
+                let _ = PluginData::remove_volt(proxy.clone(), local_meta.clone());
+            },
+        );
+        menu = menu.separator().entry(item);
+        ctx.show_context_menu::<LapceData>(menu, ctx.to_window(pos))
+    } else if let Some(volt) = data.plugin.volts.volts.get(id) {
+        let _ = PluginData::install_volt(data.proxy.clone(), volt.clone());
     }
 }
diff --git a/lapce-ui/src/problem.rs b/lapce-ui/src/problem.rs
index 4d59b5e0b0..94631123aa 100644
--- a/lapce-ui/src/problem.rs
+++ b/lapce-ui/src/problem.rs
@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::path::Path;
 
 use druid::{
     piet::{Text, TextLayout as PietTextLayout, TextLayoutBuilder},
@@ -6,51 +6,48 @@ use druid::{
     LifeCycle, LifeCycleCtx, MouseEvent, PaintCtx, Point, RenderContext, Size,
     Target, UpdateCtx, Widget, WidgetExt,
 };
-use itertools::Itertools;
 use lapce_data::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::LapceTheme,
-    data::{EditorDiagnostic, LapceTabData, PanelKind},
+    config::{LapceIcons, LapceTheme},
+    data::{EditorDiagnostic, LapceTabData},
     editor::EditorLocation,
+    panel::PanelKind,
     problem::ProblemData,
     proxy::path_from_url,
-    split::SplitDirection,
 };
 use lsp_types::DiagnosticSeverity;
 
-use crate::{
-    panel::{LapcePanel, PanelHeaderKind},
-    svg::{file_svg, get_svg},
-};
+use crate::panel::{LapcePanel, PanelHeaderKind, PanelSizing};
 
 pub fn new_problem_panel(data: &ProblemData) -> LapcePanel {
     LapcePanel::new(
         PanelKind::Problem,
         data.widget_id,
         data.split_id,
-        SplitDirection::Vertical,
-        PanelHeaderKind::Simple("Problem".into()),
         vec![
             (
                 data.error_widget_id,
                 PanelHeaderKind::Simple("Errors".into()),
-                ProblemContent::new(DiagnosticSeverity::Error).boxed(),
-                None,
+                ProblemContent::new(DiagnosticSeverity::ERROR).boxed(),
+                PanelSizing::Flex(true),
             ),
             (
                 data.warning_widget_id,
                 PanelHeaderKind::Simple("Warnings".into()),
-                ProblemContent::new(DiagnosticSeverity::Warning).boxed(),
-                None,
+                ProblemContent::new(DiagnosticSeverity::WARNING).boxed(),
+                PanelSizing::Flex(true),
             ),
         ],
     )
 }
 
+fn is_collapsed(data: &LapceTabData, path: &Path) -> bool {
+    data.problem.collapsed.get(path).copied().unwrap_or(false)
+}
+
 struct ProblemContent {
     severity: DiagnosticSeverity,
     mouse_pos: Point,
-    line_height: f64,
     content_height: f64,
 }
 
@@ -59,122 +56,164 @@ impl ProblemContent {
         Self {
             severity,
             mouse_pos: Point::ZERO,
-            line_height: 25.0,
             content_height: 0.0,
         }
     }
 
-    fn items<'a>(
-        &self,
-        data: &'a LapceTabData,
-    ) -> Vec<(&'a PathBuf, Vec<&'a EditorDiagnostic>)> {
-        let items: Vec<(&PathBuf, Vec<&EditorDiagnostic>)> = data
-            .main_split
-            .diagnostics
-            .iter()
-            .filter_map(|(path, diagnostic)| {
-                let diagnostics: Vec<&EditorDiagnostic> = diagnostic
-                    .iter()
-                    .filter(|d| d.diagnostic.severity == Some(self.severity))
-                    .collect();
-                if !diagnostics.is_empty() {
-                    Some((path, diagnostics))
-                } else {
-                    None
-                }
-            })
-            .sorted_by_key(|(path, _)| (*path).clone())
-            .collect();
-        items
-    }
-
     fn mouse_down(
         &self,
         ctx: &mut EventCtx,
         mouse_event: &MouseEvent,
         data: &LapceTabData,
     ) {
-        let n = (mouse_event.pos.y / self.line_height).floor() as usize;
+        // If it isn't hot then we don't bother checking
+        if !ctx.is_hot() {
+            return;
+        }
 
-        let items = self.items(data);
-        let mut i = 0;
+        let line_height = data.config.editor.line_height() as f64;
+        let click_line = (mouse_event.pos.y / line_height).floor() as usize;
+
+        let items = data.main_split.diagnostics_items(self.severity);
+
+        let mut line_cursor = 0;
+
+        // Skip files before clicked section.
+        let mut current_file = None;
         for (path, diagnostics) in items {
-            let diagnostics_len = diagnostics.iter().map(|d| d.lines).sum::<usize>();
-            if diagnostics_len + 1 + i < n {
-                i += diagnostics_len + 1;
-                continue;
+            let diag_lines = if is_collapsed(data, path) {
+                // If section is collapsed count only header with file name.
+                1
+            } else {
+                // Total file lines and header with file name.
+                diagnostics.iter().map(|d| d.lines).sum::<usize>() + 1 /* file name header */
+            };
+            let line_range = line_cursor..(line_cursor + diag_lines);
+
+            // Did we reach the clicked section?
+            if line_range.contains(&click_line) {
+                // The current file is what we are looking for.
+                current_file = Some((path, diagnostics));
+                break;
             }
 
-            for d in diagnostics {
-                if i > n {
-                    return;
-                }
+            // No. Move line cursor.
+            line_cursor += diag_lines;
+        }
 
-                let msg_lines = d.diagnostic.message.matches('\n').count() + 1;
-                let related_lines = d
-                    .diagnostic
-                    .related_information
-                    .as_ref()
-                    .map(|r| {
-                        r.iter()
-                            .map(|r| r.message.matches('\n').count() + 1 + 1)
-                            .sum()
-                    })
-                    .unwrap_or(0);
-                if i + 1 + msg_lines + related_lines < n {
-                    i += msg_lines + related_lines;
-                    continue;
-                }
+        // Check if we have clicked something interesting.
+        let (path, diagnostics) = if let Some(diag) = current_file {
+            diag
+        } else {
+            // The user clicked an empty area.
+            return;
+        };
+
+        // Handle click on header with file name.
+        if line_cursor == click_line {
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::ToggleProblem(path.to_path_buf()),
+                Target::Widget(data.id),
+            ));
+            return;
+        }
 
-                if ctx.is_hot() && i < n && n < i + 1 + msg_lines {
-                    ctx.submit_command(Command::new(
-                        LAPCE_UI_COMMAND,
-                        LapceUICommand::JumpToLocation(
-                            None,
-                            EditorLocation {
-                                path: path.clone(),
-                                position: Some(d.diagnostic.range.start),
-                                scroll_offset: None,
-                                history: None,
-                            },
-                        ),
-                        Target::Widget(data.id),
-                    ));
-                    return;
-                }
-                i += msg_lines;
+        assert!(
+            !is_collapsed(data, path),
+            "Can't click any element because the file is collapsed. This shouldn't happen, please report a bug."
+        );
 
-                for related in d
-                    .diagnostic
-                    .related_information
-                    .as_ref()
-                    .unwrap_or(&Vec::new())
-                {
-                    let lines = related.message.matches('\n').count() + 1 + 1;
-                    if i <= n && n <= i + lines {
-                        ctx.submit_command(Command::new(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::JumpToLocation(
-                                None,
-                                EditorLocation {
-                                    path: related
-                                        .location
-                                        .uri
-                                        .to_file_path()
-                                        .unwrap(),
-                                    position: Some(related.location.range.start),
-                                    scroll_offset: None,
-                                    history: None,
-                                },
-                            ),
-                            Target::Widget(data.id),
-                        ));
-                        return;
-                    }
-                    i += lines;
-                }
+        // Skip header.
+        line_cursor += 1;
+
+        // Skip to clicked diagnostic.
+        let mut clicked_file_diagnostic = None;
+        for file_diagnostic in diagnostics {
+            let line_range = line_cursor..(line_cursor + file_diagnostic.lines);
+
+            // Is the current diagnostic the clicked one?
+            if line_range.contains(&click_line) {
+                // We found the diagnostic we are looking for.
+                clicked_file_diagnostic = Some(file_diagnostic);
+                break;
             }
-            i += 1;
+
+            // No. Move line cursor and consume diagnostic.
+            line_cursor += file_diagnostic.lines;
+        }
+
+        // Handle current diagnostic.
+        let file_diagnostic = clicked_file_diagnostic.expect("Editor diagnostic not found. We should have found something, please report a bug");
+
+        assert!(
+            line_cursor <= click_line,
+            "Line cursor ({line_cursor}) is larger than clicked line ({click_line}). This should never happen!"
+        );
+
+        let msg_lines = message_lines(file_diagnostic);
+
+        // Widget has mouse about it and line is clicked one.
+        if (line_cursor..(line_cursor + msg_lines)).contains(&click_line) {
+            // Rust example: description without location.
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::JumpToLspLocation(
+                    None,
+                    EditorLocation {
+                        path: path.to_path_buf(),
+                        position: Some(file_diagnostic.diagnostic.range.start),
+                        scroll_offset: None,
+                        history: None,
+                    },
+                    false,
+                ),
+                Target::Widget(data.id),
+            ));
+            return;
+        }
+        line_cursor += msg_lines;
+
+        // Skip to clicked related information.
+        let related = file_diagnostic
+            .diagnostic
+            .related_information
+            .as_deref()
+            .unwrap_or(&[]);
+
+        let mut clicked_related = None;
+        for related in related {
+            let lines = related.message.lines().count();
+            let item_line_range = line_cursor..(line_cursor + lines);
+
+            // Is the current line the clicked one?
+            if item_line_range.contains(&click_line) {
+                // We found the related info we are looking for.
+                clicked_related = Some(related);
+                break;
+            }
+
+            // No. Move line cursor.
+            line_cursor += lines;
+        }
+
+        if let Some(related) = clicked_related {
+            let path = related.location.uri.to_file_path().unwrap();
+            let start = related.location.range.start;
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::JumpToLspLocation(
+                    None,
+                    EditorLocation {
+                        path,
+                        position: Some(start),
+                        scroll_offset: None,
+                        history: None,
+                    },
+                    false,
+                ),
+                Target::Widget(data.id),
+            ));
         }
     }
 }
@@ -229,6 +268,10 @@ impl Widget<LapceTabData> for ProblemContent {
         {
             ctx.request_layout();
         }
+
+        if data.problem.collapsed != old_data.problem.collapsed {
+            ctx.request_layout();
+        }
     }
 
     fn layout(
@@ -238,21 +281,26 @@ impl Widget<LapceTabData> for ProblemContent {
         data: &LapceTabData,
         _env: &Env,
     ) -> Size {
-        let items = self.items(data);
-        let n = items
+        let items = data.main_split.diagnostics_items(self.severity);
+        let lines = items
             .iter()
-            .map(|(_, diagnostics)| {
-                diagnostics.iter().map(|d| d.lines).sum::<usize>() + 1
+            .map(|(path, diagnostics)| {
+                if is_collapsed(data, path) {
+                    1
+                } else {
+                    diagnostics.iter().map(|d| d.lines).sum::<usize>() + 1 /* file name header */
+                }
             })
             .sum::<usize>();
-        let line_height = data.config.editor.line_height as f64;
-        self.content_height = line_height * n as f64;
+        let line_height = data.config.editor.line_height() as f64;
+        self.content_height = line_height * lines as f64;
 
         Size::new(bc.max().width, self.content_height.max(bc.max().height))
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
-        let line_height = data.config.editor.line_height as f64;
+        let line_height = data.config.editor.line_height() as f64;
+        let padding = (line_height - 14.0) / 2.0;
         let size = ctx.size();
         let mouse_line = (self.mouse_pos.y / line_height).floor() as usize;
 
@@ -260,32 +308,38 @@ impl Widget<LapceTabData> for ProblemContent {
         let min = (rect.y0 / line_height).floor() as usize;
         let max = (rect.y1 / line_height) as usize + 2;
 
-        let items = self.items(data);
-        let mut i = 0;
+        let ui_font_family = data.config.ui.font_family();
+        let ui_font_size = data.config.ui.font_size() as f64;
+
+        let items = data.main_split.diagnostics_items(self.severity);
+        let mut current_line = 0;
         for (path, diagnostics) in items {
-            let diagnostics_len = diagnostics.iter().map(|d| d.lines).sum::<usize>();
-            if diagnostics_len + 1 + i < min {
-                i += diagnostics_len + 1;
+            let diagnostics_len =
+                diagnostics.iter().map(|d| d.lines).sum::<usize>() + 1 /* file name header */;
+
+            if !is_collapsed(data, path) && diagnostics_len + current_line < min {
+                current_line += diagnostics_len + 1;
                 continue;
             }
 
-            let padding = (line_height - 14.0) / 2.0;
-            let svg = file_svg(path);
-            let rect = Size::new(line_height, line_height)
-                .to_rect()
-                .with_origin(Point::new(0.0, line_height * i as f64))
-                .inflate(-padding, -padding);
-            ctx.draw_svg(&svg, rect, None);
+            let svg_size = data.config.ui.icon_size() as f64;
+            let (svg, svg_color) = data.config.file_svg(path);
+            let rect =
+                Size::new(svg_size, svg_size)
+                    .to_rect()
+                    .with_origin(Point::new(
+                        (line_height - svg_size) / 2.0,
+                        line_height * current_line as f64
+                            + (line_height - svg_size) / 2.0,
+                    ));
+            ctx.draw_svg(&svg, rect, svg_color);
 
             let text_layout = ctx
                 .text()
                 .new_text_layout(
                     path.file_name().unwrap().to_str().unwrap().to_string(),
                 )
-                .font(
-                    data.config.ui.font_family(),
-                    data.config.ui.font_size() as f64,
-                )
+                .font(ui_font_family.clone(), ui_font_size)
                 .text_color(
                     data.config
                         .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
@@ -297,33 +351,34 @@ impl Widget<LapceTabData> for ProblemContent {
                 &text_layout,
                 Point::new(
                     line_height,
-                    line_height * i as f64
-                        + (line_height - text_layout.size().height) / 2.0,
+                    line_height * current_line as f64
+                        + text_layout.y_offset(line_height),
                 ),
             );
 
-            let mut path = path.clone();
-            if let Some(workspace_path) = data.workspace.path.as_ref() {
-                path = path
-                    .strip_prefix(workspace_path)
-                    .unwrap_or(&path)
-                    .to_path_buf();
+            if is_collapsed(data, path) {
+                current_line += 1;
+                continue;
             }
-            let folder = path
+
+            let folder = data
+                .workspace
+                .path
+                .as_ref()
+                .and_then(|workspace_path| path.strip_prefix(workspace_path).ok())
+                .unwrap_or(path)
                 .parent()
-                .and_then(|s| s.to_str())
+                .and_then(Path::to_str)
                 .unwrap_or("")
                 .to_string();
+
             if !folder.is_empty() {
                 let x = text_layout.size().width + line_height + 5.0;
 
                 let text_layout = ctx
                     .text()
                     .new_text_layout(folder)
-                    .font(
-                        data.config.ui.font_family(),
-                        data.config.ui.font_size() as f64,
-                    )
+                    .font(ui_font_family.clone(), ui_font_size)
                     .text_color(
                         data.config
                             .get_color_unchecked(LapceTheme::EDITOR_DIM)
@@ -335,39 +390,33 @@ impl Widget<LapceTabData> for ProblemContent {
                     &text_layout,
                     Point::new(
                         x,
-                        line_height * i as f64
-                            + (line_height - text_layout.size().height) / 2.0,
+                        line_height * current_line as f64
+                            + text_layout.y_offset(line_height),
                     ),
                 );
             }
 
             for d in diagnostics {
-                if i > max {
+                if current_line > max {
                     return;
                 }
-                let msg_lines = d.diagnostic.message.matches('\n').count() + 1;
-                let related_lines = d
-                    .diagnostic
-                    .related_information
-                    .as_ref()
-                    .map(|r| {
-                        r.iter()
-                            .map(|r| r.message.matches('\n').count() + 1 + 1)
-                            .sum()
-                    })
-                    .unwrap_or(0);
-                if i + 1 + msg_lines + related_lines < min {
-                    i += msg_lines + related_lines;
+                let msg_lines = message_lines(d);
+                let related_lines = related_line_count(d);
+                if current_line + 1 + msg_lines + related_lines < min {
+                    current_line += msg_lines + related_lines;
                     continue;
                 }
 
-                if ctx.is_hot() && i < mouse_line && mouse_line < i + 1 + msg_lines {
+                if ctx.is_hot()
+                    && current_line < mouse_line
+                    && mouse_line < current_line + 1 + msg_lines
+                {
                     ctx.fill(
                         Size::new(size.width, line_height * msg_lines as f64)
                             .to_rect()
                             .with_origin(Point::new(
                                 0.0,
-                                line_height * (i + 1) as f64,
+                                line_height * (current_line + 1) as f64,
                             )),
                         data.config
                             .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
@@ -375,14 +424,16 @@ impl Widget<LapceTabData> for ProblemContent {
                 }
 
                 let svg = match self.severity {
-                    DiagnosticSeverity::Error => get_svg("error.svg").unwrap(),
-                    _ => get_svg("warning.svg").unwrap(),
+                    DiagnosticSeverity::ERROR => {
+                        data.config.ui_svg(LapceIcons::ERROR)
+                    }
+                    _ => data.config.ui_svg(LapceIcons::WARNING),
                 };
                 let rect = Size::new(line_height, line_height)
                     .to_rect()
                     .with_origin(Point::new(
                         line_height,
-                        line_height * (i + 1) as f64,
+                        line_height * (current_line + 1) as f64,
                     ))
                     .inflate(-padding, -padding);
                 ctx.draw_svg(
@@ -390,19 +441,16 @@ impl Widget<LapceTabData> for ProblemContent {
                     rect,
                     Some(
                         data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                            .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
                     ),
                 );
 
-                for line in d.diagnostic.message.split('\n') {
-                    i += 1;
+                for line in d.diagnostic.message.lines() {
+                    current_line += 1;
                     let text_layout = ctx
                         .text()
                         .new_text_layout(line.to_string())
-                        .font(
-                            data.config.ui.font_family(),
-                            data.config.ui.font_size() as f64,
-                        )
+                        .font(ui_font_family.clone(), ui_font_size)
                         .text_color(
                             data.config
                                 .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
@@ -414,29 +462,26 @@ impl Widget<LapceTabData> for ProblemContent {
                         &text_layout,
                         Point::new(
                             2.0 * line_height,
-                            line_height * i as f64
-                                + (line_height - text_layout.size().height) / 2.0,
+                            line_height * current_line as f64
+                                + text_layout.y_offset(line_height),
                         ),
                     );
                 }
 
-                for related in d
-                    .diagnostic
-                    .related_information
-                    .as_ref()
-                    .unwrap_or(&Vec::new())
+                for related in
+                    d.diagnostic.related_information.as_deref().unwrap_or(&[])
                 {
-                    i += 1;
+                    current_line += 1;
 
-                    if ctx.is_hot() && mouse_line >= i {
-                        let lines = related.message.matches('\n').count() + 1 + 1;
-                        if mouse_line < i + lines {
+                    if ctx.is_hot() && mouse_line >= current_line {
+                        let lines = related.message.lines().count() + 1;
+                        if mouse_line < current_line + lines {
                             ctx.fill(
                                 Size::new(size.width, line_height * lines as f64)
                                     .to_rect()
                                     .with_origin(Point::new(
                                         0.0,
-                                        line_height * i as f64,
+                                        line_height * current_line as f64,
                                     )),
                                 data.config.get_color_unchecked(
                                     LapceTheme::EDITOR_CURRENT_LINE,
@@ -445,12 +490,12 @@ impl Widget<LapceTabData> for ProblemContent {
                         }
                     }
 
-                    let svg = get_svg("link.svg").unwrap();
+                    let svg = data.config.ui_svg(LapceIcons::LINK);
                     let rect = Size::new(line_height, line_height)
                         .to_rect()
                         .with_origin(Point::new(
                             2.0 * line_height,
-                            line_height * i as f64,
+                            line_height * current_line as f64,
                         ))
                         .inflate(-padding, -padding);
                     ctx.draw_svg(
@@ -458,25 +503,20 @@ impl Widget<LapceTabData> for ProblemContent {
                         rect,
                         Some(
                             data.config
-                                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                                .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
                         ),
                     );
+                    let path = path_from_url(&related.location.uri);
                     let text = format!(
                         "{}[{}, {}]:",
-                        path_from_url(&related.location.uri)
-                            .file_name()
-                            .and_then(|f| f.to_str())
-                            .unwrap_or(""),
+                        path.file_name().and_then(|f| f.to_str()).unwrap_or(""),
                         related.location.range.start.line,
                         related.location.range.start.character,
                     );
                     let text_layout = ctx
                         .text()
                         .new_text_layout(text)
-                        .font(
-                            data.config.ui.font_family(),
-                            data.config.ui.font_size() as f64,
-                        )
+                        .font(ui_font_family.clone(), ui_font_size)
                         .text_color(
                             data.config
                                 .get_color_unchecked(LapceTheme::EDITOR_DIM)
@@ -488,20 +528,17 @@ impl Widget<LapceTabData> for ProblemContent {
                         &text_layout,
                         Point::new(
                             3.0 * line_height,
-                            line_height * i as f64
-                                + (line_height - text_layout.size().height) / 2.0,
+                            line_height * current_line as f64
+                                + text_layout.y_offset(line_height),
                         ),
                     );
-                    for line in related.message.split('\n') {
-                        i += 1;
+                    for line in related.message.lines() {
+                        current_line += 1;
 
                         let text_layout = ctx
                             .text()
                             .new_text_layout(line.to_string())
-                            .font(
-                                data.config.ui.font_family(),
-                                data.config.ui.font_size() as f64,
-                            )
+                            .font(ui_font_family.clone(), ui_font_size)
                             .text_color(
                                 data.config
                                     .get_color_unchecked(LapceTheme::EDITOR_DIM)
@@ -513,15 +550,27 @@ impl Widget<LapceTabData> for ProblemContent {
                             &text_layout,
                             Point::new(
                                 3.0 * line_height,
-                                line_height * i as f64
-                                    + (line_height - text_layout.size().height)
-                                        / 2.0,
+                                line_height * current_line as f64
+                                    + text_layout.y_offset(line_height),
                             ),
                         );
                     }
                 }
             }
-            i += 1;
+            current_line += 1;
         }
     }
 }
+
+fn message_lines(diagnostic: &EditorDiagnostic) -> usize {
+    diagnostic.diagnostic.message.lines().count()
+}
+
+fn related_line_count(diagnostic: &EditorDiagnostic) -> usize {
+    diagnostic
+        .diagnostic
+        .related_information
+        .as_ref()
+        .map(|r| r.iter().map(|r| r.message.lines().count() + 1).sum())
+        .unwrap_or(0)
+}
diff --git a/lapce-ui/src/scroll.rs b/lapce-ui/src/scroll.rs
index d945932dd6..e32e4d4cd9 100644
--- a/lapce-ui/src/scroll.rs
+++ b/lapce-ui/src/scroll.rs
@@ -1,19 +1,14 @@
-use std::time::Duration;
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
-use druid::Cursor;
 use druid::{
     kurbo::{Affine, Point, Rect, Size, Vec2},
-    Insets, WidgetId,
+    theme, BoxConstraints, Cursor, Data, Env, Event, EventCtx, Insets, LayoutCtx,
+    LifeCycle, LifeCycleCtx, PaintCtx, RenderContext, TimerToken, UpdateCtx, Widget,
+    WidgetId, WidgetPod,
 };
-use druid::{
-    theme, BoxConstraints, Data, Env, Event, EventCtx, LayoutCtx, LifeCycle,
-    LifeCycleCtx, PaintCtx, RenderContext, TimerToken, UpdateCtx, Widget, WidgetPod,
-};
-
 use lapce_data::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::{Config, GetConfig, LapceTheme},
+    config::{GetConfig, LapceConfig, LapceTheme},
 };
 
 /// Minimum length for any scrollbar to be when measured on that
@@ -348,7 +343,7 @@ impl<T: Data, W: Widget<T>> Widget<T> for ClipBox<T, W> {
         let viewport = ctx.size().to_rect();
         let offset = self.viewport_origin().to_vec2();
         ctx.with_save(|ctx| {
-            ctx.clip(viewport.inflate(1.0, 0.0));
+            ctx.clip(viewport + self.child.paint_insets());
             ctx.transform(Affine::translate(-offset));
 
             let mut visible = ctx.region().clone();
@@ -413,7 +408,7 @@ impl ScrollComponent {
     pub fn calc_vertical_bar_bounds(
         &self,
         port: &Viewport,
-        config: &Config,
+        config: &LapceConfig,
         env: &Env,
     ) -> Option<Rect> {
         let viewport_size = port.rect.size();
@@ -452,7 +447,7 @@ impl ScrollComponent {
     pub fn calc_horizontal_bar_bounds(
         &self,
         port: &Viewport,
-        config: &Config,
+        config: &LapceConfig,
         env: &Env,
     ) -> Option<Rect> {
         let viewport_size = port.rect.size();
@@ -503,7 +498,7 @@ impl ScrollComponent {
         ctx: &mut PaintCtx,
         port: &Viewport,
         env: &Env,
-        config: &Config,
+        config: &LapceConfig,
     ) {
         let scroll_offset = port.rect.origin().to_vec2();
         if self.opacity <= 0.0 {
@@ -526,19 +521,23 @@ impl ScrollComponent {
         let _radius = env.get(theme::SCROLLBAR_RADIUS);
         let edge_width = env.get(theme::SCROLLBAR_EDGE_WIDTH);
 
-        // Vertical bar
-        if let Some(bounds) = self.calc_vertical_bar_bounds(port, config, env) {
-            let rect = (bounds - scroll_offset).inset(-edge_width / 2.0);
-            ctx.render_ctx.fill(rect, &brush);
-            ctx.render_ctx.stroke(rect, &border_brush, edge_width);
-        }
+        ctx.with_save(|ctx| {
+            ctx.incr_alpha_depth();
+            // Vertical bar
+            if let Some(bounds) = self.calc_vertical_bar_bounds(port, config, env) {
+                let rect = (bounds - scroll_offset).inset(-edge_width / 2.0);
+                ctx.render_ctx.fill(rect, &brush);
+                ctx.render_ctx.stroke(rect, &border_brush, edge_width);
+            }
 
-        // Horizontal bar
-        if let Some(bounds) = self.calc_horizontal_bar_bounds(port, config, env) {
-            let rect = (bounds - scroll_offset).inset(-edge_width / 2.0);
-            ctx.render_ctx.fill(rect, &brush);
-            ctx.render_ctx.stroke(rect, &border_brush, edge_width);
-        }
+            // Horizontal bar
+            if let Some(bounds) = self.calc_horizontal_bar_bounds(port, config, env)
+            {
+                let rect = (bounds - scroll_offset).inset(-edge_width / 2.0);
+                ctx.render_ctx.fill(rect, &brush);
+                ctx.render_ctx.stroke(rect, &border_brush, edge_width);
+            }
+        })
     }
 
     /// Tests if the specified point overlaps the vertical scrollbar
@@ -548,7 +547,7 @@ impl ScrollComponent {
         &self,
         port: &Viewport,
         pos: Point,
-        config: &Config,
+        config: &LapceConfig,
         env: &Env,
     ) -> bool {
         let viewport_size = port.rect.size();
@@ -570,7 +569,7 @@ impl ScrollComponent {
         &self,
         port: &Viewport,
         pos: Point,
-        config: &Config,
+        config: &LapceConfig,
         env: &Env,
     ) -> bool {
         let viewport_size = port.rect.size();
@@ -594,7 +593,7 @@ impl ScrollComponent {
         port: &mut Viewport,
         ctx: &mut EventCtx,
         event: &Event,
-        config: &Config,
+        config: &LapceConfig,
         env: &Env,
     ) {
         let viewport_size = port.rect.size();
@@ -612,6 +611,8 @@ impl ScrollComponent {
 
         if scrollbar_is_hovered || ctx.is_active() {
             ctx.set_cursor(&Cursor::Arrow);
+        } else {
+            ctx.clear_cursor();
         }
 
         if self.are_bars_held() {
@@ -676,6 +677,7 @@ impl ScrollComponent {
                     let pos = event.pos + scroll_offset;
 
                     if self.point_hits_vertical_bar(port, pos, config, env) {
+                        ctx.set_handled();
                         ctx.set_active(true);
                         self.held = BarHeldState::Vertical(
                             // The bounds must be non-empty, because the point hits the scrollbar.
@@ -684,6 +686,7 @@ impl ScrollComponent {
                         );
                     } else if self.point_hits_horizontal_bar(port, pos, config, env)
                     {
+                        ctx.set_handled();
                         ctx.set_active(true);
                         self.held = BarHeldState::Horizontal(
                             // The bounds must be non-empty, because the point hits the scrollbar.
@@ -692,8 +695,6 @@ impl ScrollComponent {
                         );
                     } else {
                     }
-
-                    ctx.set_handled();
                 }
                 // if the mouse was downed elsewhere, moved over a scroll bar and released: noop.
                 Event::MouseUp(_) => (),
@@ -741,12 +742,14 @@ impl ScrollComponent {
         port: &mut Viewport,
         ctx: &mut EventCtx,
         event: &Event,
+        config: &LapceConfig,
         env: &Env,
     ) {
         if !ctx.is_handled() {
             if let Event::Wheel(mouse) = event {
-                let mut delta = mouse.wheel_delta.round();
-                if self.vertical_scroll_for_horizontal {
+                let mut delta =
+                    mouse.wheel_delta.round() * config.editor.scroll_speed_modifier;
+                if self.vertical_scroll_for_horizontal && delta.x == 0.0 {
                     delta.x = delta.y;
                 }
                 if port.pan_by(delta) {}
@@ -783,6 +786,7 @@ impl ScrollComponent {
 pub struct LapceScroll<T, W> {
     clip: ClipBox<T, W>,
     scroll_component: ScrollComponent,
+    hide_bar: bool,
 }
 
 impl<T, W: Widget<T>> LapceScroll<T, W> {
@@ -795,6 +799,7 @@ impl<T, W: Widget<T>> LapceScroll<T, W> {
         Self {
             clip: ClipBox::new(child),
             scroll_component: ScrollComponent::new(),
+            hide_bar: false,
         }
     }
 
@@ -818,6 +823,11 @@ impl<T, W: Widget<T>> LapceScroll<T, W> {
         self
     }
 
+    pub fn hide_bar(mut self) -> Self {
+        self.hide_bar = true;
+        self
+    }
+
     pub fn vertical_scroll_for_horizontal(mut self) -> Self {
         self.scroll_component.vertical_scroll_for_horizontal = true;
         self
@@ -890,7 +900,7 @@ impl<T: Data + GetConfig, W: Widget<T>> Widget<T> for LapceScroll<T, W> {
         }
 
         self.clip.with_port(|port| {
-            scroll_component.handle_scroll(port, ctx, event, env);
+            scroll_component.handle_scroll(port, ctx, event, data.get_config(), env);
         });
 
         match event {
@@ -946,12 +956,14 @@ impl<T: Data + GetConfig, W: Widget<T>> Widget<T> for LapceScroll<T, W> {
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &T, env: &Env) {
         self.clip.paint(ctx, data, env);
-        self.scroll_component.draw_bars(
-            ctx,
-            &self.clip.viewport(),
-            env,
-            data.get_config(),
-        );
+        if !self.hide_bar {
+            self.scroll_component.draw_bars(
+                ctx,
+                &self.clip.viewport(),
+                env,
+                data.get_config(),
+            );
+        }
     }
 }
 
diff --git a/lapce-ui/src/search.rs b/lapce-ui/src/search.rs
index 3ddb27b596..3f5462f0f0 100644
--- a/lapce-ui/src/search.rs
+++ b/lapce-ui/src/search.rs
@@ -1,57 +1,308 @@
+use std::path::PathBuf;
+
 use druid::{
     piet::{Text, TextAttribute, TextLayout as PietTextLayout, TextLayoutBuilder},
     BoxConstraints, Command, Cursor, Data, Env, Event, EventCtx, FontWeight,
-    LayoutCtx, LifeCycle, LifeCycleCtx, MouseEvent, PaintCtx, Point, RenderContext,
-    Size, Target, UpdateCtx, Widget, WidgetExt, WidgetId,
+    LayoutCtx, LifeCycle, LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect,
+    RenderContext, Size, Target, UpdateCtx, Widget, WidgetExt, WidgetId, WidgetPod,
 };
+use lapce_core::command::FocusCommand;
 use lapce_data::{
-    command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::LapceTheme,
-    data::{LapceTabData, PanelKind},
-    editor::EditorLocation,
-    split::SplitDirection,
+    command::{
+        CommandKind, LapceCommand, LapceUICommand, LAPCE_COMMAND, LAPCE_UI_COMMAND,
+    },
+    config::{LapceIcons, LapceTheme},
+    data::LapceTabData,
+    editor::{EditorLocation, LineCol},
+    panel::PanelKind,
 };
 
 use crate::{
     editor::view::LapceEditorView,
-    panel::{LapcePanel, PanelHeaderKind},
+    panel::{LapcePanel, PanelHeaderKind, PanelSizing},
     scroll::LapceScroll,
     split::LapceSplit,
-    svg::file_svg,
+    tab::LapceIcon,
 };
 
+// Global search widget
+pub struct SearchInput {
+    input: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    icons: Vec<LapceIcon>,
+    parent_view_id: WidgetId,
+    result_width: f64,
+    search_input_padding: f64,
+    mouse_pos: Point,
+    background_color: Option<&'static str>,
+}
+
+impl SearchInput {
+    fn new(view_id: WidgetId) -> Self {
+        let id = WidgetId::next();
+
+        let search_input_padding = 15.0;
+        let input = LapceEditorView::new(view_id, id, None)
+            .hide_header()
+            .hide_gutter()
+            .padding((search_input_padding, search_input_padding));
+
+        let icons = vec![LapceIcon {
+            icon: LapceIcons::SEARCH_CASE_SENSITIVE,
+            rect: Rect::ZERO,
+            command: Command::new(
+                LAPCE_COMMAND,
+                LapceCommand {
+                    kind: CommandKind::Focus(FocusCommand::ToggleCaseSensitive),
+                    data: None,
+                },
+                Target::Widget(view_id),
+            ),
+        }];
+
+        Self {
+            parent_view_id: view_id,
+            result_width: 75.0,
+            input: WidgetPod::new(input.boxed()),
+            icons,
+            mouse_pos: Point::ZERO,
+            search_input_padding,
+            background_color: Some(LapceTheme::EDITOR_BACKGROUND),
+        }
+    }
+
+    pub fn clear_background_color(mut self) -> Self {
+        self.background_color = None;
+        self
+    }
+
+    fn mouse_down(&self, ctx: &mut EventCtx, mouse_event: &MouseEvent) {
+        for icon in self.icons.iter() {
+            if icon.rect.contains(mouse_event.pos) {
+                ctx.submit_command(icon.command.clone());
+            }
+        }
+    }
+
+    fn icon_hit_test(&self, mouse_event: &MouseEvent) -> bool {
+        for icon in self.icons.iter() {
+            if icon.rect.contains(mouse_event.pos) {
+                return true;
+            }
+        }
+        false
+    }
+}
+
+impl Widget<LapceTabData> for SearchInput {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        self.input.event(ctx, event, data, env);
+        match event {
+            Event::MouseMove(mouse_event) => {
+                ctx.set_handled();
+                self.mouse_pos = mouse_event.pos;
+                if self.icon_hit_test(mouse_event) {
+                    ctx.set_cursor(&druid::Cursor::Pointer);
+                } else {
+                    ctx.clear_cursor();
+                }
+            }
+            Event::MouseDown(mouse_event) => {
+                ctx.set_handled();
+                self.mouse_down(ctx, mouse_event);
+            }
+            _ => {}
+        }
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let input_bc = BoxConstraints::tight(bc.max());
+        let mut input_size = self.input.layout(ctx, &input_bc, data, env);
+        self.input.set_origin(ctx, data, env, Point::ZERO);
+        let icon_len = self.icons.len() as f64;
+        let height = input_size.height;
+        let icon_height = height - self.search_input_padding;
+        let mut width = input_size.width + self.result_width + height * icon_len;
+
+        if width > bc.max().width {
+            let input_bc = BoxConstraints::tight(Size::new(
+                bc.max().width - height * icon_len - self.result_width,
+                bc.max().height,
+            ));
+            input_size = self.input.layout(ctx, &input_bc, data, env);
+            self.input.set_origin(ctx, data, env, Point::ZERO);
+            width = input_size.width + self.result_width + height * icon_len;
+        }
+
+        for (i, icon) in self.icons.iter_mut().enumerate() {
+            icon.rect = Size::new(icon_height, icon_height)
+                .to_rect()
+                .with_origin(Point::new(
+                    input_size.width + self.result_width + i as f64 * icon_height,
+                    self.search_input_padding / 2.0,
+                ))
+                .inflate(-5.0, -5.0);
+        }
+
+        Size::new(width, height)
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.input.lifecycle(ctx, event, data, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.input.update(ctx, data, env);
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let buffer = data.editor_view_content(self.parent_view_id);
+
+        if let Some(background_color) = self.background_color {
+            let rect = ctx.size().to_rect();
+            ctx.fill(rect, data.config.get_color_unchecked(background_color));
+        }
+        self.input.paint(ctx, data, env);
+
+        let mut index = None;
+        let cursor_offset = buffer.editor.cursor.offset();
+
+        for i in 0..buffer.doc.find.borrow().occurrences().regions().len() {
+            let region = buffer.doc.find.borrow().occurrences().regions()[i];
+            if region.min() <= cursor_offset && cursor_offset <= region.max() {
+                index = Some(i);
+            }
+        }
+
+        let match_count = data
+            .search
+            .matches
+            .iter()
+            .map(|(_, matches)| matches.len())
+            .sum::<usize>();
+
+        let text_layout = ctx
+            .text()
+            .new_text_layout(if match_count > 0 {
+                match index {
+                    Some(index) => format!("{}/{}", index + 1, match_count),
+                    None => format!("{match_count} results"),
+                }
+            } else {
+                "No results".to_string()
+            })
+            .font(
+                data.config.ui.font_family(),
+                data.config.ui.font_size() as f64,
+            )
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                    .clone(),
+            )
+            .max_width(self.result_width)
+            .build()
+            .unwrap();
+
+        let input_size = self.input.layout_rect().size();
+        ctx.draw_text(
+            &text_layout,
+            Point::new(input_size.width, text_layout.y_offset(input_size.height)),
+        );
+
+        let case_sensitive = data
+            .main_split
+            .active_editor()
+            .map(|editor| {
+                let editor_data = data.editor_view_content(editor.view_id);
+                editor_data.find.case_sensitive()
+            })
+            .unwrap_or_default();
+
+        for icon in self.icons.iter() {
+            if icon.icon == LapceIcons::SEARCH_CASE_SENSITIVE && case_sensitive {
+                ctx.fill(
+                    icon.rect,
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_TAB_ACTIVE_UNDERLINE),
+                );
+            } else if icon.rect.contains(self.mouse_pos) {
+                ctx.fill(
+                    icon.rect,
+                    &data.config.get_hover_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+                    ),
+                );
+            }
+
+            let svg = data.config.ui_svg(icon.icon);
+            ctx.draw_svg(
+                &svg,
+                icon.rect.inflate(-7.0, -7.0),
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                ),
+            );
+        }
+    }
+}
+
 pub fn new_search_panel(data: &LapceTabData) -> LapcePanel {
     let editor_data = data
         .main_split
         .editors
         .get(&data.search.editor_view_id)
         .unwrap();
-    let input = LapceEditorView::new(editor_data.view_id, WidgetId::next(), None)
-        .hide_header()
-        .hide_gutter()
-        .padding((15.0, 15.0));
+
+    let search_bar = SearchInput::new(editor_data.view_id).clear_background_color();
+
     let split = LapceSplit::new(data.search.split_id)
         .horizontal()
-        .with_child(input.boxed(), None, 100.0)
+        .with_child(search_bar.boxed(), None, 100.0)
         .with_flex_child(
             LapceScroll::new(SearchContent::new().boxed())
                 .vertical()
                 .boxed(),
             None,
             1.0,
+            false,
         )
         .hide_border();
+
     LapcePanel::new(
         PanelKind::Search,
         data.search.widget_id,
         data.search.split_id,
-        SplitDirection::Vertical,
-        PanelHeaderKind::Simple("Search".into()),
         vec![(
             data.search.split_id,
             PanelHeaderKind::None,
             split.boxed(),
-            None,
+            PanelSizing::Flex(false),
         )],
     )
 }
@@ -89,17 +340,18 @@ impl SearchContent {
                 if i == n {
                     ctx.submit_command(Command::new(
                         LAPCE_UI_COMMAND,
-                        LapceUICommand::JumpToLocation(
+                        LapceUICommand::JumpToLineColLocation(
                             None,
                             EditorLocation {
                                 path: path.clone(),
-                                position: Some(lsp_types::Position {
-                                    line: *line_number as u32 - 1,
-                                    character: *start as u32,
+                                position: Some(LineCol {
+                                    line: line_number.saturating_sub(1),
+                                    column: *start,
                                 }),
                                 scroll_offset: None,
                                 history: None,
                             },
+                            false,
                         ),
                         Target::Widget(data.id),
                     ));
@@ -172,6 +424,7 @@ impl Widget<LapceTabData> for SearchContent {
             .iter()
             .map(|(_, matches)| matches.len() + 1)
             .sum::<usize>();
+
         let height = self.line_height * n as f64;
         Size::new(bc.max().width, height)
     }
@@ -194,7 +447,6 @@ impl Widget<LapceTabData> for SearchContent {
         let max = (rect.y1 / self.line_height) as usize + 2;
 
         let focus_color = data.config.get_color_unchecked(LapceTheme::EDITOR_FOCUS);
-        let padding = (self.line_height - 14.0) / 2.0;
         let mut i = 0;
         for (path, matches) in data.search.matches.iter() {
             if matches.len() + 1 + i < min {
@@ -202,12 +454,17 @@ impl Widget<LapceTabData> for SearchContent {
                 continue;
             }
 
-            let svg = file_svg(path);
-            let rect = Size::new(self.line_height, self.line_height)
-                .to_rect()
-                .with_origin(Point::new(0.0, self.line_height * i as f64))
-                .inflate(-padding, -padding);
-            ctx.draw_svg(&svg, rect, None);
+            let svg_size = data.config.ui.icon_size() as f64;
+            let (svg, svg_color) = data.config.file_svg(path);
+            let rect =
+                Size::new(svg_size, svg_size)
+                    .to_rect()
+                    .with_origin(Point::new(
+                        (self.line_height - svg_size) / 2.0,
+                        self.line_height * i as f64
+                            + (self.line_height - svg_size) / 2.0,
+                    ));
+            ctx.draw_svg(&svg, rect, svg_color);
 
             let text_layout = ctx
                 .text()
@@ -230,11 +487,11 @@ impl Widget<LapceTabData> for SearchContent {
                 Point::new(
                     self.line_height,
                     self.line_height * i as f64
-                        + (self.line_height - text_layout.size().height) / 2.0,
+                        + text_layout.y_offset(self.line_height),
                 ),
             );
 
-            let mut path = path.clone();
+            let mut path: PathBuf = path.clone();
             if let Some(workspace_path) = data.workspace.path.as_ref() {
                 path = path
                     .strip_prefix(workspace_path)
@@ -268,7 +525,7 @@ impl Widget<LapceTabData> for SearchContent {
                     Point::new(
                         x,
                         self.line_height * i as f64
-                            + (self.line_height - text_layout.size().height) / 2.0,
+                            + text_layout.y_offset(self.line_height),
                     ),
                 );
             }
@@ -279,10 +536,24 @@ impl Widget<LapceTabData> for SearchContent {
                     return;
                 }
 
+                let whitespace_count: usize =
+                    if data.config.ui.trim_search_results_whitespace() {
+                        line.chars()
+                            .take_while(|ch| ch.is_whitespace() && *ch != '\n')
+                            .map(|ch| ch.len_utf8())
+                            .sum()
+                    } else {
+                        0
+                    };
+
                 if i >= min {
                     let mut text_layout = ctx
                         .text()
-                        .new_text_layout(format!("{line_number}: {line}"))
+                        .new_text_layout(format!(
+                            "{}: {}",
+                            line_number,
+                            &line[whitespace_count..]
+                        ))
                         .font(
                             data.config.ui.font_family(),
                             data.config.ui.font_size() as f64,
@@ -294,11 +565,13 @@ impl Widget<LapceTabData> for SearchContent {
                         );
                     let prefix = line_number.to_string().len() + 2;
                     text_layout = text_layout.range_attribute(
-                        *start + prefix..*end + prefix,
+                        *start + prefix - whitespace_count
+                            ..*end + prefix - whitespace_count,
                         TextAttribute::TextColor(focus_color.clone()),
                     );
                     text_layout = text_layout.range_attribute(
-                        *start + prefix..*end + prefix,
+                        *start + prefix - whitespace_count
+                            ..*end + prefix - whitespace_count,
                         TextAttribute::Weight(FontWeight::BOLD),
                     );
                     let text_layout = text_layout.build().unwrap();
@@ -307,8 +580,7 @@ impl Widget<LapceTabData> for SearchContent {
                         Point::new(
                             self.line_height,
                             self.line_height * i as f64
-                                + (self.line_height - text_layout.size().height)
-                                    / 2.0,
+                                + text_layout.y_offset(self.line_height),
                         ),
                     );
                 }
diff --git a/lapce-ui/src/settings.rs b/lapce-ui/src/settings.rs
index 0eef8bc10b..5b8affc57c 100644
--- a/lapce-ui/src/settings.rs
+++ b/lapce-ui/src/settings.rs
@@ -1,14 +1,16 @@
-use std::{collections::HashMap, fmt::Display, sync::Arc, time::Duration};
+use hashbrown::HashMap;
+use std::{fmt::Display, sync::Arc, time::Duration};
 
 use druid::{
     kurbo::{BezPath, Line},
     piet::{
         PietText, PietTextLayout, Text, TextAttribute, TextLayout, TextLayoutBuilder,
     },
-    BoxConstraints, Command, Env, Event, EventCtx, ExtEventSink, FontWeight,
-    LayoutCtx, LifeCycle, LifeCycleCtx, Modifiers, MouseEvent, PaintCtx, Point,
-    Rect, RenderContext, Size, Target, TimerToken, UpdateCtx, Widget, WidgetExt,
-    WidgetId, WidgetPod,
+    widget::Padding,
+    BoxConstraints, Command, Cursor, Env, Event, EventCtx, ExtEventSink, FontWeight,
+    LayoutCtx, LifeCycle, LifeCycleCtx, Modifiers, PaintCtx, Point, Rect,
+    RenderContext, Size, Target, TimerToken, UpdateCtx, Widget, WidgetExt, WidgetId,
+    WidgetPod,
 };
 use inflector::Inflector;
 use itertools::Itertools;
@@ -21,36 +23,37 @@ use lapce_data::{
         CommandExecuted, CommandKind, LapceUICommand, LAPCE_COMMAND,
         LAPCE_UI_COMMAND,
     },
-    config::{EditorConfig, LapceConfig, LapceTheme, TerminalConfig, UIConfig},
-    data::{LapceEditorData, LapceTabData},
+    config::{
+        CoreConfig, DropdownInfo, EditorConfig, LapceTheme, TerminalConfig, UIConfig,
+    },
+    data::{FocusArea, LapceEditorData, LapceTabData},
     document::{BufferContent, Document},
+    dropdown::DropdownData,
     keypress::KeyPressFocus,
-    settings::{LapceSettingsFocusData, SettingsValueKind},
+    settings::{LapceSettingsFocusData, LapceSettingsKind, SettingsValueKind},
 };
-use xi_rope::Rope;
+use lapce_xi_rope::Rope;
+use serde::Serialize;
 
 use crate::{
+    button::Button,
+    dropdown::DropdownSelector,
     editor::view::LapceEditorView,
     keymap::LapceKeymap,
     scroll::{LapcePadding, LapceScroll},
-    split::LapceSplit,
 };
 
-enum LapceSettingsKind {
-    Core,
-    UI,
-    Editor,
-    Terminal,
-}
-
 pub struct LapceSettingsPanel {
     widget_id: WidgetId,
     editor_tab_id: WidgetId,
-    active: usize,
+    active: LapceSettingsKind,
     content_rect: Rect,
     switcher_rect: Rect,
-    switcher_line_height: f64,
-    children: Vec<WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>>,
+    switcher: WidgetPod<LapceTabData, LapceScroll<LapceTabData, SettingsSwitcher>>,
+    children: HashMap<
+        LapceSettingsKind,
+        WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    >,
 }
 
 impl LapceSettingsPanel {
@@ -58,57 +61,121 @@ impl LapceSettingsPanel {
         data: &LapceTabData,
         widget_id: WidgetId,
         editor_tab_id: WidgetId,
+        keymap_input_view_id: WidgetId,
     ) -> Self {
-        let children = vec![
-            WidgetPod::new(
-                LapceSettings::new_split(LapceSettingsKind::Core, data).boxed(),
-            ),
+        let mut children = HashMap::new();
+        children.insert(
+            LapceSettingsKind::Core,
             WidgetPod::new(
-                LapceSettings::new_split(LapceSettingsKind::UI, data).boxed(),
+                LapceSettings::new_scroll(LapceSettingsKind::Core).boxed(),
             ),
+        );
+        children.insert(
+            LapceSettingsKind::UI,
+            WidgetPod::new(LapceSettings::new_scroll(LapceSettingsKind::UI).boxed()),
+        );
+        children.insert(
+            LapceSettingsKind::Editor,
             WidgetPod::new(
-                LapceSettings::new_split(LapceSettingsKind::Editor, data).boxed(),
+                LapceSettings::new_scroll(LapceSettingsKind::Editor).boxed(),
             ),
+        );
+        children.insert(
+            LapceSettingsKind::Terminal,
             WidgetPod::new(
-                LapceSettings::new_split(LapceSettingsKind::Terminal, data).boxed(),
+                LapceSettings::new_scroll(LapceSettingsKind::Terminal).boxed(),
             ),
-            WidgetPod::new(ThemeSettings::new_boxed().boxed()),
-            WidgetPod::new(LapceKeymap::new_split(data).boxed()),
-        ];
+        );
+        children.insert(
+            LapceSettingsKind::Theme,
+            WidgetPod::new(LapceScroll::new(ThemeSettings::new(data)).boxed()),
+        );
+        children.insert(
+            LapceSettingsKind::Keymap,
+            WidgetPod::new(LapceKeymap::new_split(keymap_input_view_id).boxed()),
+        );
+        for (volt_id, volt) in data.plugin.installed.iter() {
+            if volt.config.is_some() {
+                children.insert(
+                    LapceSettingsKind::Plugin(volt_id.clone()),
+                    WidgetPod::new(
+                        LapceSettings::new_scroll(LapceSettingsKind::Plugin(
+                            volt_id.clone(),
+                        ))
+                        .boxed(),
+                    ),
+                );
+            }
+        }
+
+        let switcher = LapceScroll::new(SettingsSwitcher::new(widget_id));
+
         Self {
             widget_id,
             editor_tab_id,
-            active: 0,
             content_rect: Rect::ZERO,
             switcher_rect: Rect::ZERO,
-            switcher_line_height: 40.0,
+            switcher: WidgetPod::new(switcher),
             children,
+            active: LapceSettingsKind::Core,
         }
     }
 
-    fn mouse_down(
-        &mut self,
-        ctx: &mut EventCtx,
-        mouse_event: &MouseEvent,
-        data: &mut LapceTabData,
-    ) {
-        if self.switcher_rect.contains(mouse_event.pos) {
-            let index = ((mouse_event.pos.y - self.switcher_rect.y0)
-                / self.switcher_line_height)
-                .floor() as usize;
-            if index < self.children.len() {
-                self.active = index;
-                ctx.request_layout();
-            }
-            ctx.set_handled();
-            self.request_focus(ctx, data);
+    fn request_focus(&self, ctx: &mut EventCtx, data: &mut LapceTabData) {
+        let editor_tab = data
+            .main_split
+            .editor_tabs
+            .get_mut(&self.editor_tab_id)
+            .unwrap();
+        let editor_tab = Arc::make_mut(editor_tab);
+        if let Some(index) = editor_tab
+            .children
+            .iter()
+            .position(|child| child.widget_id() == self.widget_id)
+        {
+            editor_tab.active = index;
         }
-    }
 
-    fn request_focus(&self, ctx: &mut EventCtx, data: &mut LapceTabData) {
         data.main_split.active_tab = Arc::new(Some(self.editor_tab_id));
+        data.focus = Arc::new(self.widget_id);
+        data.focus_area = FocusArea::Editor;
         ctx.request_focus();
     }
+
+    fn update_plugins(&mut self, ctx: &mut EventCtx, data: &LapceTabData) {
+        let mut children_changed = false;
+        self.children.retain(|kind, _| {
+            if let LapceSettingsKind::Plugin(volt_id) = &kind {
+                if !data.plugin.installed.contains_key(volt_id) {
+                    if self.active == *kind {
+                        self.active = LapceSettingsKind::Core;
+                        self.switcher
+                            .widget_mut()
+                            .child_mut()
+                            .set_active(self.active.clone(), data);
+                    }
+                    children_changed = true;
+                    return false;
+                }
+            }
+            true
+        });
+        for (_, volt) in data.plugin.installed.iter() {
+            if volt.config.is_some() {
+                let kind = LapceSettingsKind::Plugin(volt.id());
+                if !self.children.contains_key(&kind) {
+                    self.children.insert(
+                        kind.clone(),
+                        WidgetPod::new(LapceSettings::new_scroll(kind).boxed()),
+                    );
+                    children_changed = true;
+                }
+            }
+        }
+        if children_changed {
+            ctx.children_changed();
+        }
+    }
 }
 
 impl Widget<LapceTabData> for LapceSettingsPanel {
@@ -131,6 +198,7 @@ impl Widget<LapceTabData> for LapceSettingsPanel {
                         widget_id: self.widget_id,
                         editor_tab_id: self.editor_tab_id,
                         main_split: data.main_split.clone(),
+                        config: data.config.clone(),
                     };
                     let mut_keypress = Arc::make_mut(&mut keypress);
                     let performed_action =
@@ -142,15 +210,13 @@ impl Widget<LapceTabData> for LapceSettingsPanel {
                     }
                 }
             }
-            Event::MouseDown(mouse_event) => {
-                self.mouse_down(ctx, mouse_event, data);
-            }
             Event::Command(cmd) if cmd.is(LAPCE_COMMAND) => {
                 let cmd = cmd.get_unchecked(LAPCE_COMMAND);
                 let mut focus = LapceSettingsFocusData {
                     widget_id: self.widget_id,
                     editor_tab_id: self.editor_tab_id,
                     main_split: data.main_split.clone(),
+                    config: data.config.clone(),
                 };
                 if focus.run_command(ctx, cmd, None, Modifiers::empty(), env)
                     == CommandExecuted::Yes
@@ -167,12 +233,30 @@ impl Widget<LapceTabData> for LapceSettingsPanel {
                         self.request_focus(ctx, data);
                     }
                     LapceUICommand::ShowSettings => {
+                        let kind = LapceSettingsKind::Core;
+                        self.active = kind.clone();
+                        self.switcher
+                            .widget_mut()
+                            .child_mut()
+                            .set_active(kind, data);
                         ctx.request_focus();
-                        self.active = 0;
                     }
                     LapceUICommand::ShowKeybindings => {
+                        let kind = LapceSettingsKind::Keymap;
+                        self.active = kind.clone();
+                        self.switcher
+                            .widget_mut()
+                            .child_mut()
+                            .set_active(kind, data);
                         ctx.request_focus();
-                        self.active = 5;
+                    }
+                    LapceUICommand::ShowSettingsKind(kind) => {
+                        self.active = kind.clone();
+                        self.switcher
+                            .widget_mut()
+                            .child_mut()
+                            .set_active(kind.clone(), data);
+                        ctx.request_layout();
                     }
                     LapceUICommand::Hide => {
                         if let Some(active) = *data.main_split.active {
@@ -183,6 +267,11 @@ impl Widget<LapceTabData> for LapceSettingsPanel {
                             ));
                         }
                     }
+                    LapceUICommand::VoltInstalled(_, _)
+                    | LapceUICommand::VoltRemoved(_, _) => {
+                        ctx.set_handled();
+                        self.update_plugins(ctx, data);
+                    }
                     _ => (),
                 }
             }
@@ -193,12 +282,13 @@ impl Widget<LapceTabData> for LapceSettingsPanel {
             return;
         }
 
+        self.switcher.event(ctx, event, data, env);
         if event.should_propagate_to_hidden() {
-            for child in self.children.iter_mut() {
+            for child in self.children.values_mut() {
                 child.event(ctx, event, data, env);
             }
-        } else {
-            self.children[self.active].event(ctx, event, data, env);
+        } else if let Some(child) = self.children.get_mut(&self.active) {
+            child.event(ctx, event, data, env);
         }
     }
 
@@ -209,7 +299,8 @@ impl Widget<LapceTabData> for LapceSettingsPanel {
         data: &LapceTabData,
         env: &Env,
     ) {
-        for child in self.children.iter_mut() {
+        self.switcher.lifecycle(ctx, event, data, env);
+        for child in self.children.values_mut() {
             child.lifecycle(ctx, event, data, env);
         }
     }
@@ -221,7 +312,8 @@ impl Widget<LapceTabData> for LapceSettingsPanel {
         data: &LapceTabData,
         env: &Env,
     ) {
-        for child in self.children.iter_mut() {
+        self.switcher.update(ctx, data, env);
+        for child in self.children.values_mut() {
             child.update(ctx, data, env);
         }
     }
@@ -237,83 +329,38 @@ impl Widget<LapceTabData> for LapceSettingsPanel {
         let origin = Point::ZERO;
         self.content_rect = self_size.to_rect().with_origin(origin).round();
 
+        let switcher_size = self.switcher.layout(
+            ctx,
+            &BoxConstraints::new(Size::ZERO, bc.max()),
+            data,
+            env,
+        );
+        self.switcher.set_origin(ctx, data, env, Point::ZERO);
+
         self.switcher_rect = Size::new(150.0, self_size.height)
             .to_rect()
             .with_origin(Point::ZERO)
             .round();
 
         let content_size = Size::new(
-            self_size.width - self.switcher_rect.width() - 20.0,
+            self_size.width - switcher_size.width - 20.0,
             self_size.height,
         );
-        let content_origin = Point::new(self.switcher_rect.width() + 20.0, 0.0);
+        let content_origin = Point::new(switcher_size.width + 20.0, 0.0);
         let content_bc = BoxConstraints::tight(content_size);
-        let child = &mut self.children[self.active];
-        child.layout(ctx, &content_bc, data, env);
-        child.set_origin(ctx, data, env, content_origin);
+        if let Some(child) = self.children.get_mut(&self.active) {
+            child.layout(ctx, &content_bc, data, env);
+            child.set_origin(ctx, data, env, content_origin);
+        }
 
         self_size
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
-        ctx.fill(
-            self.content_rect,
-            data.config
-                .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
-        );
-
-        ctx.fill(
-            Size::new(self.switcher_rect.width(), self.switcher_line_height)
-                .to_rect()
-                .with_origin(
-                    self.switcher_rect.origin()
-                        + (0.0, self.active as f64 * self.switcher_line_height),
-                ),
-            data.config
-                .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
-        );
-
-        ctx.with_save(|ctx| {
-            ctx.clip(self.switcher_rect);
-            const SETTINGS_SECTIONS: [&str; 6] = [
-                "Coreの設定",
-                "UIの設定",
-                "Editorの設定",
-                "Terminalの設定",
-                "Themeの設定",
-                "Keybindings",
-            ];
-
-            for (i, text) in SETTINGS_SECTIONS.into_iter().enumerate() {
-                let text_layout = ctx
-                    .text()
-                    .new_text_layout(text)
-                    .font(
-                        data.config.ui.font_family(),
-                        (data.config.ui.font_size() + 1) as f64,
-                    )
-                    .text_color(
-                        data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                            .clone(),
-                    )
-                    .build()
-                    .unwrap();
-                let text_size = text_layout.size();
-                ctx.draw_text(
-                    &text_layout,
-                    self.switcher_rect.origin()
-                        + (
-                            20.0,
-                            i as f64 * self.switcher_line_height
-                                + (self.switcher_line_height / 2.0
-                                    - text_size.height / 2.0),
-                        ),
-                );
-            }
-        });
-
-        self.children[self.active].paint(ctx, data, env);
+        self.switcher.paint(ctx, data, env);
+        if let Some(child) = self.children.get_mut(&self.active) {
+            child.paint(ctx, data, env);
+        }
 
         ctx.stroke(
             Line::new(
@@ -333,107 +380,106 @@ struct LapceSettings {
 }
 
 impl LapceSettings {
-    pub fn new_split(kind: LapceSettingsKind, data: &LapceTabData) -> LapceSplit {
-        let settings = LapceScroll::new(
-            Self {
-                widget_id: WidgetId::next(),
-                kind,
-                children: Vec::new(),
-            }
-            .boxed(),
-        );
-
-        let _input = LapceEditorView::new(
-            data.settings.settings_view_id,
-            WidgetId::next(),
-            None,
-        )
-        .hide_header()
-        .hide_gutter()
-        .padding((15.0, 15.0, 0.0, 15.0));
-
-        let split = LapceSplit::new(data.settings.settings_split_id)
-            .horizontal()
-            //.with_child(input.boxed(), None, 55.0)
-            .with_flex_child(settings.boxed(), None, 1.0);
-
-        split
+    pub fn new_scroll(
+        kind: LapceSettingsKind,
+    ) -> LapceScroll<LapceTabData, LapceSettings> {
+        LapceScroll::new(Self {
+            widget_id: WidgetId::next(),
+            kind,
+            children: Vec::new(),
+        })
     }
 
     fn update_children(&mut self, ctx: &mut EventCtx, data: &mut LapceTabData) {
+        fn into_settings_map(
+            data: &impl Serialize,
+        ) -> serde_json::Map<String, serde_json::Value> {
+            match serde_json::to_value(data).unwrap() {
+                serde_json::Value::Object(h) => h,
+                _ => serde_json::Map::default(),
+            }
+        }
+
         self.children.clear();
 
-        let (kind, fields, descs, settings) = match self.kind {
-            LapceSettingsKind::Core => {
-                let settings: HashMap<String, serde_json::Value> =
-                    serde_json::from_value(
-                        serde_json::to_value(&data.config.lapce).unwrap(),
-                    )
-                    .unwrap();
-                (
-                    "lapce".to_string(),
-                    LapceConfig::FIELDS.to_vec(),
-                    LapceConfig::DESCS.to_vec(),
-                    settings,
-                )
-            }
-            LapceSettingsKind::UI => {
-                let settings: HashMap<String, serde_json::Value> =
-                    serde_json::from_value(
-                        serde_json::to_value(&data.config.ui).unwrap(),
-                    )
-                    .unwrap();
-                (
-                    "ui".to_string(),
-                    UIConfig::FIELDS.to_vec(),
-                    UIConfig::DESCS.to_vec(),
-                    settings,
-                )
-            }
-            LapceSettingsKind::Editor => {
-                let settings: HashMap<String, serde_json::Value> =
-                    serde_json::from_value(
-                        serde_json::to_value(&data.config.editor).unwrap(),
-                    )
-                    .unwrap();
-                (
-                    "editor".to_string(),
-                    EditorConfig::FIELDS.to_vec(),
-                    EditorConfig::DESCS.to_vec(),
-                    settings,
-                )
+        let (kind, fields, descs, mut settings) = match &self.kind {
+            LapceSettingsKind::Core => (
+                "core",
+                &CoreConfig::FIELDS[..],
+                &CoreConfig::DESCS[..],
+                into_settings_map(&data.config.core),
+            ),
+            LapceSettingsKind::UI => (
+                "ui",
+                &UIConfig::FIELDS[..],
+                &UIConfig::DESCS[..],
+                into_settings_map(&data.config.ui),
+            ),
+            LapceSettingsKind::Editor => (
+                "editor",
+                &EditorConfig::FIELDS[..],
+                &EditorConfig::DESCS[..],
+                into_settings_map(&data.config.editor),
+            ),
+            LapceSettingsKind::Terminal => (
+                "terminal",
+                &TerminalConfig::FIELDS[..],
+                &TerminalConfig::DESCS[..],
+                into_settings_map(&data.config.terminal),
+            ),
+            LapceSettingsKind::Theme | LapceSettingsKind::Keymap => {
+                return;
             }
-            LapceSettingsKind::Terminal => {
-                let settings: HashMap<String, serde_json::Value> =
-                    serde_json::from_value(
-                        serde_json::to_value(&data.config.terminal).unwrap(),
-                    )
-                    .unwrap();
-                (
-                    "terminal".to_string(),
-                    TerminalConfig::FIELDS.to_vec(),
-                    TerminalConfig::DESCS.to_vec(),
-                    settings,
-                )
+            LapceSettingsKind::Plugin(volt_id) => {
+                if let Some(volt) = data.plugin.installed.get(volt_id).cloned() {
+                    if let Some(config) = volt.config.as_ref() {
+                        for (key, config) in
+                            config.iter().sorted_by_key(|(key, _)| *key)
+                        {
+                            let mut value = config.default.clone();
+                            if let Some(plugin_config) =
+                                data.config.plugins.get(&volt.name)
+                            {
+                                if let Some(v) = plugin_config.get(key) {
+                                    value = v.clone();
+                                }
+                            }
+                            // TODO: let plugins define dropdowns
+                            let value = SettingsValue::from(value);
+                            self.children.push(create_settings_item(
+                                data,
+                                volt.name.clone(),
+                                key.to_string(),
+                                config.description.clone(),
+                                value,
+                                ctx.get_external_handle(),
+                            ));
+                        }
+                    }
+                }
+                return;
             }
         };
 
-        for (i, field) in fields.into_iter().enumerate() {
+        for (field, desc) in fields.iter().zip(descs.iter()) {
+            // TODO(dbuga): we should generate kebab-case field names
             let field = field.replace('_', "-");
-            self.children.push(WidgetPod::new(
-                LapcePadding::new(
-                    (10.0, 10.0),
-                    LapceSettingsItem::new(
-                        data,
-                        kind.clone(),
-                        field.clone(),
-                        descs[i].to_string(),
-                        settings.get(&field).unwrap().clone(),
-                        ctx.get_external_handle(),
-                    ),
-                )
-                .boxed(),
-            ))
+            let value = if let Some(dropdown) =
+                data.config.get_dropdown_info(kind, &field)
+            {
+                SettingsValue::Dropdown(dropdown)
+            } else {
+                let value = settings.remove(&field).unwrap();
+                SettingsValue::from(value)
+            };
+            self.children.push(create_settings_item(
+                data,
+                kind.to_string(),
+                field,
+                desc.to_string(),
+                value,
+                ctx.get_external_handle(),
+            ));
         }
     }
 }
@@ -490,14 +536,6 @@ impl Widget<LapceTabData> for LapceSettings {
         data: &LapceTabData,
         env: &Env,
     ) -> Size {
-        if self.children.is_empty() {
-            ctx.submit_command(Command::new(
-                LAPCE_UI_COMMAND,
-                LapceUICommand::InitChildren,
-                Target::Widget(self.widget_id),
-            ));
-        }
-
         let mut y = 0.0;
         for child in self.children.iter_mut() {
             let size = child.layout(ctx, bc, data, env);
@@ -520,109 +558,182 @@ struct LapceSettingsItemKeypress {
     cursor: usize,
 }
 
-struct LapceSettingsItem {
+#[derive(Debug, Clone)]
+pub enum SettingsValue {
+    Float(f64),
+    Integer(i64),
+    String(String),
+    Bool(bool),
+    Dropdown(DropdownInfo),
+    Empty,
+}
+impl From<serde_json::Value> for SettingsValue {
+    fn from(v: serde_json::Value) -> Self {
+        match v {
+            serde_json::Value::Number(n) => {
+                if n.is_f64() {
+                    SettingsValue::Float(n.as_f64().unwrap())
+                } else {
+                    SettingsValue::Integer(n.as_i64().unwrap())
+                }
+            }
+            serde_json::Value::String(s) => SettingsValue::String(s),
+            serde_json::Value::Bool(b) => SettingsValue::Bool(b),
+            _ => SettingsValue::Empty,
+        }
+    }
+}
+
+/// Create a settings item widget  
+/// Includes padding.
+fn create_settings_item(
+    data: &mut LapceTabData,
     kind: String,
-    name: String,
+    key: String,
     desc: String,
-    value: serde_json::Value,
-    padding: f64,
-    checkbox_width: f64,
-    input_max_width: f64,
+    value: SettingsValue,
+    event_sink: ExtEventSink,
+) -> WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>> {
+    let insets = (10.0, 10.0);
+    match value {
+        // TODO: deduplicate these matches, the first three are just inputs with a string!
+        SettingsValue::Float(n) => WidgetPod::new(
+            LapcePadding::new(
+                insets,
+                InputSettingsItem::new(
+                    data,
+                    kind,
+                    key,
+                    desc,
+                    event_sink,
+                    n.to_string(),
+                    SettingsValueKind::Float,
+                ),
+            )
+            .boxed(),
+        ),
+        SettingsValue::Integer(n) => WidgetPod::new(
+            LapcePadding::new(
+                insets,
+                InputSettingsItem::new(
+                    data,
+                    kind,
+                    key,
+                    desc,
+                    event_sink,
+                    n.to_string(),
+                    SettingsValueKind::Integer,
+                ),
+            )
+            .boxed(),
+        ),
+        SettingsValue::String(s) => WidgetPod::new(
+            LapcePadding::new(
+                insets,
+                InputSettingsItem::new(
+                    data,
+                    kind,
+                    key,
+                    desc,
+                    event_sink,
+                    s,
+                    SettingsValueKind::String,
+                ),
+            )
+            .boxed(),
+        ),
+        SettingsValue::Bool(checked) => WidgetPod::new(
+            LapcePadding::new(
+                insets,
+                CheckBoxSettingsItem::new(key, kind, desc, checked),
+            )
+            .boxed(),
+        ),
+        SettingsValue::Dropdown(dropdown) => WidgetPod::new(
+            LapcePadding::new(
+                insets,
+                DropdownSettingsItem::new(data, key, kind, desc, dropdown),
+            )
+            .boxed(),
+        ),
+        SettingsValue::Empty => WidgetPod::new(
+            LapcePadding::new(insets, EmptySettingsItem::new(key, kind, desc))
+                .boxed(),
+        ),
+    }
+}
+
+/// Shared information between each setting item
+struct SettingsItemInfo {
     width: f64,
-    cursor: usize,
-    input: String,
-    value_changed: bool,
-    last_idle_timer: TimerToken,
+    padding: f64,
+
+    /// Key of the field
+    key: String,
+    kind: String,
+    desc: String,
 
     name_text: Option<PietTextLayout>,
     desc_text: Option<PietTextLayout>,
-    value_text: Option<Option<PietTextLayout>>,
-    input_rect: Rect,
-    input_widget: Option<WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>>,
-}
 
-impl LapceSettingsItem {
+    /// Timer which keeps track of when it was last edited  
+    /// So that it can update
+    last_idle_timer: TimerToken,
+}
+impl SettingsItemInfo {
     /// The amount of time to wait for the next key press before storing settings.
     const SAVE_DELAY: Duration = Duration::from_millis(500);
 
-    pub fn new(
-        data: &mut LapceTabData,
-        kind: String,
-        key: String,
-        desc: String,
-        value: serde_json::Value,
-        event_sink: ExtEventSink,
-    ) -> Self {
-        let input = match &value {
-            serde_json::Value::Number(n) => {
-                Some((n.to_string(), SettingsValueKind::Number))
-            }
-            serde_json::Value::String(s) => {
-                Some((s.to_string(), SettingsValueKind::String))
-            }
-            serde_json::Value::Array(_)
-            | serde_json::Value::Object(_)
-            | serde_json::Value::Bool(_)
-            | serde_json::Value::Null => None,
-        };
-        let input = input.map(|(input, value_kind)| {
-            let name = format!("{kind}.{key}");
-            let content = BufferContent::SettingsValue(
-                name.clone(),
-                value_kind,
-                kind.clone(),
-                key.clone(),
-            );
-
-            let mut doc = Document::new(
-                content.clone(),
-                data.id,
-                event_sink,
-                data.proxy.clone(),
-            );
-            doc.reload(Rope::from(&input), true);
-            data.main_split.value_docs.insert(name, Arc::new(doc));
-            let editor =
-                LapceEditorData::new(None, None, None, content, &data.config);
-            let view_id = editor.view_id;
-            let input = LapceEditorView::new(editor.view_id, editor.editor_id, None)
-                .hide_header()
-                .hide_gutter()
-                .padding((5.0, 0.0, 50.0, 0.0));
-            data.main_split.editors.insert(view_id, Arc::new(editor));
-            (view_id, WidgetPod::new(input.boxed()))
-        });
-        let input_widget = input.map(|i| i.1);
-        Self {
+    fn new(key: String, kind: String, desc: String) -> Self {
+        SettingsItemInfo {
+            width: 0.0,
+            padding: 10.0,
+            key,
             kind,
-            name: key,
             desc,
-            value,
-            padding: 10.0,
-            width: 0.0,
-            checkbox_width: 20.0,
-            input_max_width: 500.0,
-            cursor: 0,
-            input: "".to_string(),
-            value_changed: false,
-            last_idle_timer: TimerToken::INVALID,
-
             name_text: None,
             desc_text: None,
-            value_text: None,
-            input_rect: Rect::ZERO,
-            input_widget,
+            last_idle_timer: TimerToken::INVALID,
         }
     }
 
+    /// Check if the last-idle-timer has been triggered, and thus it should probably update
+    fn idle_timer_triggered(&self, token: TimerToken) -> bool {
+        token == self.last_idle_timer
+    }
+
+    fn clear_text_layout_cache(&mut self) {
+        self.name_text = None;
+        self.desc_text = None;
+    }
+
+    /// Get the text layout for the name of the setting item, creating it if it has changed
+    /// or if it is not already initialize.
     pub fn name(
         &mut self,
         text: &mut PietText,
         data: &LapceTabData,
     ) -> &PietTextLayout {
         if self.name_text.is_none() {
+            let mut splits = self.key.rsplitn(2, '.');
+            let mut name_text = String::new();
+
+            if let Some(name) = splits.next() {
+                name_text.reserve(self.key.len());
+                if let Some(title) = splits.next() {
+                    for (i, part) in title.split('.').enumerate() {
+                        if i > 0 {
+                            name_text.push_str(" > ");
+                        }
+                        name_text.push_str(&part.to_title_case());
+                    }
+                    name_text.push_str(": ");
+                }
+                name_text.push_str(&name.to_title_case());
+            }
+
             let text_layout = text
-                .new_text_layout(self.name.to_title_case())
+                .new_text_layout(name_text)
                 .font(
                     data.config.ui.font_family(),
                     (data.config.ui.font_size() + 1) as f64,
@@ -643,17 +754,17 @@ impl LapceSettingsItem {
         self.name_text.as_ref().unwrap()
     }
 
+    /// Get the text layout for the description of the setting item, creating it if it doesn't exist.  
+    /// `extra_width` is used for when there are other rendered elements on the same line as the description,  
+    /// such as the checkbox.
     pub fn desc(
         &mut self,
         text: &mut PietText,
         data: &LapceTabData,
+        extra_width: f64,
     ) -> &PietTextLayout {
         if self.desc_text.is_none() {
-            let max_width = if self.value.is_boolean() {
-                self.width - self.checkbox_width
-            } else {
-                self.width
-            };
+            let max_width = self.width - extra_width;
             let text_layout = text
                 .new_text_layout(self.desc.clone())
                 .font(
@@ -675,74 +786,599 @@ impl LapceSettingsItem {
         self.desc_text.as_ref().unwrap()
     }
 
-    pub fn value(
-        &mut self,
-        text: &mut PietText,
+    fn update_settings(
+        &self,
         data: &LapceTabData,
-    ) -> Option<&PietTextLayout> {
-        if self.value_text.is_none() {
-            let value = match &self.value {
-                serde_json::Value::Number(n) => Some(n.to_string()),
-                serde_json::Value::String(s) => Some(s.to_string()),
-                serde_json::Value::Array(_)
-                | serde_json::Value::Object(_)
-                | serde_json::Value::Bool(_)
-                | serde_json::Value::Null => None,
-            };
-            let text_layout = value.map(|value| {
-                self.input = value.to_string();
-                text.new_text_layout(value)
-                    .font(
-                        data.config.ui.font_family(),
-                        data.config.ui.font_size() as f64,
-                    )
-                    .text_color(
-                        data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                            .clone(),
-                    )
-                    .build()
-                    .unwrap()
-            });
-            self.value_text = Some(text_layout);
-        }
-
-        self.value_text.as_ref().unwrap().as_ref()
-    }
-
-    fn clear_text_layout_cache(&mut self) {
-        self.name_text = None;
-        self.desc_text = None;
-        self.value_text = None;
+        ctx: &mut EventCtx,
+        value: serde_json::Value,
+    ) {
+        ctx.submit_command(Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::UpdateSettingsFile {
+                kind: self.kind.clone(),
+                key: self.key.clone(),
+                value,
+            },
+            Target::Widget(data.id),
+        ));
     }
-}
 
-impl KeyPressFocus for LapceSettingsItemKeypress {
-    fn get_mode(&self) -> Mode {
-        Mode::Insert
+    fn update(
+        &mut self,
+        _ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        _env: &Env,
+    ) {
+        if data.config.id != old_data.config.id {
+            self.clear_text_layout_cache();
+        }
     }
 
-    fn check_condition(&self, _condition: &str) -> bool {
-        false
-    }
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        _env: &Env,
+        extra_width: f64,
+    ) -> Size {
+        let width = bc.max().width;
+        if width != self.width {
+            self.width = width;
+            self.clear_text_layout_cache();
+        }
+        let text = ctx.text();
+        let name = self.name(text, data).size();
+        let desc = self.desc(text, data, extra_width).size();
+        let mut height = name.height + desc.height + (self.padding * 3.0);
+        height = height.round();
 
-    fn receive_char(&mut self, _ctx: &mut EventCtx, c: &str) {
-        self.input.insert_str(self.cursor, c);
-        self.cursor += c.len();
+        Size::new(self.width, height)
     }
 
-    fn run_command(
+    /// Paint the name of the setting and the description  
+    /// `extra_width` decides how the description should be shifted to the right  
+    /// Returns the y position of the description, so that you can relative to it.
+    fn paint(
         &mut self,
-        _ctx: &mut EventCtx,
-        command: &lapce_data::command::LapceCommand,
-        _count: Option<usize>,
-        _mods: Modifiers,
+        ctx: &mut PaintCtx,
+        data: &LapceTabData,
         _env: &Env,
-    ) -> CommandExecuted {
-        match &command.kind {
-            CommandKind::Move(cmd) => match cmd {
-                MoveCommand::Right => {
-                    self.cursor += 1;
+        extra_width: f64,
+    ) -> f64 {
+        let mut y = 0.0;
+        let padding = self.padding;
+
+        let rect = ctx
+            .size()
+            .to_rect()
+            .inflate(0.0, padding)
+            .inset((padding, 0.0, -30.0, 0.0));
+        if ctx.is_hot() {
+            ctx.fill(
+                rect,
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
+            );
+        }
+
+        let text = ctx.text();
+        let text = self.name(text, data);
+        y += padding;
+        ctx.draw_text(text, Point::new(0.0, y));
+        y += text.size().height;
+        y += padding;
+
+        let desc_y = y;
+
+        let text = ctx.text();
+        let desc = self.desc(text, data, extra_width);
+        ctx.draw_text(desc, Point::new(extra_width, y));
+
+        desc_y
+    }
+}
+
+/// An uneditable settings item. Typically this is because it must
+/// be edited directly in the `settings.toml` file.
+struct EmptySettingsItem {
+    info: SettingsItemInfo,
+}
+impl EmptySettingsItem {
+    fn new(key: String, kind: String, desc: String) -> Self {
+        EmptySettingsItem {
+            info: SettingsItemInfo::new(key, kind, desc),
+        }
+    }
+}
+impl Widget<LapceTabData> for EmptySettingsItem {
+    fn event(
+        &mut self,
+        _ctx: &mut EventCtx,
+        _event: &Event,
+        _data: &mut LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+        if let LifeCycle::HotChanged(_) = event {
+            ctx.request_paint();
+        }
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.info.update(ctx, old_data, data, env);
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        self.info.layout(ctx, bc, data, env, 0.0)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        self.info.paint(ctx, data, env, 0.0);
+    }
+}
+
+struct CheckBoxSettingsItem {
+    checked: bool,
+    checkbox_width: f64,
+    info: SettingsItemInfo,
+}
+
+impl CheckBoxSettingsItem {
+    fn new(key: String, kind: String, desc: String, checked: bool) -> Self {
+        Self {
+            checked,
+            checkbox_width: 20.0,
+            info: SettingsItemInfo::new(key, kind, desc),
+        }
+    }
+}
+
+impl Widget<LapceTabData> for CheckBoxSettingsItem {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        _env: &Env,
+    ) {
+        match event {
+            Event::MouseMove(_) => ctx.set_handled(),
+            Event::MouseDown(mouse_event) => {
+                let rect = Size::new(self.checkbox_width, self.checkbox_width)
+                    .to_rect()
+                    .with_origin(Point::new(
+                        0.0,
+                        self.info.name(ctx.text(), data).size().height
+                            + self.info.padding * 2.0
+                            + 4.0,
+                    ));
+                if rect.contains(mouse_event.pos) {
+                    self.checked = !self.checked;
+                    self.info.last_idle_timer =
+                        ctx.request_timer(SettingsItemInfo::SAVE_DELAY, None);
+                }
+            }
+            Event::Timer(token) if self.info.idle_timer_triggered(*token) => {
+                ctx.set_handled();
+                self.info.update_settings(
+                    data,
+                    ctx,
+                    serde_json::Value::Bool(self.checked),
+                );
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+        if let LifeCycle::HotChanged(_) = event {
+            ctx.request_paint();
+        }
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.info.update(ctx, old_data, data, env);
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        self.info.layout(ctx, bc, data, env, self.checkbox_width)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let y = self.info.paint(ctx, data, env, self.checkbox_width);
+
+        let width = 13.0;
+        let height = 13.0;
+        let origin = Point::new(0.0, y + 4.0);
+        let rect = Size::new(width, height).to_rect().with_origin(origin);
+        ctx.stroke(
+            rect,
+            data.config
+                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+            1.0,
+        );
+        if self.checked {
+            let mut path = BezPath::new();
+            path.move_to((origin.x + 3.0, origin.y + 7.0));
+            path.line_to((origin.x + 6.0, origin.y + 9.5));
+            path.line_to((origin.x + 10.0, origin.y + 3.0));
+            ctx.stroke(
+                path,
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                2.0,
+            );
+        }
+    }
+}
+
+struct DropdownSettingsItem {
+    widget_id: WidgetId,
+    dropdown: WidgetPod<DropdownData<String, ()>, DropdownSelector<String, ()>>,
+
+    // We could have map of the key to a function to get the current items and selected item?
+    info: SettingsItemInfo,
+}
+impl DropdownSettingsItem {
+    fn new(
+        data: &mut LapceTabData,
+        key: String,
+        kind: String,
+        desc: String,
+        info: DropdownInfo,
+    ) -> Self {
+        let widget_id = WidgetId::next();
+
+        let dropdown = WidgetPod::new(DropdownSelector::default());
+
+        // Create our data and insert it into the settings data structure so we can access it later
+        let mut dropdown_data =
+            DropdownData::new(data.config.clone(), widget_id, ());
+        dropdown_data.update_from_info(info);
+
+        let settings = Arc::make_mut(&mut data.settings);
+        settings
+            .dropdown_data
+            .entry(kind.clone())
+            .or_insert_with(im::HashMap::new)
+            .insert(key.clone(), dropdown_data);
+
+        Self {
+            widget_id,
+            dropdown,
+
+            info: SettingsItemInfo::new(key, kind, desc),
+        }
+    }
+
+    /// Get the `DropdownData` for this widget, cloning it with the curent config
+    fn get_data_clone(&self, data: &LapceTabData) -> DropdownData<String, ()> {
+        data.settings
+            .dropdown_data
+            .get(&self.info.kind)
+            .unwrap()
+            .get(&self.info.key)
+            .unwrap()
+            .clone_with(data.config.clone())
+    }
+}
+impl Widget<LapceTabData> for DropdownSettingsItem {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.widget_id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        match event {
+            Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
+                let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
+                if let LapceUICommand::DropdownItemSelected = command {
+                    // We just update the settings whenever you select an item in the dropdown
+                    // since it is unlikely that you're changing it fast enough to to be an
+                    // issue
+                    let dropdown_data = self.get_data_clone(data);
+                    if let Some(value) = dropdown_data.get_active_item() {
+                        self.info.update_settings(
+                            data,
+                            ctx,
+                            serde_json::json!(value),
+                        );
+                    }
+                }
+            }
+            _ => {}
+        }
+
+        let settings = Arc::make_mut(&mut data.settings);
+        let dropdown_data = settings
+            .dropdown_data
+            .get_mut(&self.info.kind)
+            .unwrap()
+            .get_mut(&self.info.key)
+            .unwrap();
+        dropdown_data.update_data(data.config.clone());
+
+        self.dropdown.event(ctx, event, dropdown_data, env);
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        let dropdown = self.get_data_clone(data);
+        self.dropdown.lifecycle(ctx, event, &dropdown, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        let dropdown = self.get_data_clone(data);
+        self.dropdown.update(ctx, &dropdown, env);
+        self.info.update(ctx, old_data, data, env)
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let size = self.info.layout(ctx, bc, data, env, 0.0);
+
+        let dropdown = self.get_data_clone(data);
+        let dropdown_size = self.dropdown.layout(ctx, bc, &dropdown, env);
+        self.dropdown
+            .set_origin(ctx, &dropdown, env, Point::new(0.0, size.height));
+
+        ctx.set_paint_insets(4000.0);
+
+        Size::new(size.width, (size.height + dropdown_size.height).ceil())
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        self.info.paint(ctx, data, env, 0.0);
+        let dropdown = self.get_data_clone(data);
+        self.dropdown.paint(ctx, &dropdown, env);
+    }
+}
+
+// TODO: Split input into separate kinds for for int/f64/string?
+struct InputSettingsItem {
+    /// ID of the editor so that it can be easily accessed
+    view_id: WidgetId,
+
+    input: WidgetPod<LapceTabData, Padding<LapceTabData, LapceEditorView>>,
+
+    /// The value kind of the setting item, so that we know what to parse it as.
+    value_kind: SettingsValueKind,
+
+    info: SettingsItemInfo,
+}
+
+impl InputSettingsItem {
+    fn new(
+        data: &mut LapceTabData,
+        kind: String,
+        key: String,
+        desc: String,
+        event_sink: ExtEventSink,
+        input: String,
+        value_kind: SettingsValueKind,
+    ) -> Self {
+        let name = format!("{kind}.{key}");
+        let content = BufferContent::SettingsValue(name.clone());
+
+        let mut doc =
+            Document::new(content.clone(), data.id, event_sink, data.proxy.clone());
+        doc.reload(Rope::from(&input), true);
+        data.main_split.value_docs.insert(name, Arc::new(doc));
+        let editor = LapceEditorData::new(None, None, None, content, &data.config);
+        let view_id = editor.view_id;
+        let input = LapceEditorView::new(editor.view_id, editor.editor_id, None)
+            .hide_header()
+            .hide_gutter()
+            .padding((5.0, 0.0, 50.0, 0.0));
+        data.main_split.editors.insert(view_id, Arc::new(editor));
+
+        Self {
+            view_id,
+            input: WidgetPod::new(input),
+            value_kind,
+            info: SettingsItemInfo::new(key, kind, desc),
+        }
+    }
+}
+
+impl Widget<LapceTabData> for InputSettingsItem {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        // Don't alert the input to mouse-wheel events
+        if !matches!(event, Event::Wheel(_)) {
+            self.input.event(ctx, event, data, env);
+        }
+
+        match event {
+            Event::MouseMove(_) => ctx.set_handled(),
+            // Save settings when it has been some time since the last edit
+            Event::Timer(token) if self.info.idle_timer_triggered(*token) => {
+                ctx.set_handled();
+                let editor_data = data.editor_view_content(self.view_id);
+
+                if let BufferContent::SettingsValue(_) = &editor_data.editor.content
+                {
+                    let content = editor_data.doc.buffer().to_string();
+                    let value = match self.value_kind {
+                        SettingsValueKind::String => {
+                            Some(serde_json::json!(content))
+                        }
+                        SettingsValueKind::Integer => {
+                            content.parse::<i64>().ok().map(|n| serde_json::json!(n))
+                        }
+                        SettingsValueKind::Float => {
+                            content.parse::<f64>().ok().map(|n| serde_json::json!(n))
+                        }
+                        // Should be unreachable
+                        SettingsValueKind::Bool => None,
+                    };
+
+                    if let Some(value) = value {
+                        self.info.update_settings(data, ctx, value);
+                    }
+                } else {
+                    log::warn!("Setting Input editor view id referred to editor with non-settings-value BufferContent");
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        if let LifeCycle::HotChanged(_) = event {
+            ctx.request_paint();
+        }
+
+        self.input.lifecycle(ctx, event, data, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.info.update(ctx, old_data, data, env);
+
+        let old_editor_data = old_data.editor_view_content(self.view_id);
+        let editor_data = data.editor_view_content(self.view_id);
+
+        // If there's been changes, then report that the last time we were idle is right now
+        // TODO: minor. These usages of slice_to_cow are fine, since all settings are short values and thus
+        // it can probably just return a `Cow::Borrowed(_)`, but there's probably a better way to compare
+        if !editor_data.doc.buffer().is_pristine()
+            && (editor_data.doc.buffer().len() != old_editor_data.doc.buffer().len()
+                || editor_data.doc.buffer().text().slice_to_cow(..)
+                    != old_editor_data.doc.buffer().text().slice_to_cow(..))
+        {
+            self.info.last_idle_timer =
+                ctx.request_timer(SettingsItemInfo::SAVE_DELAY, None);
+        }
+
+        self.input.update(ctx, data, env);
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let size = self.info.layout(ctx, bc, data, env, 0.0);
+
+        let input_size = self.input.layout(ctx, bc, data, env);
+        self.input
+            .set_origin(ctx, data, env, Point::new(0.0, size.height));
+
+        Size::new(size.width, (size.height + input_size.height).ceil())
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        self.info.paint(ctx, data, env, 0.0);
+        self.input.paint(ctx, data, env);
+    }
+}
+
+impl KeyPressFocus for LapceSettingsItemKeypress {
+    fn get_mode(&self) -> Mode {
+        Mode::Insert
+    }
+
+    fn check_condition(&self, _condition: &str) -> bool {
+        false
+    }
+
+    fn receive_char(&mut self, _ctx: &mut EventCtx, c: &str) {
+        self.input.insert_str(self.cursor, c);
+        self.cursor += c.len();
+    }
+
+    fn run_command(
+        &mut self,
+        _ctx: &mut EventCtx,
+        command: &lapce_data::command::LapceCommand,
+        _count: Option<usize>,
+        _mods: Modifiers,
+        _env: &Env,
+    ) -> CommandExecuted {
+        match &command.kind {
+            CommandKind::Move(cmd) => match cmd {
+                MoveCommand::Right => {
+                    self.cursor += 1;
                     if self.cursor > self.input.len() {
                         self.cursor = self.input.len();
                     }
@@ -768,7 +1404,39 @@ impl KeyPressFocus for LapceSettingsItemKeypress {
     }
 }
 
-impl Widget<LapceTabData> for LapceSettingsItem {
+#[derive(Clone, Copy)]
+pub enum ThemeKind {
+    Base,
+    UI,
+    Syntax,
+}
+
+impl Display for ThemeKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            ThemeKind::Base => "color-theme.base",
+            ThemeKind::UI => "color-theme.ui",
+            ThemeKind::Syntax => "color-theme.syntax",
+        })
+    }
+}
+
+pub struct ThemeSettings {
+    base: WidgetPod<LapceTabData, ThemeSection>,
+    ui: WidgetPod<LapceTabData, ThemeSection>,
+    syntax: WidgetPod<LapceTabData, ThemeSection>,
+}
+
+impl ThemeSettings {
+    pub fn new(data: &LapceTabData) -> Self {
+        let base = WidgetPod::new(ThemeSection::new(data, ThemeKind::Base));
+        let ui = WidgetPod::new(ThemeSection::new(data, ThemeKind::UI));
+        let syntax = WidgetPod::new(ThemeSection::new(data, ThemeKind::Syntax));
+        Self { base, ui, syntax }
+    }
+}
+
+impl Widget<LapceTabData> for ThemeSettings {
     fn event(
         &mut self,
         ctx: &mut EventCtx,
@@ -776,93 +1444,447 @@ impl Widget<LapceTabData> for LapceSettingsItem {
         data: &mut LapceTabData,
         env: &Env,
     ) {
-        if let Some(input) = self.input_widget.as_mut() {
-            match event {
-                Event::Wheel(_) => {}
-                _ => {
-                    input.event(ctx, event, data, env);
-                }
+        self.base.event(ctx, event, data, env);
+        self.ui.event(ctx, event, data, env);
+        self.syntax.event(ctx, event, data, env);
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.base.lifecycle(ctx, event, data, env);
+        self.ui.lifecycle(ctx, event, data, env);
+        self.syntax.lifecycle(ctx, event, data, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.base.update(ctx, data, env);
+        self.ui.update(ctx, data, env);
+        self.syntax.update(ctx, data, env);
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let base_size = self.base.layout(ctx, bc, data, env);
+        self.base.set_origin(ctx, data, env, Point::ZERO);
+
+        let ui_size = self.ui.layout(ctx, bc, data, env);
+        self.ui
+            .set_origin(ctx, data, env, Point::new(0.0, base_size.height));
+
+        let syntax_size = self.syntax.layout(ctx, bc, data, env);
+        self.syntax.set_origin(
+            ctx,
+            data,
+            env,
+            Point::new(0.0, base_size.height + ui_size.height),
+        );
+
+        Size::new(
+            base_size
+                .width
+                .max(ui_size.width)
+                .max(syntax_size.width)
+                .max(bc.max().width),
+            (base_size.height + ui_size.height + syntax_size.height)
+                .max(bc.max().height),
+        )
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        self.base.paint(ctx, data, env);
+        self.ui.paint(ctx, data, env);
+        self.syntax.paint(ctx, data, env);
+    }
+}
+
+pub struct ThemeSection {
+    header_height: f64,
+    kind: ThemeKind,
+    colors: Vec<String>,
+    text_layouts: Option<Vec<PietTextLayout>>,
+    items: Vec<WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>>,
+}
+
+impl ThemeSection {
+    fn new(data: &LapceTabData, kind: ThemeKind) -> Self {
+        let theme_color = &data.config.color;
+        let mut colors: Vec<String> = match kind {
+            ThemeKind::Base => theme_color
+                .base
+                .keys()
+                .into_iter()
+                .map(ToString::to_string)
+                .collect(),
+            ThemeKind::UI => theme_color.ui.keys().map(Clone::clone).collect(),
+            ThemeKind::Syntax => {
+                theme_color.syntax.keys().map(Clone::clone).collect()
             }
+        };
+        colors.sort_unstable();
+
+        Self {
+            header_height: 40.0,
+            kind,
+            items: Vec::new(),
+            text_layouts: None,
+            colors,
         }
-        match event {
-            Event::MouseDown(mouse_event) => {
-                // ctx.request_focus();
-                let input = self.input.clone();
-                if let Some(_text) = self.value(ctx.text(), data) {
-                    let text = ctx
-                        .text()
-                        .new_text_layout(input)
-                        .font(
-                            data.config.ui.font_family(),
-                            data.config.ui.font_size() as f64,
-                        )
-                        .text_color(
-                            data.config
-                                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                                .clone(),
-                        )
-                        .build()
-                        .unwrap();
-                    let mut height = self.name(ctx.text(), data).size().height;
-                    height += self.desc(ctx.text(), data).size().height;
-                    height += self.padding * 2.0 + self.padding;
-
-                    let rect = Size::new(
-                        ctx.size().width.min(self.input_max_width),
-                        text.size().height,
-                    )
-                    .to_rect()
-                    .with_origin(Point::new(0.0, height))
-                    .inflate(0.0, 8.0);
-                    if rect.contains(mouse_event.pos) {
-                        let pos = mouse_event.pos - (8.0, 0.0);
-                        let hit = text.hit_test_point(pos);
-                        self.cursor = hit.idx;
-                    }
-                } else if let serde_json::Value::Bool(checked) = self.value {
-                    let rect = Size::new(self.checkbox_width, self.checkbox_width)
-                        .to_rect()
-                        .with_origin(Point::new(
-                            0.0,
-                            self.name(ctx.text(), data).size().height
-                                + self.padding * 2.0
-                                + 4.0,
-                        ));
-                    if rect.contains(mouse_event.pos) {
-                        self.value = serde_json::json!(!checked);
-                        self.value_changed = true;
-                        self.last_idle_timer =
-                            ctx.request_timer(Self::SAVE_DELAY, None);
-                    }
-                }
+    }
+
+    fn update_items(&mut self, ctx: &mut EventCtx, data: &mut LapceTabData) {
+        let event_sink = ctx.get_external_handle();
+        self.items = self
+            .colors
+            .iter()
+            .map(|color| {
+                WidgetPod::new(LapcePadding::new(
+                    5.0,
+                    ThemeSettingItem::new(
+                        data,
+                        self.kind,
+                        color.clone(),
+                        event_sink.clone(),
+                    ),
+                ))
+                .boxed()
+            })
+            .collect();
+        ctx.children_changed();
+    }
+}
+
+impl Widget<LapceTabData> for ThemeSection {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        for item in self.items.iter_mut() {
+            item.event(ctx, event, data, env);
+        }
+
+        if self.items.is_empty() {
+            self.update_items(ctx, data);
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        for item in self.items.iter_mut() {
+            item.lifecycle(ctx, event, data, env);
+        }
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        for item in self.items.iter_mut() {
+            item.update(ctx, data, env);
+        }
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let mut text_layouts = Vec::new();
+
+        let mut width = 0.0;
+        for color in self.colors.iter() {
+            let text_layout = ctx
+                .text()
+                .new_text_layout(color.to_string())
+                .font(
+                    data.config.ui.font_family(),
+                    data.config.ui.font_size() as f64,
+                )
+                .text_color(
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                        .clone(),
+                )
+                .build()
+                .unwrap();
+            let size = text_layout.size();
+            if size.width > width {
+                width = size.width;
             }
-            Event::MouseMove(mouse_event) => {
-                ctx.set_handled();
-                if self.input_rect.contains(mouse_event.pos) {
-                    ctx.set_cursor(&druid::Cursor::IBeam);
-                    ctx.request_paint();
-                } else {
-                    ctx.clear_cursor();
-                    ctx.request_paint();
+            text_layouts.push(text_layout);
+        }
+        self.text_layouts = Some(text_layouts);
+
+        let mut item_width = 0.0;
+        let x = width + 5.0;
+
+        let mut height = self.header_height;
+        for item in self.items.iter_mut() {
+            let size = item.layout(ctx, bc, data, env);
+            if size.width > item_width {
+                item_width = size.width;
+            }
+            item.set_origin(ctx, data, env, Point::new(x, height));
+            height += size.height;
+        }
+
+        Size::new(x + item_width + 10.0, height)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let header_text = ctx
+            .text()
+            .new_text_layout(match self.kind {
+                ThemeKind::Base => "Base Colors",
+                ThemeKind::UI => "UI Colors",
+                ThemeKind::Syntax => "Syntax Colors",
+            })
+            .font(
+                data.config.ui.font_family(),
+                data.config.ui.font_size() as f64,
+            )
+            .default_attribute(TextAttribute::Weight(FontWeight::BOLD))
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+        ctx.draw_text(
+            &header_text,
+            Point::new(0.0, self.header_height - header_text.size().height - 5.0),
+        );
+
+        let text_layouts = self.text_layouts.as_ref().unwrap();
+        for (i, item) in self.items.iter_mut().enumerate() {
+            item.paint(ctx, data, env);
+            let layout_rect = item.layout_rect();
+            let height = layout_rect.height();
+            if let Some(text_layout) = text_layouts.get(i) {
+                ctx.draw_text(
+                    text_layout,
+                    Point::new(0.0, layout_rect.y0 + text_layout.y_offset(height)),
+                );
+            }
+        }
+    }
+}
+
+pub struct ThemeSettingItem {
+    widget_id: WidgetId,
+    kind: ThemeKind,
+    color: String,
+    name: String,
+    input: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    input_view_id: WidgetId,
+    last_idle_timer: TimerToken,
+    reset: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    reset_shown: bool,
+}
+
+impl ThemeSettingItem {
+    const SAVE_DELAY: Duration = Duration::from_millis(500);
+
+    fn new(
+        data: &mut LapceTabData,
+        kind: ThemeKind,
+        color: String,
+        event_sink: ExtEventSink,
+    ) -> Self {
+        let name = format!("{kind}.{color}");
+        let content = BufferContent::SettingsValue(name.clone());
+        let mut doc =
+            Document::new(content.clone(), data.id, event_sink, data.proxy.clone());
+        doc.reload(
+            Rope::from(match kind {
+                ThemeKind::Base => data.config.color_theme.base.get(&color).unwrap(),
+                ThemeKind::UI => data.config.color_theme.ui.get(&color).unwrap(),
+                ThemeKind::Syntax => {
+                    data.config.color_theme.syntax.get(&color).unwrap()
                 }
+            }),
+            true,
+        );
+        data.main_split.value_docs.insert(name, Arc::new(doc));
+        let editor = LapceEditorData::new(None, None, None, content, &data.config);
+        let view_id = editor.view_id;
+        let input = LapceEditorView::new(editor.view_id, editor.editor_id, None)
+            .hide_header()
+            .hide_gutter()
+            .padding((5.0, 0.0, 5.0, 0.0));
+        data.main_split.editors.insert(view_id, Arc::new(editor));
+
+        let widget_id = WidgetId::next();
+        let local_color = color.clone();
+        Self {
+            widget_id,
+            name: format!("{kind}.{color}"),
+            input_view_id: view_id,
+            input: WidgetPod::new(input.boxed()),
+            last_idle_timer: TimerToken::INVALID,
+            kind,
+            color,
+            reset: WidgetPod::new(
+                Button::new(data, "Reset")
+                    .on_click(move |ctx, data, _env| {
+                        ctx.submit_command(Command::new(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::ResetSettingsFile {
+                                kind: kind.to_string(),
+                                key: local_color.clone(),
+                            },
+                            Target::Widget(data.id),
+                        ));
+                        ctx.submit_command(Command::new(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::ResetSettingsItem,
+                            Target::Widget(widget_id),
+                        ));
+                    })
+                    .boxed(),
+            ),
+            reset_shown: false,
+        }
+    }
+
+    fn default(&self, data: &LapceTabData) -> String {
+        match self.kind {
+            ThemeKind::Base => data
+                .config
+                .default_color_theme
+                .base
+                .get(&self.color)
+                .unwrap()
+                .to_string(),
+            ThemeKind::UI => data
+                .config
+                .default_color_theme
+                .ui
+                .get(&self.color)
+                .cloned()
+                .unwrap_or_default(),
+            ThemeKind::Syntax => data
+                .config
+                .default_color_theme
+                .syntax
+                .get(&self.color)
+                .cloned()
+                .unwrap_or_default(),
+        }
+    }
+
+    fn check_reset(&mut self, data: &LapceTabData) {
+        self.reset_shown = match self.kind {
+            ThemeKind::Base => {
+                let default = data
+                    .config
+                    .default_color_theme
+                    .base
+                    .get(&self.color)
+                    .unwrap();
+                data.config.color_theme.base.get(&self.color) != Some(default)
             }
-            Event::Timer(token)
-                if self.value_changed && *token == self.last_idle_timer =>
-            {
-                self.value_changed = false;
+            ThemeKind::UI => {
+                let default = data
+                    .config
+                    .default_color_theme
+                    .ui
+                    .get(&self.color)
+                    .cloned()
+                    .unwrap_or_default();
+                data.config.color_theme.ui.get(&self.color) != Some(&default)
+            }
+            ThemeKind::Syntax => {
+                let default = data
+                    .config
+                    .default_color_theme
+                    .syntax
+                    .get(&self.color)
+                    .cloned()
+                    .unwrap_or_default();
+                data.config.color_theme.syntax.get(&self.color) != Some(&default)
+            }
+        };
+    }
+}
+
+impl Widget<LapceTabData> for ThemeSettingItem {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.widget_id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        // Don't alert the input to mouse-wheel events
+        if !matches!(event, Event::Wheel(_)) {
+            self.input.event(ctx, event, data, env);
+        }
+
+        match event {
+            Event::Timer(token) if &self.last_idle_timer == token => {
+                ctx.set_handled();
+                let editor_data = data.editor_view_content(self.input_view_id);
+                let content = editor_data.doc.buffer().to_string();
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::UpdateSettingsFile(
-                        self.kind.clone(),
-                        self.name.clone(),
-                        self.value.clone(),
-                    ),
+                    LapceUICommand::UpdateSettingsFile {
+                        kind: self.kind.to_string(),
+                        key: self.color.clone(),
+                        value: serde_json::json!(content),
+                    },
                     Target::Widget(data.id),
                 ));
             }
-
+            Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
+                let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
+                if let LapceUICommand::ResetSettingsItem = command {
+                    let default = self.default(data);
+                    let name = format!("{}.{}", self.kind, self.color);
+                    let doc = data.main_split.value_docs.get_mut(&name).unwrap();
+                    let doc = Arc::make_mut(doc);
+                    doc.reload(Rope::from(default), true);
+                }
+            }
             _ => {}
         }
+
+        if self.reset_shown {
+            self.reset.event(ctx, event, data, env);
+        }
     }
 
     fn lifecycle(
@@ -872,9 +1894,8 @@ impl Widget<LapceTabData> for LapceSettingsItem {
         data: &LapceTabData,
         env: &Env,
     ) {
-        if let Some(input) = self.input_widget.as_mut() {
-            input.lifecycle(ctx, event, data, env);
-        }
+        self.input.lifecycle(ctx, event, data, env);
+        self.reset.lifecycle(ctx, event, data, env);
     }
 
     fn update(
@@ -884,540 +1905,367 @@ impl Widget<LapceTabData> for LapceSettingsItem {
         data: &LapceTabData,
         env: &Env,
     ) {
-        if data.config.id != old_data.config.id {
-            self.clear_text_layout_cache();
-        }
-        if let Some(input) = self.input_widget.as_mut() {
-            input.update(ctx, data, env);
+        self.input.update(ctx, data, env);
+
+        let old_doc = old_data.main_split.value_docs.get(&self.name).unwrap();
+        let doc = data.main_split.value_docs.get(&self.name).unwrap();
+        if doc.buffer().len() != old_doc.buffer().len()
+            || doc.buffer().text().slice_to_cow(..)
+                != old_doc.buffer().text().slice_to_cow(..)
+        {
+            self.last_idle_timer = ctx.request_timer(Self::SAVE_DELAY, None);
         }
+
+        self.reset.update(ctx, data, env);
     }
 
     fn layout(
         &mut self,
         ctx: &mut LayoutCtx,
-        bc: &BoxConstraints,
+        _bc: &BoxConstraints,
         data: &LapceTabData,
         env: &Env,
     ) -> Size {
-        let width = bc.max().width;
-        if width != self.width {
-            self.width = width;
-            self.clear_text_layout_cache();
-        }
-        let text = ctx.text();
-        let name = self.name(text, data).size();
-        let desc = self.desc(text, data).size();
-        let mut height = name.height + desc.height + (self.padding * 3.0);
-        height = height.round();
-
-        if let Some(input) = self.input_widget.as_mut() {
-            input.layout(ctx, bc, data, env);
-            input.set_origin(ctx, data, env, Point::new(0.0, height));
-        }
+        self.check_reset(data);
+
+        let input_bc = BoxConstraints::tight(Size::new(150.0, 100.0));
+        let size = self.input.layout(ctx, &input_bc, data, env);
+        self.input.set_origin(ctx, data, env, Point::ZERO);
+
+        let reset_width = if self.reset_shown {
+            let reset_size = self.reset.layout(
+                ctx,
+                &BoxConstraints::new(
+                    Size::new(0.0, size.height),
+                    Size::new(200.0, size.height),
+                ),
+                data,
+                env,
+            );
+            self.reset.set_origin(
+                ctx,
+                data,
+                env,
+                Point::new(size.width + size.height + 10.0, 0.0),
+            );
+            reset_size.width
+        } else {
+            0.0
+        };
 
-        let text = ctx.text();
-        let value = self
-            .value(text, data)
-            .map(|v| v.size().height)
-            .unwrap_or(0.0);
-        if value > 0.0 {
-            height += value + self.padding * 2.0;
-        }
-        Size::new(self.width, height.ceil())
+        Size::new(size.width + size.height + 10.0 + reset_width, size.height)
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
-        let mut y = 0.0;
-        let padding = self.padding;
-
-        let rect = ctx
-            .size()
-            .to_rect()
-            .inflate(0.0, padding)
-            .inset((padding, 0.0, -30.0, 0.0));
-        if ctx.is_hot() {
-            ctx.fill(
-                rect,
-                data.config
-                    .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
-            );
-        }
-
-        let text = ctx.text();
-        let text = self.name(text, data);
-        y += padding;
-        ctx.draw_text(text, Point::new(0.0, y));
-        y += text.size().height;
+        self.input.paint(ctx, data, env);
 
-        y += padding;
-        let x = if let serde_json::Value::Bool(checked) = self.value {
-            let width = 13.0;
-            let height = 13.0;
-            let origin = Point::new(0.0, y + 4.0);
-            let rect = Size::new(width, height).to_rect().with_origin(origin);
-            ctx.stroke(
-                rect,
-                data.config
-                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
-                1.0,
-            );
-            if checked {
-                let mut path = BezPath::new();
-                path.move_to((origin.x + 3.0, origin.y + 7.0));
-                path.line_to((origin.x + 6.0, origin.y + 9.5));
-                path.line_to((origin.x + 10.0, origin.y + 3.0));
-                ctx.stroke(
-                    path,
+        let preview_color = match self.kind {
+            ThemeKind::Base => {
+                data.config.color.base.get(&self.color).unwrap_or_else(|| {
                     data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
-                    2.0,
-                );
+                        .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
+                })
             }
-
-            self.checkbox_width
-        } else {
-            0.0
+            ThemeKind::UI => {
+                data.config.color.ui.get(&self.color).unwrap_or_else(|| {
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
+                })
+            }
+            ThemeKind::Syntax => data
+                .config
+                .color
+                .syntax
+                .get(&self.color)
+                .unwrap_or_else(|| {
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
+                }),
         };
-        let text = ctx.text();
-        let text = self.desc(text, data);
-        ctx.draw_text(text, Point::new(x, y));
 
-        if let Some(input) = self.input_widget.as_mut() {
-            input.paint(ctx, data, env);
+        let layout_rect = self.input.layout_rect();
+        let color_rect = Rect::new(
+            layout_rect.x1 + 5.0,
+            layout_rect.y0,
+            layout_rect.x1 + 5.0 + layout_rect.height(),
+            layout_rect.y1,
+        )
+        .inflate(-0.5, -0.5);
+        ctx.stroke(
+            color_rect,
+            data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+            1.0,
+        );
+        ctx.fill(color_rect.inflate(-0.5, -0.5), preview_color);
+
+        if self.reset_shown {
+            self.reset.paint(ctx, data, env);
         }
     }
 }
 
-#[derive(Clone)]
-pub enum ThemeKind {
-    Base,
-    UI,
-    Syntax,
+struct SettingsSwitcher {
+    settings_widget_id: WidgetId,
+    plugin_settings_expanded: bool,
+    plugin_settings_disabled: bool,
+    line_height: f64,
+    last_mouse_down: Option<usize>,
+    active: LapceSettingsKind,
+    active_index: Option<usize>,
 }
 
-impl Display for ThemeKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(match self {
-            ThemeKind::Base => "theme.base",
-            ThemeKind::UI => "theme.ui",
-            ThemeKind::Syntax => "theme.syntax",
-        })
+impl SettingsSwitcher {
+    fn new(settings_widget_id: WidgetId) -> Self {
+        Self {
+            settings_widget_id,
+            plugin_settings_expanded: true,
+            plugin_settings_disabled: true,
+            line_height: 40.0,
+            last_mouse_down: None,
+            active: LapceSettingsKind::Core,
+            active_index: Some(0),
+        }
     }
-}
-
-pub struct ThemeSettings {
-    widget_id: WidgetId,
-    kind: ThemeKind,
-    inputs: Vec<WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>>,
-    keys: Vec<String>,
-    text_layouts: Option<Vec<PietTextLayout>>,
-    changed_rects: Vec<(String, String, Rect)>,
-    mouse_down_rect: Option<(String, String, Rect)>,
-}
 
-impl ThemeSettings {
-    fn new_boxed() -> Box<dyn Widget<LapceTabData>> {
-        LapceScroll::new(
-            LapceSplit::new(WidgetId::next())
-                .horizontal()
-                .hide_border()
-                .with_child(
-                    Self {
-                        kind: ThemeKind::Base,
-                        widget_id: WidgetId::next(),
-                        inputs: Vec::new(),
-                        keys: Vec::new(),
-                        text_layouts: None,
-                        changed_rects: Vec::new(),
-                        mouse_down_rect: None,
-                    }
-                    .boxed(),
-                    None,
-                    1.0,
-                )
-                .with_child(
-                    Self {
-                        kind: ThemeKind::Syntax,
-                        widget_id: WidgetId::next(),
-                        inputs: Vec::new(),
-                        keys: Vec::new(),
-                        text_layouts: None,
-                        changed_rects: Vec::new(),
-                        mouse_down_rect: None,
-                    }
-                    .boxed(),
-                    None,
-                    1.0,
-                )
-                .with_child(
-                    Self {
-                        kind: ThemeKind::UI,
-                        widget_id: WidgetId::next(),
-                        inputs: Vec::new(),
-                        keys: Vec::new(),
-                        text_layouts: None,
-                        changed_rects: Vec::new(),
-                        mouse_down_rect: None,
-                    }
-                    .boxed(),
-                    None,
-                    1.0,
-                )
-                .boxed(),
-        )
-        .boxed()
+    fn num_items(&self, data: &LapceTabData) -> usize {
+        let mut n = if self.plugin_settings_disabled { 6 } else { 7 };
+        if self.plugin_settings_expanded {
+            n += data
+                .plugin
+                .installed
+                .iter()
+                .filter(|(_, v)| v.config.is_some())
+                .count();
+        }
+        n
     }
 
-    fn update_inputs(&mut self, ctx: &mut EventCtx, data: &mut LapceTabData) {
-        self.keys.clear();
-        self.inputs.clear();
-        self.text_layouts = None;
-
-        let colors: Vec<&str> = match &self.kind {
-            ThemeKind::Base => {
-                data.config.color.base.keys().into_iter().sorted().collect()
+    pub fn set_active(&mut self, active: LapceSettingsKind, data: &LapceTabData) {
+        self.active = active;
+
+        if let LapceSettingsKind::Plugin(active_volt_id) = &self.active {
+            for (i, (volt_id, _)) in data
+                .plugin
+                .installed
+                .iter()
+                .filter(|(_, v)| v.config.is_some())
+                .sorted_by_key(|(_, v)| &v.display_name)
+                .enumerate()
+            {
+                if active_volt_id == volt_id {
+                    self.active_index = Some(i + 6);
+                    return;
+                }
             }
-            ThemeKind::UI => data
-                .config
-                .color
-                .ui
-                .keys()
-                .map(|s| s.as_str())
-                .sorted()
-                .collect(),
-            ThemeKind::Syntax => data
-                .config
-                .color
-                .syntax
-                .keys()
-                .map(|s| s.as_str())
-                .sorted()
-                .collect(),
-        };
+        }
 
-        for color in colors {
-            let name = format!("{}.{color}", self.kind);
-            let content = BufferContent::SettingsValue(
-                name.clone(),
-                SettingsValueKind::String,
-                self.kind.to_string(),
-                color.to_string(),
-            );
-            let mut doc = Document::new(
-                content.clone(),
-                data.id,
-                ctx.get_external_handle(),
-                data.proxy.clone(),
-            );
-            doc.reload(
-                Rope::from(match &self.kind {
-                    ThemeKind::Base => data.config.theme.base.get(color).unwrap(),
-                    ThemeKind::UI => data.config.theme.ui.get(color).unwrap(),
-                    ThemeKind::Syntax => {
-                        data.config.theme.syntax.get(color).unwrap()
-                    }
-                }),
-                true,
-            );
-            data.main_split.value_docs.insert(name, Arc::new(doc));
-            let editor =
-                LapceEditorData::new(None, None, None, content, &data.config);
-            let view_id = editor.view_id;
-            let input = LapceEditorView::new(editor.view_id, editor.editor_id, None)
-                .hide_header()
-                .hide_gutter()
-                .padding((5.0, 0.0, 5.0, 0.0));
-            data.main_split.editors.insert(view_id, Arc::new(editor));
-            self.keys.push(color.to_string());
-            self.inputs.push(WidgetPod::new(input.boxed()));
+        let kinds = [
+            LapceSettingsKind::Core,
+            LapceSettingsKind::UI,
+            LapceSettingsKind::Editor,
+            LapceSettingsKind::Terminal,
+            LapceSettingsKind::Theme,
+            LapceSettingsKind::Keymap,
+        ];
+
+        for (i, kind) in kinds.iter().enumerate() {
+            if kind == &self.active {
+                self.active_index = Some(i);
+                return;
+            }
         }
     }
 }
 
-impl Widget<LapceTabData> for ThemeSettings {
-    fn id(&self) -> Option<WidgetId> {
-        Some(self.widget_id)
-    }
-
+impl Widget<LapceTabData> for SettingsSwitcher {
     fn event(
         &mut self,
         ctx: &mut EventCtx,
         event: &Event,
         data: &mut LapceTabData,
-        env: &Env,
+        _env: &Env,
     ) {
         match event {
             Event::MouseDown(mouse_event) => {
-                self.mouse_down_rect = None;
-                for (key, default, change) in self.changed_rects.iter() {
-                    if change.contains(mouse_event.pos) {
-                        self.mouse_down_rect =
-                            Some((key.to_string(), default.to_string(), *change));
-                    }
+                self.last_mouse_down = None;
+                let index = (mouse_event.pos.y / self.line_height) as usize;
+                if index < self.num_items(data) {
+                    self.last_mouse_down = Some(index);
                 }
             }
             Event::MouseUp(mouse_event) => {
-                if let Some((key, default, rect)) = self.mouse_down_rect.as_ref() {
-                    if rect.contains(mouse_event.pos) {
-                        let name = format!("{}.{key}", self.kind);
-                        let doc = data.main_split.value_docs.get_mut(&name).unwrap();
-                        let doc = Arc::make_mut(doc);
-                        doc.reload(Rope::from(default), true);
-                        ctx.submit_command(Command::new(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::ResetSettingsFile(
-                                self.kind.to_string(),
-                                key.clone(),
-                            ),
-                            Target::Widget(data.id),
-                        ));
+                if let Some(last_index) = self.last_mouse_down.take() {
+                    let index = (mouse_event.pos.y / self.line_height) as usize;
+                    if index < self.num_items(data) && index == last_index {
+                        match index {
+                            6 => {
+                                self.plugin_settings_expanded =
+                                    !self.plugin_settings_expanded;
+                                ctx.request_layout();
+                            }
+                            _ if index > 6 => {
+                                if let Some((volt_id, _)) = data
+                                    .plugin
+                                    .installed
+                                    .iter()
+                                    .filter(|(_, v)| v.config.is_some())
+                                    .sorted_by_key(|(_, v)| &v.display_name)
+                                    .nth(index - 7)
+                                {
+                                    ctx.submit_command(Command::new(
+                                        LAPCE_UI_COMMAND,
+                                        LapceUICommand::ShowSettingsKind(
+                                            LapceSettingsKind::Plugin(
+                                                volt_id.clone(),
+                                            ),
+                                        ),
+                                        Target::Widget(self.settings_widget_id),
+                                    ));
+                                }
+                            }
+                            _ => {
+                                if let Some(kind) = [
+                                    LapceSettingsKind::Core,
+                                    LapceSettingsKind::UI,
+                                    LapceSettingsKind::Editor,
+                                    LapceSettingsKind::Terminal,
+                                    LapceSettingsKind::Theme,
+                                    LapceSettingsKind::Keymap,
+                                ]
+                                .get(index)
+                                {
+                                    ctx.submit_command(Command::new(
+                                        LAPCE_UI_COMMAND,
+                                        LapceUICommand::ShowSettingsKind(
+                                            kind.clone(),
+                                        ),
+                                        Target::Widget(self.settings_widget_id),
+                                    ));
+                                }
+                            }
+                        }
                     }
                 }
-                self.mouse_down_rect = None;
             }
-            _ => {}
-        }
-        for input in self.inputs.iter_mut() {
-            match event {
-                Event::Wheel(_) => {}
-                _ => {
-                    input.event(ctx, event, data, env);
+            Event::MouseMove(mouse_event) => {
+                if mouse_event.pos.y
+                    <= self.num_items(data) as f64 * self.line_height
+                {
+                    ctx.set_cursor(&Cursor::Pointer);
+                } else {
+                    ctx.clear_cursor();
                 }
             }
-        }
-
-        if self.inputs.is_empty() {
-            self.update_inputs(ctx, data);
-            ctx.children_changed();
+            _ => {}
         }
     }
 
     fn lifecycle(
         &mut self,
-        ctx: &mut LifeCycleCtx,
-        event: &LifeCycle,
-        data: &LapceTabData,
-        env: &Env,
+        _ctx: &mut LifeCycleCtx,
+        _event: &LifeCycle,
+        _data: &LapceTabData,
+        _env: &Env,
     ) {
-        for input in self.inputs.iter_mut() {
-            input.lifecycle(ctx, event, data, env);
-        }
     }
 
     fn update(
         &mut self,
-        ctx: &mut UpdateCtx,
-        old_data: &LapceTabData,
-        data: &LapceTabData,
-        env: &Env,
+        _ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        _data: &LapceTabData,
+        _env: &Env,
     ) {
-        if data.config.id != old_data.config.id {
-            self.text_layouts = None;
-        }
-        for input in self.inputs.iter_mut() {
-            input.update(ctx, data, env);
+        if self.plugin_settings_disabled {
+            self.plugin_settings_expanded = true;
         }
     }
 
     fn layout(
         &mut self,
-        ctx: &mut LayoutCtx,
+        _ctx: &mut LayoutCtx,
         bc: &BoxConstraints,
         data: &LapceTabData,
-        env: &Env,
+        _env: &Env,
     ) -> Size {
-        if self.inputs.is_empty() {
-            ctx.submit_command(Command::new(
-                LAPCE_UI_COMMAND,
-                LapceUICommand::InitChildren,
-                Target::Widget(self.widget_id),
-            ));
-        }
+        let width = 150.0;
+        let n = self.num_items(data);
+        Size::new(width, bc.max().height.max(n as f64 * self.line_height))
+    }
 
-        if self.text_layouts.is_none() {
-            let mut text_layouts = Vec::new();
-            for key in self.keys.iter() {
-                let text_layout = ctx
-                    .text()
-                    .new_text_layout(key.to_string())
-                    .font(
-                        data.config.ui.font_family(),
-                        data.config.ui.font_size() as f64,
-                    )
-                    .text_color(
-                        data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                            .clone(),
-                    )
-                    .build()
-                    .unwrap();
-                text_layouts.push(text_layout);
-            }
-            self.text_layouts = Some(text_layouts);
-        }
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+        let mut settings_sections: Vec<&str> = vec![
+            "Coreの設定",
+            "UIの設定",
+            "Editorの設定",
+            "Terminalの設定",
+            "Themeの設定",
+            "Keyの割り当て",
+            "Pluginの設定",
+        ];
 
-        let text_width = self
-            .text_layouts
-            .as_ref()
-            .unwrap()
+        self.plugin_settings_disabled = true;
+        for (_, volt) in data
+            .plugin
+            .installed
             .iter()
-            .map(|text_layout| text_layout.size().width.ceil() as usize)
-            .max()
-            .unwrap_or(0) as f64;
-
-        let mut y = 30.0;
-        let input_bc = BoxConstraints::tight(Size::new(
-            (bc.max().width - text_width - 10.0).min(150.0),
-            100.0,
-        ));
-
-        let reset_text = ctx
-            .text()
-            .new_text_layout("reset")
-            .font(
-                data.config.ui.font_family(),
-                data.config.ui.font_size() as f64,
-            )
-            .text_color(
-                data.config
-                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                    .clone(),
-            )
-            .build()
-            .unwrap();
-        let reset_size = reset_text.size();
-        self.changed_rects.clear();
-
-        for (i, input) in self.inputs.iter_mut().enumerate() {
-            let size = input.layout(ctx, &input_bc, data, env);
-            let padding = (size.height * 0.2).round();
-            y += padding;
-            input.set_origin(ctx, data, env, Point::new(text_width + 10.0, y));
-            y += size.height + padding;
-
-            let (changed, default) = match self.kind {
-                ThemeKind::Base => {
-                    let default = data
-                        .config
-                        .default_theme
-                        .base
-                        .get(&self.keys[i])
-                        .unwrap()
-                        .to_string();
-                    (
-                        data.config.theme.base.get(&self.keys[i]).unwrap()
-                            != &default,
-                        default,
-                    )
-                }
-                ThemeKind::UI => {
-                    let default = data
-                        .config
-                        .default_theme
-                        .ui
-                        .get(&self.keys[i])
-                        .unwrap()
-                        .to_string();
-                    (
-                        data.config.theme.ui.get(&self.keys[i]).unwrap() != &default,
-                        default,
-                    )
-                }
-                ThemeKind::Syntax => {
-                    let default = data
-                        .config
-                        .default_theme
-                        .syntax
-                        .get(&self.keys[i])
-                        .unwrap()
-                        .to_string();
-                    (
-                        data.config.theme.syntax.get(&self.keys[i]).unwrap()
-                            != &default,
-                        default,
-                    )
-                }
-            };
-            if changed {
-                let x = input.layout_rect().x1 + 10.0;
-                let y0 = input.layout_rect().y0;
-                let y1 = input.layout_rect().y1;
-                let rect = Rect::new(x, y0, x + reset_size.width + 20.0, y1);
-                self.changed_rects
-                    .push((self.keys[i].clone(), default, rect));
+            .filter(|(_, v)| v.config.is_some())
+            .sorted_by_key(|(_, v)| &v.display_name)
+        {
+            if self.plugin_settings_expanded {
+                settings_sections.push(volt.display_name.as_str());
             }
+            self.plugin_settings_disabled = false;
         }
 
-        Size::new(bc.max().width, y + 10.0)
-    }
-
-    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
-        let header_text = ctx
-            .text()
-            .new_text_layout(match &self.kind {
-                ThemeKind::Base => "Base Colors",
-                ThemeKind::UI => "UI Colors",
-                ThemeKind::Syntax => "Syntax Colors",
-            })
-            .font(
-                data.config.ui.font_family(),
-                data.config.ui.font_size() as f64,
-            )
-            .default_attribute(TextAttribute::Weight(FontWeight::BOLD))
-            .text_color(
-                data.config
-                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                    .clone(),
-            )
-            .build()
-            .unwrap();
-        ctx.draw_text(
-            &header_text,
-            Point::new(0.0, (30.0 - header_text.size().height) / 2.0),
-        );
+        for (i, text) in settings_sections.iter().enumerate() {
+            let font_size = if i <= 6 {
+                data.config.ui.font_size() + 1
+            } else {
+                data.config.ui.font_size()
+            };
+            let text_layout = ctx
+                .text()
+                .new_text_layout(text.to_string())
+                .font(data.config.ui.font_family(), font_size as f64)
+                .text_color(
+                    if self.plugin_settings_disabled && text == &"Plugin Settings" {
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_DIM)
+                            .clone()
+                    } else {
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                            .clone()
+                    },
+                )
+                .build()
+                .unwrap();
 
-        for (i, input) in self.inputs.iter_mut().enumerate() {
-            let text_layout = &self.text_layouts.as_ref().unwrap()[i];
+            let x = if i <= 6 { 20.0 } else { 40.0 };
             ctx.draw_text(
-                text_layout,
+                &text_layout,
                 Point::new(
-                    0.0,
-                    input.layout_rect().y0
-                        + (input.layout_rect().height() - text_layout.size().height)
-                            / 2.0,
+                    x,
+                    i as f64 * self.line_height
+                        + text_layout.y_offset(self.line_height),
                 ),
             );
-            input.paint(ctx, data, env);
         }
 
-        let reset_text = ctx
-            .text()
-            .new_text_layout("reset")
-            .font(
-                data.config.ui.font_family(),
-                data.config.ui.font_size() as f64,
-            )
-            .text_color(
-                data.config
-                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                    .clone(),
-            )
-            .build()
-            .unwrap();
-        let reset_size = reset_text.size();
-        for (_, _, rect) in self.changed_rects.iter() {
+        let x = 2.0;
+        let active = self.active_index.unwrap_or(0);
+        let active = if active > 5 { active + 1 } else { active };
+        if (active <= 6 || self.plugin_settings_expanded)
+            && !self.plugin_settings_disabled
+        {
+            let y0 = self.line_height * active as f64;
+            let y1 = y0 + self.line_height;
             ctx.stroke(
-                rect.inflate(-0.5, -0.5),
-                data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
-                1.0,
+                Line::new(Point::new(x, y0 + 5.0), Point::new(x, y1 - 5.0)),
+                data.config.get_color_unchecked(LapceTheme::EDITOR_CARET),
+                2.0,
             );
-            ctx.draw_text(
-                &reset_text,
-                Point::new(
-                    rect.x0 + 10.0,
-                    rect.y0 + (rect.height() - reset_size.height) / 2.0,
-                ),
-            )
         }
     }
 }
diff --git a/lapce-ui/src/signature.rs b/lapce-ui/src/signature.rs
new file mode 100644
index 0000000000..a61c97db07
--- /dev/null
+++ b/lapce-ui/src/signature.rs
@@ -0,0 +1,546 @@
+use std::ops::Range;
+
+use druid::{
+    theme, ArcStr, BoxConstraints, Color, Command, Env, Event, EventCtx,
+    FontDescriptor, FontWeight, LayoutCtx, LifeCycle, PaintCtx, Point,
+    RenderContext, Size, Target, TextLayout, UpdateCtx, Widget, WidgetId, WidgetPod,
+};
+use lapce_core::{encoding::offset_utf16_to_utf8, language::LapceLanguage};
+use lapce_data::{
+    command::{LapceUICommand, LAPCE_UI_COMMAND},
+    config::{LapceConfig, LapceTheme},
+    data::LapceTabData,
+    document::BufferContent,
+    markdown::{
+        highlight_as_code,
+        layout_content::{
+            layout_content_clean_up, layouts_from_contents, LayoutContent,
+        },
+        parse_documentation, Content,
+    },
+    rich_text::{RichText, RichTextBuilder},
+    signature::{SignatureData, SignatureStatus},
+};
+use lsp_types::{ParameterLabel, SignatureInformation};
+
+use crate::scroll::{LapceIdentityWrapper, LapceScroll};
+
+pub struct SignatureContainer {
+    id: WidgetId,
+    scroll_id: WidgetId,
+    signature: WidgetPod<
+        LapceTabData,
+        LapceIdentityWrapper<LapceScroll<LapceTabData, Signature>>,
+    >,
+    signature_content_size: Size,
+    pub label_offset: f64,
+}
+impl SignatureContainer {
+    pub fn new(data: &SignatureData) -> Self {
+        let signature = LapceIdentityWrapper::wrap(
+            LapceScroll::new(Signature::new()).vertical(),
+            data.scroll_id,
+        );
+        Self {
+            id: data.id,
+            scroll_id: data.scroll_id,
+            signature: WidgetPod::new(signature),
+            signature_content_size: Size::ZERO,
+            label_offset: 0.0,
+        }
+    }
+
+    fn update_signature(&mut self, ctx: &mut EventCtx, data: &mut LapceTabData) {
+        if data.signature.status == SignatureStatus::Inactive {
+            return;
+        }
+
+        let signature = if data.config.editor.show_signature {
+            data.signature.current()
+        } else {
+            None
+        };
+
+        let (label, param_doc, doc) = if let Some(signature) = signature {
+            // Get the language of the current file, so that we can style the label
+            let language = {
+                let editor = data.main_split.active_editor();
+                let document = editor.and_then(|editor| {
+                    if matches!(
+                        editor.content,
+                        BufferContent::File(_) | BufferContent::Scratch(_, _)
+                    ) {
+                        Some(data.main_split.editor_doc(editor.view_id))
+                    } else {
+                        None
+                    }
+                });
+                document.and_then(|document| {
+                    document.syntax().map(|syntax| syntax.language)
+                })
+            };
+
+            parse_signature(
+                signature,
+                data.signature.active_parameter,
+                language,
+                &data.config,
+            )
+        } else {
+            (RichText::new(ArcStr::from("")), None, None)
+        };
+        let label_text = signature.map(|s| s.label.clone()).unwrap_or_default();
+        let param_doc = param_doc.unwrap_or_default();
+        let doc = doc.unwrap_or_default();
+
+        let sig = self.signature.widget_mut().inner_mut().child_mut();
+        sig.label_layout.set_text(label);
+
+        layout_content_clean_up(&mut sig.param_doc_layout, data);
+        layout_content_clean_up(&mut sig.doc_layout, data);
+
+        sig.param_doc_layout = layouts_from_contents(ctx, data, param_doc.iter());
+
+        sig.doc_layout = layouts_from_contents(ctx, data, doc.iter());
+
+        sig.label = label_text;
+
+        // Set font / text color information
+        let font = FontDescriptor::new(data.config.ui.hover_font_family())
+            .with_size(data.config.ui.hover_font_size() as f64);
+        let text_color = data
+            .config
+            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+            .clone();
+
+        sig.label_layout.set_font(font.clone());
+        sig.label_layout.set_text_color(text_color.clone());
+
+        for param_doc in sig.param_doc_layout.iter_mut() {
+            param_doc.set_font(font.clone());
+            param_doc.set_text_color(text_color.clone());
+        }
+
+        for doc in sig.doc_layout.iter_mut() {
+            doc.set_font(font.clone());
+            doc.set_text_color(text_color.clone());
+        }
+    }
+}
+impl Widget<LapceTabData> for SignatureContainer {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        if let Event::Command(cmd) = event {
+            if cmd.is(LAPCE_UI_COMMAND) {
+                let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
+                if let LapceUICommand::RefreshSignature = *command {
+                    self.update_signature(ctx, data);
+                    ctx.request_layout();
+                }
+            }
+        }
+
+        self.signature.event(ctx, event, data, env);
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut druid::LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.signature.lifecycle(ctx, event, data, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        let old_signature = &old_data.signature;
+        let signature = &data.signature;
+
+        if data.signature.status != SignatureStatus::Inactive {
+            let old_editor = old_data.main_split.active_editor();
+            let old_editor = match old_editor {
+                Some(editor) => editor,
+                None => return,
+            };
+            let editor = data.main_split.active_editor();
+            let editor = match editor {
+                Some(editor) => editor,
+                None => return,
+            };
+            if old_editor.window_origin != editor.window_origin
+                || old_editor.scroll_offset != editor.scroll_offset
+            {
+                ctx.request_layout();
+            }
+
+            if old_signature.request_id != signature.request_id
+                || old_signature.status != data.signature.status
+                || old_signature.signatures != signature.signatures
+                || old_signature.current_signature != signature.current_signature
+            {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::RefreshSignature,
+                    Target::Widget(self.id),
+                ));
+            }
+
+            if old_signature.status == SignatureStatus::Inactive
+                && signature.status != SignatureStatus::Inactive
+            {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::ResetFade,
+                    Target::Widget(self.scroll_id),
+                ));
+            }
+
+            let sig = self.signature.widget_mut().inner_mut().child_mut();
+            // Note: this deliberately uses bitwise-or so that both are executed
+            // since `needs_rebuild_after_update` alters internal state of the layout
+            // (Is there a more clear way of doing this?)
+            let mut needs_layout = false;
+            needs_layout |= sig.label_layout.needs_rebuild_after_update(ctx);
+
+            for param_doc in sig.param_doc_layout.iter_mut() {
+                needs_layout |= param_doc.needs_rebuild_after_update(ctx);
+            }
+
+            for doc in sig.doc_layout.iter_mut() {
+                needs_layout |= doc.needs_rebuild_after_update(ctx);
+            }
+
+            if needs_layout {
+                ctx.request_layout();
+            }
+
+            self.signature.update(ctx, data, env);
+        }
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        _bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let bc = BoxConstraints::new(Size::ZERO, data.signature.size);
+        self.signature_content_size = self.signature.layout(ctx, &bc, data, env);
+        self.signature.set_origin(ctx, data, env, Point::ZERO);
+
+        self.label_offset = self.signature.widget().inner().child().label_offset;
+
+        self.signature_content_size
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        if data.signature.status != SignatureStatus::Inactive {
+            let rect = self.signature_content_size.to_rect();
+            let shadow_width = data.config.ui.drop_shadow_width() as f64;
+            if shadow_width > 0.0 {
+                ctx.blurred_rect(
+                    rect,
+                    shadow_width,
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                );
+            } else {
+                ctx.stroke(
+                    rect.inflate(0.5, 0.5),
+                    data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                    1.0,
+                );
+            }
+            self.signature.paint(ctx, data, env);
+        }
+    }
+}
+
+pub struct Signature {
+    label: String,
+    label_offset: f64,
+    label_layout: TextLayout<RichText>,
+    param_doc_layout: Vec<LayoutContent>,
+    doc_layout: Vec<LayoutContent>,
+}
+impl Signature {
+    const STARTING_Y: f64 = 5.0;
+    const STARTING_X: f64 = 10.0;
+    /// Padding between the label and the documentation
+    const PADDING: f64 = 5.0;
+
+    fn new() -> Signature {
+        Self {
+            label: "".to_string(),
+            label_offset: 0.0,
+            label_layout: {
+                let mut layout = TextLayout::new();
+                layout.set_text(RichText::new(ArcStr::from("")));
+                layout
+            },
+            param_doc_layout: Vec::new(),
+            doc_layout: Vec::new(),
+        }
+    }
+
+    fn has_label_text(&self) -> bool {
+        self.label_layout
+            .text()
+            .map(|text| !text.is_empty())
+            .unwrap_or(false)
+    }
+
+    fn has_param_doc_text(&self) -> bool {
+        !self.param_doc_layout.is_empty()
+    }
+
+    fn has_doc_text(&self) -> bool {
+        !self.doc_layout.is_empty()
+    }
+
+    fn has_text(&self) -> bool {
+        self.has_label_text() || self.has_param_doc_text() || self.has_doc_text()
+    }
+}
+impl Widget<LapceTabData> for Signature {
+    fn event(
+        &mut self,
+        _ctx: &mut EventCtx,
+        _event: &Event,
+        _data: &mut LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn lifecycle(
+        &mut self,
+        _ctx: &mut druid::LifeCycleCtx,
+        _event: &LifeCycle,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn update(
+        &mut self,
+        _ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> druid::Size {
+        if !self.has_text() {
+            return Size::ZERO;
+        }
+
+        let width = bc.max().width;
+        let max_width = width
+            - Self::STARTING_X
+            - env.get(theme::SCROLLBAR_WIDTH)
+            - env.get(theme::SCROLLBAR_PAD);
+
+        self.label_layout.set_wrap_width(max_width);
+        self.label_layout.rebuild_if_needed(ctx.text(), env);
+
+        if let Some(col) = self.label.find('(') {
+            self.label_offset = self.label_layout.point_for_text_position(col + 1).x;
+        }
+
+        for param_doc in self.param_doc_layout.iter_mut() {
+            param_doc.set_max_width(&data.images, max_width);
+            param_doc.rebuild_if_needed(ctx.text(), env);
+        }
+
+        for doc in self.doc_layout.iter_mut() {
+            doc.set_max_width(&data.images, max_width);
+            doc.rebuild_if_needed(ctx.text(), env);
+        }
+
+        let mut height = 0.0;
+
+        if self.has_label_text() {
+            let text_metrics = self.label_layout.layout_metrics();
+            ctx.set_baseline_offset(
+                text_metrics.size.height - text_metrics.first_baseline,
+            );
+            height += text_metrics.size.height;
+        }
+
+        // TODO: draw separator around param docs?
+
+        for param_doc in self.param_doc_layout.iter() {
+            let size = param_doc.size(&data.images, &data.config);
+            height += size.height + Self::PADDING;
+        }
+
+        for doc in self.doc_layout.iter() {
+            let size = doc.size(&data.images, &data.config);
+            height += size.height + Self::PADDING;
+        }
+
+        Size::new(width, height + Self::STARTING_Y + Self::PADDING)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+        if data.signature.status == SignatureStatus::Inactive || !self.has_text() {
+            return;
+        }
+
+        let rect = ctx.region().bounding_box();
+
+        // Draw the background
+        ctx.fill(
+            rect,
+            data.config
+                .get_color_unchecked(LapceTheme::HOVER_BACKGROUND),
+        );
+
+        let mut origin = Point::new(Self::STARTING_X, Self::STARTING_Y);
+
+        if self.has_label_text() {
+            self.label_layout.draw(ctx, origin);
+            origin.y +=
+                self.label_layout.layout_metrics().size.height + Self::PADDING;
+        }
+
+        for param_doc in self.param_doc_layout.iter() {
+            let size = param_doc.size(&data.images, &data.config);
+            param_doc.draw(ctx, &data.images, &data.config, origin);
+            origin.y += size.height + Self::PADDING;
+        }
+
+        for doc in self.doc_layout.iter() {
+            let size = doc.size(&data.images, &data.config);
+            doc.draw(ctx, &data.images, &data.config, origin);
+            origin.y += size.height + Self::PADDING;
+        }
+    }
+}
+
+fn parse_signature(
+    sig: &SignatureInformation,
+    active_parameter: Option<usize>,
+    language: Option<LapceLanguage>,
+    config: &LapceConfig,
+) -> (RichText, Option<Vec<Content>>, Option<Vec<Content>>) {
+    let doc = sig
+        .documentation
+        .as_ref()
+        .map(|doc| parse_documentation(doc, config));
+
+    let (label, param_doc) = {
+        let mut builder = RichTextBuilder::new();
+        builder.set_line_height(1.5);
+
+        let mut attrs = builder.push(&sig.label);
+        // Display the the label in a code block for the specific file's language
+        // This will work fine for most languages, though could be mishighlighted in some situations
+        // Unfortunately, the LSP does not provide markdown to explicitly say whether and how
+        // it should be highlighted.
+        if config.editor.signature_label_code_block {
+            attrs.font_family(config.editor.font_family());
+
+            highlight_as_code(&mut builder, config, language, &sig.label, 0);
+        }
+
+        // If the parameters are defined and we know the active parameter, then
+        // we can apply styling to make it clear to the user what the current parameter is
+        let param_doc = if let Some(parameter) = sig
+            .parameters
+            .as_deref()
+            .zip(active_parameter)
+            .and_then(|(params, idx)| params.get(idx))
+        {
+            let active_color =
+                config.get_color_unchecked(LapceTheme::EDITOR_FOREGROUND);
+            match &parameter.label {
+                ParameterLabel::Simple(name) => {
+                    // TODO: test this
+                    if let Some(offset_start) = sig.label.find(name) {
+                        let offset_end = offset_start + name.len();
+
+                        add_parameter_attr(
+                            &mut builder,
+                            &sig.label,
+                            offset_start..offset_end,
+                            active_color.clone(),
+                        );
+                    }
+                    // Otherwise, if it failed to find it, we just ignore the bad indices
+                }
+                ParameterLabel::LabelOffsets(offsets) => {
+                    // The offsets are utf16 into the `label`
+                    let offset_start = offset_utf16_to_utf8(
+                        sig.label.char_indices(),
+                        offsets[0] as usize,
+                    );
+                    let offset_end = offset_utf16_to_utf8(
+                        sig.label.char_indices(),
+                        offsets[1] as usize,
+                    );
+
+                    add_parameter_attr(
+                        &mut builder,
+                        &sig.label,
+                        offset_start..offset_end,
+                        active_color.clone(),
+                    );
+                }
+            }
+
+            parameter
+                .documentation
+                .as_ref()
+                .map(|doc| parse_documentation(doc, config))
+        } else {
+            None
+        };
+
+        // TODO: make this a code block of the current language
+
+        (builder.build(), param_doc)
+    };
+
+    (label, param_doc, doc)
+}
+
+/// Add the attributes for the parameter range onto the [`RichTextBuilder`]
+fn add_parameter_attr(
+    builder: &mut RichTextBuilder,
+    label: &str,
+    range: Range<usize>,
+    color: Color,
+) {
+    if range.start < range.end && label.get(range.clone()).is_some() {
+        // TODO: This could be configurable by the user
+        builder
+            .add_attributes_for_range(range)
+            .weight(FontWeight::BOLD)
+            .text_color(color);
+    }
+}
diff --git a/lapce-ui/src/source_control.rs b/lapce-ui/src/source_control.rs
index 855623c05e..decc48a3aa 100644
--- a/lapce-ui/src/source_control.rs
+++ b/lapce-ui/src/source_control.rs
@@ -3,21 +3,25 @@ use std::sync::Arc;
 use druid::{
     kurbo::BezPath,
     piet::{Text, TextLayout as PietTextLayout, TextLayoutBuilder},
-    BoxConstraints, Color, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
-    LifeCycleCtx, PaintCtx, Point, RenderContext, Size, Target, UpdateCtx, Widget,
-    WidgetExt, WidgetId,
+    BoxConstraints, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
+    LifeCycleCtx, MouseButton, MouseEvent, PaintCtx, Point, Rect, RenderContext,
+    Size, Target, UpdateCtx, Widget, WidgetExt, WidgetId,
 };
 use lapce_data::{
-    command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::LapceTheme,
-    data::{FocusArea, LapceTabData, PanelKind},
+    command::{
+        CommandKind, LapceCommand, LapceUICommand, LapceWorkbenchCommand,
+        LAPCE_COMMAND, LAPCE_UI_COMMAND,
+    },
+    config::{LapceIcons, LapceTheme},
+    data::{FocusArea, LapceData, LapceTabData},
+    panel::PanelKind,
 };
 use lapce_rpc::source_control::FileDiff;
 
 use crate::{
+    button::Button,
     editor::view::LapceEditorView,
-    panel::{LapcePanel, PanelHeaderKind},
-    svg::{file_svg, get_svg},
+    panel::{LapcePanel, PanelHeaderKind, PanelSizing},
 };
 
 pub fn new_source_control_panel(data: &LapceTabData) -> LapcePanel {
@@ -32,25 +36,48 @@ pub fn new_source_control_panel(data: &LapceTabData) -> LapcePanel {
             .hide_gutter()
             .set_placeholder("Commit Message".to_string())
             .padding((15.0, 15.0));
+
+    let commit_button = Button::new(data, "Commit")
+        .on_click(|ctx, data, _env| {
+            ctx.submit_command(Command::new(
+                LAPCE_COMMAND,
+                LapceCommand {
+                    kind: CommandKind::Workbench(
+                        LapceWorkbenchCommand::SourceControlCommit,
+                    ),
+                    data: None,
+                },
+                Target::Widget(data.id),
+            ));
+        })
+        .expand_width()
+        .with_id(data.source_control.commit_button_id)
+        .padding((10.0, 0.0, 10.0, 10.0));
+
     let content = SourceControlFileList::new(data.source_control.file_list_id);
+
     LapcePanel::new(
         PanelKind::SourceControl,
         data.source_control.widget_id,
         data.source_control.split_id,
-        data.source_control.split_direction,
-        PanelHeaderKind::Simple("Source Control".into()),
         vec![
             (
                 editor_data.view_id,
                 PanelHeaderKind::None,
                 input.boxed(),
-                Some(300.0),
+                PanelSizing::Size(300.0),
+            ),
+            (
+                data.source_control.commit_button_id,
+                PanelHeaderKind::None,
+                commit_button.boxed(),
+                PanelSizing::Flex(false),
             ),
             (
                 data.source_control.file_list_id,
                 PanelHeaderKind::Simple("Changes".into()),
                 content.boxed(),
-                None,
+                PanelSizing::Flex(false),
             ),
         ],
     )
@@ -58,7 +85,10 @@ pub fn new_source_control_panel(data: &LapceTabData) -> LapcePanel {
 
 struct SourceControlFileList {
     widget_id: WidgetId,
+    mouse_pos: Option<Point>,
     mouse_down: Option<usize>,
+    current_line: Option<usize>,
+    line_rects: Vec<Rect>,
     line_height: f64,
 }
 
@@ -66,7 +96,10 @@ impl SourceControlFileList {
     pub fn new(widget_id: WidgetId) -> Self {
         Self {
             widget_id,
+            mouse_pos: None,
             mouse_down: None,
+            current_line: None,
+            line_rects: vec![],
             line_height: 25.0,
         }
     }
@@ -76,7 +109,16 @@ impl SourceControlFileList {
         let source_control = Arc::make_mut(&mut data.source_control);
         source_control.active = self.widget_id;
         data.focus_area = FocusArea::Panel(PanelKind::SourceControl);
-        data.focus = self.widget_id;
+        data.focus = Arc::new(self.widget_id);
+    }
+
+    fn icon_hit_test(&self, mouse_event: &MouseEvent) -> Option<usize> {
+        for (i, rect) in self.line_rects.iter().enumerate() {
+            if rect.contains(mouse_event.pos) {
+                return Some(i);
+            }
+        }
+        None
     }
 }
 
@@ -93,9 +135,19 @@ impl Widget<LapceTabData> for SourceControlFileList {
         env: &Env,
     ) {
         match event {
-            Event::MouseMove(_mouse_event) => {
-                ctx.set_cursor(&druid::Cursor::Pointer);
+            Event::MouseMove(mouse_event) => {
                 ctx.set_handled();
+                self.mouse_pos = Some(mouse_event.pos);
+                let current_line = self.icon_hit_test(mouse_event);
+                if current_line.is_some() {
+                    ctx.set_cursor(&druid::Cursor::Pointer);
+                } else {
+                    ctx.clear_cursor();
+                }
+                if current_line != self.current_line {
+                    ctx.request_paint();
+                    self.current_line = current_line;
+                }
             }
             Event::MouseUp(mouse_event) => {
                 let y = mouse_event.pos.y;
@@ -110,6 +162,7 @@ impl Widget<LapceTabData> for SourceControlFileList {
                                     Arc::make_mut(&mut data.source_control);
                                 source_control.file_diffs[line].1 =
                                     !source_control.file_diffs[line].1;
+                                ctx.request_paint();
                             }
                         }
                     }
@@ -118,29 +171,104 @@ impl Widget<LapceTabData> for SourceControlFileList {
                 ctx.set_handled();
             }
             Event::MouseDown(mouse_event) => {
-                self.mouse_down = None;
-                let source_control = Arc::make_mut(&mut data.source_control);
-                let y = mouse_event.pos.y;
-                if y > 0.0 {
-                    let line = (y / self.line_height).floor() as usize;
-                    if line < source_control.file_diffs.len() {
-                        source_control.file_list_index = line;
-                        if mouse_event.pos.x < self.line_height {
-                            self.mouse_down = Some(line);
-                        } else {
-                            ctx.submit_command(Command::new(
-                                LAPCE_UI_COMMAND,
-                                LapceUICommand::OpenFileDiff(
-                                    source_control.file_diffs[line].0.path().clone(),
-                                    "head".to_string(),
-                                ),
-                                Target::Widget(data.id),
-                            ));
+                if mouse_event.pos.y < 0.0 {
+                    return;
+                }
+
+                let target_line =
+                    (mouse_event.pos.y / self.line_height).floor() as usize;
+
+                match mouse_event.button {
+                    MouseButton::Left => {
+                        self.mouse_down = None;
+                        let source_control = Arc::make_mut(&mut data.source_control);
+
+                        if target_line < source_control.file_diffs.len() {
+                            source_control.file_list_index = target_line;
+                            if mouse_event.pos.x < self.line_height {
+                                self.mouse_down = Some(target_line);
+                            } else {
+                                ctx.submit_command(Command::new(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::OpenFileDiff {
+                                        path: source_control
+                                            .file_diffs
+                                            .get_index(target_line)
+                                            .unwrap()
+                                            .0
+                                            .clone(),
+                                        history: "head".to_string(),
+                                    },
+                                    Target::Widget(data.id),
+                                ));
+                            }
                         }
+
+                        self.request_focus(ctx, data);
+                        ctx.set_handled();
                     }
+                    MouseButton::Right => {
+                        let source_control = data.source_control.clone();
+                        let (target_file_path, target_file_diff) = source_control
+                            .file_diffs
+                            .get_index(target_line)
+                            .map(|(path, (diff, _))| (path.clone(), diff.clone()))
+                            .unwrap();
+
+                        let mut menu = druid::Menu::<LapceData>::new("");
+                        let mut item = druid::MenuItem::new("Open Changes").command(
+                            Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::OpenFileDiff {
+                                    path: target_file_path.clone(),
+                                    history: "head".to_string(),
+                                },
+                                Target::Auto,
+                            ),
+                        );
+
+                        menu = menu.entry(item);
+
+                        let enable_open_file =
+                            !matches!(target_file_diff, FileDiff::Deleted(_));
+
+                        item = druid::MenuItem::new("Open File")
+                            .enabled(enable_open_file)
+                            .on_activate(move |ctx, _, _| {
+                                ctx.submit_command(Command::new(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::OpenFile(
+                                        target_file_path.clone(),
+                                        true,
+                                    ),
+                                    Target::Auto,
+                                ));
+                            });
+
+                        menu = menu.entry(item);
+
+                        menu = menu.separator();
+
+                        item = druid::MenuItem::new("Discard Changes")
+                            .on_activate(move |ctx, _, _| {
+                                ctx.submit_command(Command::new(
+                                    LAPCE_COMMAND,
+                                    LapceCommand {
+                                        kind: CommandKind::Workbench(
+                                             LapceWorkbenchCommand::SourceControlDiscardTargetFileChanges
+                                        ),
+                                        data: Some(serde_json::json!(target_file_diff.clone()))
+                                    },
+                                    Target::Auto,
+                                ));
+                            });
+
+                        menu = menu.entry(item);
+
+                        ctx.show_context_menu(menu, mouse_event.window_pos)
+                    }
+                    _ => {}
                 }
-                self.request_focus(ctx, data);
-                ctx.set_handled();
             }
             Event::KeyDown(key_event) => {
                 let mut keypress = data.keypress.clone();
@@ -207,9 +335,7 @@ impl Widget<LapceTabData> for SourceControlFileList {
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
         let self_size = ctx.size();
 
-        let diffs = &data.source_control.file_diffs;
-
-        if ctx.is_focused() && !diffs.is_empty() {
+        if ctx.is_focused() && !data.source_control.file_diffs.is_empty() {
             let rect = Size::new(ctx.size().width, self.line_height)
                 .to_rect()
                 .with_origin(Point::new(
@@ -218,26 +344,49 @@ impl Widget<LapceTabData> for SourceControlFileList {
                 ));
             ctx.fill(
                 rect,
-                data.config.get_color_unchecked(LapceTheme::PANEL_CURRENT),
+                data.config
+                    .get_color_unchecked(LapceTheme::PANEL_CURRENT_BACKGROUND),
             );
         }
 
         let rect = ctx.region().bounding_box();
         let start_line = (rect.y0 / self.line_height).floor() as usize;
         let end_line = (rect.y1 / self.line_height).ceil() as usize;
+        self.line_rects = vec![];
         for line in start_line..end_line {
-            if line >= diffs.len() {
+            if line >= data.source_control.file_diffs.len() {
                 break;
             }
             let y = self.line_height * line as f64;
-            let (diff, checked) = diffs[line].clone();
-            let mut path = diff.path().clone();
+
+            let current_line = Size::new(ctx.size().width, self.line_height)
+                .to_rect()
+                .with_origin(Point::new(0.0, y));
+            self.line_rects.push(current_line);
+            if let Some(mouse_pos) = self.mouse_pos {
+                if current_line.contains(mouse_pos) {
+                    ctx.fill(
+                        current_line,
+                        data.config.get_color_unchecked(
+                            LapceTheme::PANEL_CURRENT_BACKGROUND,
+                        ),
+                    );
+                }
+            }
+
+            let (mut path, (diff, checked)) = data
+                .source_control
+                .file_diffs
+                .get_index(line)
+                .map(|d| (d.0.clone(), d.1))
+                .unwrap();
             if let Some(workspace_path) = data.workspace.path.as_ref() {
                 path = path
                     .strip_prefix(workspace_path)
                     .unwrap_or(&path)
                     .to_path_buf();
             }
+
             {
                 let width = 13.0;
                 let height = 13.0;
@@ -246,24 +395,37 @@ impl Widget<LapceTabData> for SourceControlFileList {
                     (self.line_height - height) / 2.0 + y,
                 );
                 let rect = Size::new(width, height).to_rect().with_origin(origin);
-                ctx.stroke(rect, &Color::rgb8(0, 0, 0), 1.0);
+                ctx.stroke(
+                    rect,
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+                    1.0,
+                );
 
-                if checked {
+                if *checked {
                     let mut path = BezPath::new();
                     path.move_to((origin.x + 3.0, origin.y + 7.0));
                     path.line_to((origin.x + 6.0, origin.y + 9.5));
                     path.line_to((origin.x + 10.0, origin.y + 3.0));
-                    ctx.stroke(path, &Color::rgb8(0, 0, 0), 2.0);
+                    ctx.stroke(
+                        path,
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+                        2.0,
+                    );
                 }
             }
-            let svg = file_svg(&path);
-            let width = 13.0;
-            let height = 13.0;
-            let rect = Size::new(width, height).to_rect().with_origin(Point::new(
-                (self.line_height - width) / 2.0 + self.line_height,
-                (self.line_height - height) / 2.0 + y,
-            ));
-            ctx.draw_svg(&svg, rect, None);
+
+            let svg_size = data.config.ui.icon_size() as f64;
+            let (svg, svg_color) = data.config.file_svg(&path);
+            let rect =
+                Size::new(svg_size, svg_size)
+                    .to_rect()
+                    .with_origin(Point::new(
+                        (self.line_height - svg_size) / 2.0 + self.line_height,
+                        (self.line_height - svg_size) / 2.0 + y,
+                    ));
+            ctx.draw_svg(&svg, rect, svg_color);
 
             let file_name = path
                 .file_name()
@@ -289,7 +451,7 @@ impl Widget<LapceTabData> for SourceControlFileList {
                 &text_layout,
                 Point::new(
                     self.line_height * 2.0,
-                    y + (self.line_height - text_layout.size().height) / 2.0,
+                    y + text_layout.y_offset(self.line_height),
                 ),
             );
             let folder = path
@@ -318,36 +480,35 @@ impl Widget<LapceTabData> for SourceControlFileList {
                     &text_layout,
                     Point::new(
                         self.line_height * 2.0 + x + 5.0,
-                        y + (self.line_height - text_layout.size().height) / 2.0,
+                        y + text_layout.y_offset(self.line_height),
                     ),
                 );
             }
 
             let (svg, color) = match diff {
                 FileDiff::Modified(_) => (
-                    "diff-modified.svg",
+                    LapceIcons::SCM_DIFF_MODIFIED,
                     data.config
                         .get_color_unchecked(LapceTheme::SOURCE_CONTROL_MODIFIED),
                 ),
                 FileDiff::Added(_) => (
-                    "diff-added.svg",
+                    LapceIcons::SCM_DIFF_ADDED,
                     data.config
                         .get_color_unchecked(LapceTheme::SOURCE_CONTROL_ADDED),
                 ),
                 FileDiff::Deleted(_) => (
-                    "diff-removed.svg",
+                    LapceIcons::SCM_DIFF_REMOVED,
                     data.config
                         .get_color_unchecked(LapceTheme::SOURCE_CONTROL_REMOVED),
                 ),
                 FileDiff::Renamed(_, _) => (
-                    "diff-renamed.svg",
+                    LapceIcons::SCM_DIFF_RENAMED,
                     data.config
                         .get_color_unchecked(LapceTheme::SOURCE_CONTROL_MODIFIED),
                 ),
             };
-            let svg = get_svg(svg).unwrap();
+            let svg = data.config.ui_svg(svg);
 
-            let svg_size = 15.0;
             let rect =
                 Size::new(svg_size, svg_size)
                     .to_rect()
@@ -356,7 +517,7 @@ impl Widget<LapceTabData> for SourceControlFileList {
                         line as f64 * self.line_height
                             + (self.line_height - svg_size) / 2.0,
                     ));
-            ctx.draw_svg(&svg, rect, Some(&color.clone().with_alpha(0.9)));
+            ctx.draw_svg(&svg, rect, Some(color));
         }
     }
 }
diff --git a/lapce-ui/src/split.rs b/lapce-ui/src/split.rs
index 6cccf9f18f..3a0cfa82db 100644
--- a/lapce-ui/src/split.rs
+++ b/lapce-ui/src/split.rs
@@ -1,36 +1,34 @@
-use crate::{
-    editor::{tab::LapceEditorTab, view::LapceEditorView},
-    settings::LapceSettingsPanel,
-    terminal::LapceTerminalView,
-};
 use std::sync::Arc;
 
-use crate::svg::logo_svg;
 use druid::{
     kurbo::{Line, Rect},
     piet::{PietTextLayout, Text, TextLayout, TextLayoutBuilder},
-    Command, Target, WidgetId,
-};
-use druid::{
-    BoxConstraints, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx,
-    PaintCtx, Point, RenderContext, Size, UpdateCtx, Widget, WidgetExt, WidgetPod,
+    BoxConstraints, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
+    LifeCycleCtx, PaintCtx, Point, RenderContext, Size, Target, UpdateCtx, Widget,
+    WidgetExt, WidgetId, WidgetPod,
 };
 use lapce_data::{
     command::{
         CommandKind, LapceCommand, LapceUICommand, LapceWorkbenchCommand,
         LAPCE_COMMAND, LAPCE_UI_COMMAND,
     },
-    config::{Config, LapceTheme},
-    data::{
-        EditorTabChild, FocusArea, LapceEditorData, LapceTabData, PanelKind,
-        SplitContent, SplitData,
-    },
+    config::{LapceConfig, LapceTheme},
+    data::{FocusArea, LapceEditorData, LapceTabData, SplitContent, SplitData},
     keypress::{Alignment, DefaultKeyPressHandler, KeyMap},
+    panel::PanelKind,
     split::{SplitDirection, SplitMoveDirection},
     terminal::LapceTerminalData,
 };
 use lapce_rpc::terminal::TermId;
 
+use crate::{
+    editor::{
+        tab::LapceEditorTab,
+        view::{editor_tab_child_widget, LapceEditorView},
+    },
+    terminal::LapceTerminalView,
+};
+
 struct LapceDynamicSplit {
     widget_id: WidgetId,
     children: Vec<ChildWidget>,
@@ -41,7 +39,7 @@ pub fn split_data_widget(split_data: &SplitData, data: &LapceTabData) -> LapceSp
         LapceSplit::new(split_data.widget_id).direction(split_data.direction);
     for child in split_data.children.iter() {
         let child = split_content_widget(child, data);
-        split = split.with_flex_child(child, None, 1.0);
+        split = split.with_flex_child(child, None, 1.0, true);
     }
     split
 }
@@ -56,26 +54,8 @@ pub fn split_content_widget(
                 data.main_split.editor_tabs.get(widget_id).unwrap();
             let mut editor_tab = LapceEditorTab::new(editor_tab_data.widget_id);
             for child in editor_tab_data.children.iter() {
-                match child {
-                    EditorTabChild::Editor(view_id, editor_id, find_view_id) => {
-                        let editor = LapceEditorView::new(
-                            *view_id,
-                            *editor_id,
-                            *find_view_id,
-                        )
-                        .boxed();
-                        editor_tab = editor_tab.with_child(editor);
-                    }
-                    EditorTabChild::Settings(widget_id, editor_tab_id) => {
-                        let settings = LapceSettingsPanel::new(
-                            data,
-                            *widget_id,
-                            *editor_tab_id,
-                        )
-                        .boxed();
-                        editor_tab = editor_tab.with_child(settings);
-                    }
-                }
+                let child = editor_tab_child_widget(child, data);
+                editor_tab = editor_tab.with_child(child);
             }
             editor_tab.boxed()
         }
@@ -88,6 +68,7 @@ pub fn split_content_widget(
                     split_content_widget(content, data),
                     None,
                     1.0,
+                    true,
                 );
             }
             split.boxed()
@@ -195,13 +176,30 @@ pub struct LapceSplit {
     direction: SplitDirection,
     show_border: bool,
     commands: Vec<(LapceCommand, PietTextLayout, Rect, Option<KeyMap>)>,
+    panel: Option<PanelKind>,
+    /// Whether the resize bar is hovered  
+    /// Contains the [`WidgetId`] of the child we are resizing
+    bar_hovered: Option<WidgetId>,
+    /// The sum of the non flex child sizes  
+    /// This is updated whenever we layout
+    non_flex_total: f64,
+    /// The total size of the split  
+    /// This is updated whenever we layout
+    total_size: f64,
 }
 
 struct ChildWidget {
-    pub widget: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    widget: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
     flex: bool,
     params: f64,
     layout_rect: Rect,
+    /// Whether it can be resized through the UI
+    resizable: bool,
+    /// The offset (in the direction, so x0 or y0) to use when resizing
+    /// This is used to avoid noise accumulation in the floating point math when resizing
+    resize_pos: f64,
+    /// Whether we should update the resize pos, even if we are currently resizing.
+    update_resize_pos: bool,
 }
 
 impl LapceSplit {
@@ -213,6 +211,10 @@ impl LapceSplit {
             direction: SplitDirection::Vertical,
             show_border: true,
             commands: vec![],
+            panel: None,
+            bar_hovered: None,
+            non_flex_total: 0.0,
+            total_size: 0.0,
         }
     }
 
@@ -221,6 +223,14 @@ impl LapceSplit {
         self
     }
 
+    /// Set the panel kind on the split, so that split can
+    /// determine the split direction based on the position
+    /// of the panel
+    pub fn panel(mut self, panel: PanelKind) -> Self {
+        self.panel = Some(panel);
+        self
+    }
+
     pub fn horizontal(mut self) -> Self {
         self.direction = SplitDirection::Horizontal;
         self
@@ -236,12 +246,16 @@ impl LapceSplit {
         child: Box<dyn Widget<LapceTabData>>,
         child_id: Option<WidgetId>,
         params: f64,
+        resizable: bool,
     ) -> Self {
         let child = ChildWidget {
             widget: WidgetPod::new(child),
             flex: true,
             params,
             layout_rect: Rect::ZERO,
+            resizable,
+            resize_pos: 0.0,
+            update_resize_pos: true,
         };
         self.children_ids
             .push(child_id.unwrap_or_else(|| child.widget.id()));
@@ -259,7 +273,10 @@ impl LapceSplit {
             widget: WidgetPod::new(child),
             flex: false,
             params,
+            resizable: false,
             layout_rect: Rect::ZERO,
+            resize_pos: 0.0,
+            update_resize_pos: true,
         };
         self.children_ids
             .push(child_id.unwrap_or_else(|| child.widget.id()));
@@ -285,12 +302,16 @@ impl LapceSplit {
         child: Box<dyn Widget<LapceTabData>>,
         child_id: Option<WidgetId>,
         params: f64,
+        resizable: bool,
     ) -> WidgetId {
         let child = ChildWidget {
             widget: WidgetPod::new(child),
             flex: true,
             params,
             layout_rect: Rect::ZERO,
+            resizable,
+            resize_pos: 0.0,
+            update_resize_pos: true,
         };
         let child_id = child_id.unwrap_or_else(|| child.widget.id());
         self.children_ids.insert(index, child_id);
@@ -306,12 +327,236 @@ impl LapceSplit {
         }
     }
 
-    fn paint_bar(&mut self, ctx: &mut PaintCtx, config: &Config) {
+    /// Returns the child whose border we are resizing 'at'
+    fn resize_bar_hit_test(&self, mouse_pos: Point) -> Option<&ChildWidget> {
+        // Currently we don't support resizing splits with non flex children
+        // This should be fixed.
+        if self.has_non_flex_children() {
+            return None;
+        }
+
+        // TODO: We probably aren't being as restrictive about what outofbounds positions are allowed as we should!
+        // We only check the resize bar for the 'second' child, since it's left/upper
+        // bar is the actual bar we want to use for resizing.
+        // We currently only consider flex children, but this could perhaps be extended?
+        for child in self
+            .children
+            .iter()
+            .skip(1)
+            .filter(|ch| ch.flex && ch.resizable)
+        {
+            // TODO: provide information about which child widget this is, so that we can actually resize it!
+            if self.direction == SplitDirection::Vertical {
+                let x = child.layout_rect.x0;
+                if mouse_pos.x >= x - 2.0 && mouse_pos.x <= x + 2.0 {
+                    return Some(child);
+                }
+            } else {
+                let y = child.layout_rect.y0;
+                if mouse_pos.y >= y - 2.0 && mouse_pos.y <= y + 2.0 {
+                    return Some(child);
+                }
+            }
+        }
+
+        None
+    }
+
+    fn get_hovered_child_index(&self) -> Option<usize> {
+        if let Some(child_id) = self.bar_hovered {
+            self.children
+                .iter()
+                .enumerate()
+                .find(|(_, c)| c.widget.id() == child_id)
+                .map(|(i, _)| i)
+        } else {
+            None
+        }
+    }
+
+    fn update_resize_point(&mut self, mouse_pos: Point) {
+        if let Some(i) = self.get_hovered_child_index() {
+            // We want to move the start edge of the editor to be where the mouse is, since they're dragging that edge
+            let start = match self.direction {
+                SplitDirection::Vertical => mouse_pos.x,
+                SplitDirection::Horizontal => mouse_pos.y,
+            };
+
+            self.shift_start_of_child(i, start, true);
+        }
+    }
+
+    /// Shift the x0/y0 (start) of the specific child at `i`  
+    /// `allow_shifting` decides whether we should shift other children if the start is sufficiently far back
+    /// this is for dragging an editor to the left and causing other editors to the left to also be dragged
+    fn shift_start_of_child(&mut self, i: usize, start: f64, allow_shifting: bool) {
+        // We can't move the start of the zeroth entry, and it isn't meaningful to move the start
+        // of anything past the end
+        if i == 0 || i >= self.children.len() {
+            return;
+        }
+
+        // TODO: We should implement support for a mix of flex and non-flex children
+        // though that complicates things somewhat, and for most cases that we need resizing for
+        // they are all flex. We'd need to do some more logic to shift the indices to the flex
+        // entries that we want to consider, and bound the movement of the splits to the non-flex entries.
+        if self.has_non_flex_children() {
+            return;
+        }
+
+        let start = start.round();
+        let flex_total = self.total_size - self.non_flex_total;
+        // TODO: let the margin be customizable? Also, is this the best margin we could use?
+        // Limits how close the resize can get to another get to another editor or the edge
+        let limit_margin = (0.05 * flex_total).max(5.0);
+
+        // Constrain the start position to be within the bounds of the editor, and
+        // after the previous editor.
+        let prev_offset = self
+            .children
+            .get(i - 1)
+            .map(|ch| ch.resize_pos)
+            .unwrap_or(0.0);
+        let next_offset = self
+            .children
+            .get(i + 1)
+            .map(|ch| ch.resize_pos)
+            .unwrap_or(flex_total);
+
+        let prev_limit = prev_offset + limit_margin;
+        let next_limit = next_offset - limit_margin;
+
+        let start = if allow_shifting && start <= prev_limit {
+            // If the start is before the previous offset, then we can start moving the previous editor
+            start.max(limit_margin * i as f64).min(next_limit)
+        } else if allow_shifting && start >= next_limit {
+            start
+                .max(prev_limit)
+                .min(flex_total - limit_margin * (self.children.len() - i) as f64)
+        } else {
+            start.max(prev_limit).min(next_limit)
+        };
+
+        // Check if we're shifting a specific previous child
+        let is_shifting_prev = |child_i: usize, child_offset: f64| -> bool {
+            allow_shifting
+                && child_i < i
+                && child_i != 0
+                && start <= child_offset + limit_margin * (i - child_i) as f64
+        };
+
+        // Check if we're shifting a specific child after us
+        let is_shifting_after = |child_i: usize, child_offset: f64| -> bool {
+            allow_shifting
+                && child_i > i
+                && start >= child_offset - limit_margin * (child_i - i) as f64
+        };
+
+        // Get the offset/position we want a child to start at. Skips non-flex entries as if they weren't there
+        // This uses the existing position for every child except the one we are resizing
+        let get_offset = |child_i: usize, children: &[ChildWidget]| -> f64 {
+            let child = &children[child_i];
+            // We use resize pos instead of the layout_rect.x0 because that gets rounded a bit and even if we didn't round
+            // there is some noise inherent in the calculation done in the layout.
+            // Thus we keep track of a separate position, which we only allow to update (to the layout_rect.x0 value) whenever
+            // we actually would have caused a change.
+            let offset = child.resize_pos;
+
+            if child_i == i {
+                // We return the position we want to put the editor at, rather than whatever its
+                // actual position is
+                start
+            } else if is_shifting_prev(child_i, offset) {
+                // If we're shifting an editor then we need to modify its position relative to the mouse
+                // and shift it by the limit_margin so that it is shifted at a distance
+                let shift_size = (i - child_i) as f64;
+                (start - limit_margin * shift_size)
+                    .max(0.0 + limit_margin * child_i as f64)
+            } else if is_shifting_after(child_i, offset) {
+                let shift_size = (child_i - i) as f64;
+                let from_end_shift = (children.len() - child_i) as f64;
+                (start + limit_margin * shift_size)
+                    // .min(flex_total - limit_margin * shift_size + limit_margin)
+                    .min(flex_total - limit_margin * from_end_shift)
+            } else {
+                // Otherwise, we just have the editor use its current position
+                offset
+            }
+        };
+
+        // For more than two children, we can't just update a single param to shift the start of any child
+        // We have to update multiple. There might be a way to just update a few params, rather than every single
+        // param, but given the amount of expected splits, it just isn't worth the extra effort.
+        // The basic logic is that we have:
+        // x_i = T * c_{i-1} / (sum c)
+        // aka x_i = flex_total * children[i].params / children.iter().map(|ch| ch.params).sum()
+        // So we have some x positions (existing x positions and the new one after resizing) and we want to
+        // get the params that would produce those x positions.
+        // However, this equation has an infinite number of solutions, so no single answer awaits us
+        // but, with algebra we can get:
+        // c_i = k * (x_{i + 1} - x_i)/T
+        // where k is any positive non-zero value
+        // so we can just choose k = 1
+        // we could also have chosen k = T to just get: c_i = x_{i + 1} - xi
+        // but normalizing by T gets us a nice percentage-like behavior (though, only after a resize!)
+        // or we could have chosen a k s.t. the sum is always children.len(), which would
+        // match the values it has when you initialize (since they default to a param of 1.0)
+        // Currently we don't rely on that, but if we want to do that, then it is pretty simple.
+        for child_i in 0..self.children.len() {
+            let next_child_i = child_i + 1;
+
+            // If we've caused a change, then allow the stored position to update.
+            // This still allows a tiny bit of noise, but it is more of a tiny jitter rather than the
+            // constant shifting to the side that we would get without this method.
+            if child_i == i
+                || child_i == 0
+                || is_shifting_prev(child_i, self.children[child_i].resize_pos)
+                || is_shifting_after(child_i, self.children[child_i].resize_pos)
+            {
+                self.children[child_i].update_resize_pos = true;
+            }
+
+            // x_i
+            let start_offset = get_offset(child_i, &self.children);
+            // x_{i+1}
+            // If it is the last entry, just use the total
+            let end_offset = if next_child_i >= self.children.len() {
+                flex_total
+            } else {
+                get_offset(next_child_i, &self.children)
+            };
+
+            // x_{i+1} - x_i
+            let diff = end_offset - start_offset;
+            self.children[child_i].params = diff / flex_total;
+        }
+
+        // TODO: Post-sanity check that ensures everything is inside the editor bounds?
+        // While this shouldn't occur, it would be good to ensure it simply doesn't happen.
+
+        // TODO: We get negative box constraints in layouting, which is unfortunate.
+
+        // TODO: While resizing the split arrows flicker since the mouse is constantly moving between the sides.
+        // TODO: Write to db the sizes so it gets restored? Though this shouldn't be done every single call to this!
+        //  Probably just when we reset the bar_hovered
+    }
+
+    fn has_non_flex_children(&self) -> bool {
+        self.children.iter().any(|ch| !ch.flex)
+    }
+
+    fn paint_bar(&mut self, ctx: &mut PaintCtx, config: &LapceConfig) {
         let children_len = self.children.len();
         if children_len <= 1 {
             return;
         }
 
+        let hover_i = if ctx.is_hot() || ctx.is_active() {
+            self.get_hovered_child_index()
+        } else {
+            None
+        };
+
         let size = ctx.size();
         for i in 1..children_len {
             let line = if self.direction == SplitDirection::Vertical {
@@ -323,11 +568,16 @@ impl LapceSplit {
 
                 Line::new(Point::new(0.0, y), Point::new(size.width, y))
             };
-            ctx.stroke(
-                line,
-                config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
-                1.0,
-            );
+
+            // Match the panel resize bar if we're hovering over the editor split bar
+            let (color, width) = if Some(i) == hover_i {
+                (LapceTheme::EDITOR_CARET, 2.0)
+            } else {
+                (LapceTheme::LAPCE_BORDER, 1.0)
+            };
+            let color = config.get_color_unchecked(color);
+
+            ctx.stroke(line, color, width);
         }
     }
 
@@ -499,6 +749,8 @@ impl LapceSplit {
         ));
         let terminal = LapceTerminalView::new(&terminal_data);
         Arc::make_mut(&mut data.terminal)
+            .active_terminal_split_mut()
+            .unwrap()
             .terminals
             .insert(terminal_data.term_id, terminal_data.clone());
 
@@ -507,6 +759,7 @@ impl LapceSplit {
             terminal.boxed(),
             Some(terminal_data.widget_id),
             1.0,
+            true,
         );
         self.even_flex_children();
         ctx.children_changed();
@@ -524,24 +777,16 @@ impl LapceSplit {
         }
 
         if self.children.len() == 1 {
-            Arc::make_mut(&mut data.terminal).terminals.remove(&term_id);
+            Arc::make_mut(&mut data.terminal)
+                .active_terminal_split_mut()
+                .unwrap()
+                .terminals
+                .remove(&term_id);
             self.children.remove(0);
             self.children_ids.remove(0);
 
             self.even_flex_children();
             ctx.children_changed();
-            for (_pos, panel) in data.panels.iter_mut() {
-                if panel.active == PanelKind::Terminal {
-                    Arc::make_mut(panel).shown = false;
-                }
-            }
-            if let Some(active) = *data.main_split.active_tab {
-                ctx.submit_command(Command::new(
-                    LAPCE_UI_COMMAND,
-                    LapceUICommand::Focus,
-                    Target::Widget(active),
-                ));
-            }
             return;
         }
 
@@ -566,7 +811,11 @@ impl LapceSplit {
             Target::Widget(new_terminal_id),
         ));
 
-        Arc::make_mut(&mut data.terminal).terminals.remove(&term_id);
+        Arc::make_mut(&mut data.terminal)
+            .active_terminal_split_mut()
+            .unwrap()
+            .terminals
+            .remove(&term_id);
         self.children.remove(index);
         self.children_ids.remove(index);
 
@@ -721,7 +970,7 @@ impl LapceSplit {
         focus_new: bool,
     ) {
         let new_child = split_content_widget(content, data);
-        self.insert_flex_child(index, new_child, None, 1.0);
+        self.insert_flex_child(index, new_child, None, 1.0, true);
         self.even_flex_children();
         ctx.children_changed();
         if focus_new {
@@ -758,7 +1007,6 @@ impl LapceSplit {
             &data.config,
         );
         editor_data.cursor = from_editor.cursor.clone();
-        editor_data.locations = from_editor.locations.clone();
         ctx.submit_command(Command::new(
             LAPCE_UI_COMMAND,
             LapceUICommand::ForceScrollTo(
@@ -778,6 +1026,7 @@ impl LapceSplit {
             editor.boxed(),
             Some(editor_data.view_id),
             1.0,
+            true,
         );
         self.even_flex_children();
         ctx.children_changed();
@@ -799,23 +1048,21 @@ impl Widget<LapceTabData> for LapceSplit {
         env: &Env,
     ) {
         match event {
-            Event::MouseMove(mouse_event) => {
-                if self.children.is_empty() {
-                    let mut on_command = false;
-                    for (_, _, rect, _) in &self.commands {
-                        if rect.contains(mouse_event.pos) {
-                            on_command = true;
-                            break;
-                        }
-                    }
-                    if on_command {
-                        ctx.set_cursor(&druid::Cursor::Pointer);
-                    } else {
-                        ctx.clear_cursor();
-                    }
+            Event::MouseUp(mouse_event) => {
+                if mouse_event.button.is_left() && ctx.is_active() {
+                    ctx.set_active(false);
                 }
             }
             Event::MouseDown(mouse_event) => {
+                if mouse_event.button.is_left() {
+                    if let Some(child) = self.resize_bar_hit_test(mouse_event.pos) {
+                        self.bar_hovered = Some(child.widget.id());
+                        ctx.set_active(true);
+                        ctx.set_handled();
+                        return;
+                    }
+                }
+
                 if self.children.is_empty() {
                     for (cmd, _, rect, _) in &self.commands {
                         if rect.contains(mouse_event.pos) {
@@ -858,7 +1105,7 @@ impl Widget<LapceTabData> for LapceSplit {
                                 ));
                             } else {
                                 ctx.request_focus();
-                                data.focus = self.split_id;
+                                data.focus = Arc::new(self.split_id);
                                 data.focus_area = FocusArea::Editor;
                             }
                         }
@@ -896,47 +1143,62 @@ impl Widget<LapceTabData> for LapceSplit {
                     LapceUICommand::SplitTerminalClose(term_id, widget_id) => {
                         self.split_terminal_close(ctx, data, *term_id, *widget_id);
                     }
-                    LapceUICommand::InitTerminalPanel(focus) => {
-                        if data.terminal.terminals.is_empty() {
-                            let terminal_data = Arc::new(LapceTerminalData::new(
-                                data.workspace.clone(),
-                                data.terminal.split_id,
-                                ctx.get_external_handle(),
-                                data.proxy.clone(),
-                                &data.config,
-                            ));
-                            let terminal = LapceTerminalView::new(&terminal_data);
-                            self.insert_flex_child(
-                                0,
-                                terminal.boxed(),
-                                Some(terminal_data.widget_id),
-                                1.0,
-                            );
-                            if *focus {
-                                ctx.submit_command(Command::new(
-                                    LAPCE_UI_COMMAND,
-                                    LapceUICommand::Focus,
-                                    Target::Widget(terminal_data.widget_id),
-                                ));
-                            }
-                            let terminal_panel = Arc::make_mut(&mut data.terminal);
-                            terminal_panel.active = terminal_data.widget_id;
-                            terminal_panel.active_term_id = terminal_data.term_id;
-                            terminal_panel
-                                .terminals
-                                .insert(terminal_data.term_id, terminal_data);
-                            ctx.children_changed();
-                        }
-                    }
                     _ => (),
                 }
                 return;
             }
             _ => (),
         }
+
         for child in self.children.iter_mut() {
             child.widget.event(ctx, event, data, env);
         }
+
+        if let Event::MouseMove(mouse_event) = event {
+            if self.children.is_empty() {
+                ctx.clear_cursor();
+                for (_, _, rect, _) in &self.commands {
+                    if rect.contains(mouse_event.pos) {
+                        ctx.set_cursor(&druid::Cursor::Pointer);
+                        break;
+                    }
+                }
+            } else if ctx.is_active() {
+                // If we're active then we're probably being dragged
+                self.update_resize_point(mouse_event.pos);
+                ctx.request_layout();
+                ctx.set_handled();
+            } else if data.drag.is_none() {
+                let has_active =
+                    self.children.iter().any(|child| child.widget.has_active());
+                if has_active {
+                    self.bar_hovered = None;
+                    ctx.clear_cursor();
+                } else {
+                    // TODO: We probably want to make so you don't get highlighting for more than one editor
+                    // resize bar at once, and so that you don't get highlighting/dragging for an editor resize bar
+                    // and a panel resize bar! That means we need the tab to know.
+                    if let Some(child) = self.resize_bar_hit_test(mouse_event.pos) {
+                        self.bar_hovered = Some(child.widget.id());
+
+                        ctx.set_cursor(match self.direction {
+                            SplitDirection::Vertical => {
+                                &druid::Cursor::ResizeLeftRight
+                            }
+                            SplitDirection::Horizontal => {
+                                &druid::Cursor::ResizeUpDown
+                            }
+                        });
+                    } else {
+                        if self.bar_hovered.is_some() {
+                            self.bar_hovered = None;
+                            ctx.request_paint();
+                        }
+                        ctx.clear_cursor();
+                    }
+                }
+            }
+        }
     }
 
     fn lifecycle(
@@ -971,6 +1233,15 @@ impl Widget<LapceTabData> for LapceSplit {
         env: &Env,
     ) -> Size {
         let my_size = bc.max();
+        if let Some(panel) = self.panel {
+            if let Some((_, pos)) = data.panel.panel_position(&panel) {
+                if pos.is_bottom() {
+                    self.direction = SplitDirection::Vertical;
+                } else {
+                    self.direction = SplitDirection::Horizontal;
+                }
+            }
+        }
 
         let split_data = data.main_split.splits.get(&self.split_id);
 
@@ -981,7 +1252,7 @@ impl Widget<LapceTabData> for LapceSplit {
             let line_height = 35.0;
 
             self.commands = empty_editor_commands(
-                data.config.lapce.modal,
+                data.config.core.modal,
                 data.workspace.path.is_some(),
             )
             .iter()
@@ -998,7 +1269,7 @@ impl Widget<LapceTabData> for LapceSplit {
                     )
                     .text_color(
                         data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                            .get_color_unchecked(LapceTheme::EDITOR_LINK)
                             .clone(),
                     )
                     .build()
@@ -1018,7 +1289,7 @@ impl Widget<LapceTabData> for LapceSplit {
             return my_size;
         }
 
-        let mut non_flex_total = 0.0;
+        self.non_flex_total = 0.0;
         let mut max_other_axis = 0.0;
         for child in self.children.iter_mut() {
             if !child.flex {
@@ -1033,7 +1304,7 @@ impl Widget<LapceTabData> for LapceSplit {
                     data,
                     env,
                 );
-                non_flex_total += self.direction.main_size(size);
+                self.non_flex_total += self.direction.main_size(size);
                 let cross_size = self.direction.cross_size(size);
                 if cross_size > max_other_axis {
                     max_other_axis = cross_size;
@@ -1041,16 +1312,15 @@ impl Widget<LapceTabData> for LapceSplit {
                 child.layout_rect = size.to_rect();
             };
         }
-        let non_flex_total = non_flex_total;
 
         let flex_sum = self
             .children
             .iter()
-            .filter_map(|child| child.flex.then(|| child.params))
+            .filter_map(|child| child.flex.then_some(child.params))
             .sum::<f64>();
 
-        let total_size = self.direction.main_size(my_size);
-        let flex_total = total_size - non_flex_total;
+        self.total_size = self.direction.main_size(my_size);
+        let flex_total = self.total_size - self.non_flex_total;
 
         let mut next_origin = Point::ZERO;
         let children_len = self.children.len();
@@ -1061,8 +1331,10 @@ impl Widget<LapceTabData> for LapceSplit {
             if child.flex {
                 let flex = if i == children_len - 1 {
                     match self.direction {
-                        SplitDirection::Vertical => total_size - next_origin.x,
-                        SplitDirection::Horizontal => total_size - next_origin.y,
+                        SplitDirection::Vertical => self.total_size - next_origin.x,
+                        SplitDirection::Horizontal => {
+                            self.total_size - next_origin.y
+                        }
                     }
                 } else {
                     (flex_total / flex_sum * child.params).round()
@@ -1096,6 +1368,13 @@ impl Widget<LapceTabData> for LapceSplit {
                 child.layout_rect = child.layout_rect.with_size(size);
             }
 
+            if self.bar_hovered.is_none() || child.update_resize_pos {
+                // TODO: There's probably some bugs lurking with this handling of resize pos
+                // most likely to happen if we resize the window while resizing a split
+                child.resize_pos = self.direction.start(child.layout_rect);
+                child.update_resize_pos = false;
+            }
+
             let child_size = child.layout_rect.size();
             match self.direction {
                 SplitDirection::Vertical => next_origin.x += child_size.width,
@@ -1119,7 +1398,7 @@ impl Widget<LapceTabData> for LapceSplit {
             );
             ctx.with_save(|ctx| {
                 ctx.clip(rect);
-                let svg = logo_svg();
+                let svg = data.config.logo_svg();
                 let size = ctx.size();
                 let svg_size = 100.0;
                 let rect = Size::ZERO
@@ -1156,6 +1435,15 @@ impl Widget<LapceTabData> for LapceSplit {
         for child in self.children.iter_mut() {
             child.widget.paint(ctx, data, env);
         }
+        if let Some(panel) = self.panel {
+            if let Some((_, pos)) = data.panel.panel_position(&panel) {
+                if pos.is_bottom() {
+                    self.show_border = true
+                } else {
+                    self.show_border = false
+                }
+            }
+        }
         if self.show_border {
             self.paint_bar(ctx, &data.config);
         }
diff --git a/lapce-ui/src/status.rs b/lapce-ui/src/status.rs
index 77d0ba5947..ffe79aa3ae 100644
--- a/lapce-ui/src/status.rs
+++ b/lapce-ui/src/status.rs
@@ -1,95 +1,109 @@
 use druid::{
     kurbo::Line,
-    piet::{Text, TextLayout, TextLayoutBuilder},
-    Command, Event, EventCtx, MouseEvent, PaintCtx, Point, RenderContext, Size,
-    Target, Widget,
+    piet::{PietTextLayout, Svg, Text, TextLayout, TextLayoutBuilder},
+    Command, Data, Event, EventCtx, MouseEvent, PaintCtx, Point, Rect,
+    RenderContext, Size, Target, Widget,
 };
 use lapce_core::mode::Mode;
 use lapce_data::{
     command::{CommandKind, LapceCommand, LapceWorkbenchCommand, LAPCE_COMMAND},
-    config::{Config, LapceTheme},
-    data::{FocusArea, LapceTabData, PanelKind},
-    panel::PanelPosition,
+    config::{LapceConfig, LapceIcons, LapceTheme},
+    data::{EditorTabChild, LapceEditorData, LapceTabData},
+    panel::PanelContainerPosition,
 };
 
-use crate::{svg::get_svg, tab::LapceIcon};
+use crate::tab::LapceIcon;
 
 pub struct LapceStatus {
     panel_icons: Vec<LapceIcon>,
+    clickable_items: Vec<(Rect, Command)>,
     mouse_pos: Point,
     icon_size: f64,
+    active_icon: Option<Rect>,
 }
 
 impl LapceStatus {
     pub fn new() -> Self {
         Self {
             panel_icons: Vec::new(),
+            clickable_items: Vec::new(),
             mouse_pos: Point::ZERO,
             icon_size: 13.0,
+            active_icon: None,
         }
     }
 
     fn panel_icons(&self, self_size: Size, data: &LapceTabData) -> Vec<LapceIcon> {
-        let left_panels = data
-            .panels
-            .get(&PanelPosition::BottomLeft)
-            .map(|p| p.widgets.clone())
-            .unwrap_or_default();
-        let mut right_panels = data
-            .panels
-            .get(&PanelPosition::BottomRight)
-            .map(|p| p.widgets.clone())
-            .unwrap_or_default();
-        let mut panels = left_panels;
-        panels.append(&mut right_panels);
-
-        let panel_icons_size = self_size.height * panels.len() as f64;
+        let icons = [
+            (
+                if data.panel.is_container_shown(&PanelContainerPosition::Left) {
+                    LapceIcons::SIDEBAR_LEFT
+                } else {
+                    LapceIcons::SIDEBAR_LEFT_OFF
+                },
+                LapceWorkbenchCommand::TogglePanelLeftVisual,
+            ),
+            (
+                if data
+                    .panel
+                    .is_container_shown(&PanelContainerPosition::Bottom)
+                {
+                    LapceIcons::LAYOUT_PANEL
+                } else {
+                    LapceIcons::LAYOUT_PANEL_OFF
+                },
+                LapceWorkbenchCommand::TogglePanelBottomVisual,
+            ),
+            (
+                if data
+                    .panel
+                    .is_container_shown(&PanelContainerPosition::Right)
+                {
+                    LapceIcons::SIDEBAR_RIGHT
+                } else {
+                    LapceIcons::SIDEBAR_RIGHT_OFF
+                },
+                LapceWorkbenchCommand::TogglePanelRightVisual,
+            ),
+        ];
+
+        let panel_icons_size = self_size.height * icons.len() as f64;
         let offset = (self_size.width - panel_icons_size) / 2.0;
 
-        let icons: Vec<LapceIcon> = panels
-            .iter()
+        let icons: Vec<LapceIcon> = icons
+            .into_iter()
             .enumerate()
-            .map(|(i, p)| {
-                let cmd = match p {
-                    PanelKind::FileExplorer => {
-                        LapceWorkbenchCommand::ToggleFileExplorerVisual
-                    }
-                    PanelKind::SourceControl => {
-                        LapceWorkbenchCommand::ToggleSourceControlVisual
-                    }
-                    PanelKind::Plugin => LapceWorkbenchCommand::TogglePluginVisual,
-                    PanelKind::Terminal => {
-                        LapceWorkbenchCommand::ToggleTerminalVisual
-                    }
-                    PanelKind::Search => LapceWorkbenchCommand::ToggleSearchVisual,
-                    PanelKind::Problem => LapceWorkbenchCommand::ToggleProblemVisual,
-                };
-
-                LapceIcon {
-                    icon: p.svg_name(),
-                    rect: Size::new(self_size.height, self_size.height)
-                        .to_rect()
-                        .with_origin(Point::new(
-                            offset + self_size.height * i as f64,
-                            0.0,
-                        )),
-                    command: Command::new(
-                        LAPCE_COMMAND,
-                        LapceCommand {
-                            kind: CommandKind::Workbench(cmd),
-                            data: None,
-                        },
-                        Target::Widget(data.id),
-                    ),
-                }
+            .map(|(i, (svg, cmd))| LapceIcon {
+                icon: svg,
+                rect: Size::new(self_size.height, self_size.height)
+                    .to_rect()
+                    .with_origin(Point::new(
+                        offset + self_size.height * i as f64,
+                        0.0,
+                    )),
+                command: Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Workbench(cmd),
+                        data: None,
+                    },
+                    Target::Widget(data.id),
+                ),
             })
             .collect();
         icons
     }
 
-    fn icon_hit_test(&self, mouse_event: &MouseEvent) -> bool {
+    fn icon_hit_test(&mut self, mouse_event: &MouseEvent) -> bool {
         for icon in self.panel_icons.iter() {
             if icon.rect.contains(mouse_event.pos) {
+                self.active_icon = Some(icon.rect);
+                return true;
+            }
+        }
+        for (rect, _) in self.clickable_items.iter() {
+            if rect.contains(mouse_event.pos) {
+                self.active_icon = Some(*rect);
                 return true;
             }
         }
@@ -100,6 +114,13 @@ impl LapceStatus {
         for icon in self.panel_icons.iter() {
             if icon.rect.contains(mouse_event.pos) {
                 ctx.submit_command(icon.command.clone());
+                return;
+            }
+        }
+        for (rect, cmd) in self.clickable_items.iter() {
+            if rect.contains(mouse_event.pos) {
+                ctx.submit_command(cmd.clone());
+                return;
             }
         }
     }
@@ -111,9 +132,9 @@ impl LapceStatus {
         icon: &'static str,
         label: String,
         ctx: &mut PaintCtx,
-        config: &Config,
-    ) -> f64 {
-        let fg_color = config.get_color_unchecked(LapceTheme::EDITOR_FOREGROUND);
+        config: &LapceConfig,
+    ) -> (f64, Option<(Rect, Svg)>, (Point, PietTextLayout)) {
+        let fg_color = config.get_color_unchecked(LapceTheme::STATUS_FOREGROUND);
 
         let text_layout = ctx
             .text()
@@ -127,21 +148,178 @@ impl LapceStatus {
 
         let mut left = left;
 
-        if let Some(warnings_icon) = get_svg(icon) {
+        let svg = {
+            let warnings_icon = config.ui_svg(icon);
             let rect = Size::new(height, height)
                 .to_rect()
                 .inflate(-icon_padding, -icon_padding)
                 .with_origin(Point::new(left + 2.0 * icon_padding, icon_padding));
-            ctx.draw_svg(&warnings_icon, rect, Some(fg_color));
 
             left += icon_padding + height;
-        }
+            Some((rect, warnings_icon))
+        };
+
+        let point = Point::new(left, text_layout.y_offset(height));
+        (left + text_layout.size().width, svg, (point, text_layout))
+    }
+
+    fn paint_icon_with_label_from_right(
+        &self,
+        right: f64,
+        height: f64,
+        icon: Option<&'static str>,
+        label: String,
+        ctx: &mut PaintCtx,
+        config: &LapceConfig,
+    ) -> (Point, PietTextLayout, Option<(Rect, Svg)>) {
+        let fg_color = config.get_color_unchecked(LapceTheme::STATUS_FOREGROUND);
+
+        let text_layout = ctx
+            .text()
+            .new_text_layout(label)
+            .font(config.ui.font_family(), config.ui.font_size() as f64)
+            .text_color(fg_color.clone())
+            .build()
+            .unwrap();
 
-        ctx.draw_text(
-            &text_layout,
-            Point::new(left, (height - text_layout.size().height) / 2.0),
+        let icon_padding = (height - self.icon_size) / 2.0;
+
+        let mut right = right;
+
+        let svg = if let Some(icon) = icon {
+            let warnings_icon = config.ui_svg(icon);
+            let rect = Size::new(height, height)
+                .to_rect()
+                .inflate(-icon_padding, -icon_padding)
+                .with_origin(Point::new(right - 2.0 * icon_padding, icon_padding));
+
+            right -= icon_padding + height;
+            Some((rect, warnings_icon))
+        } else {
+            None
+        };
+
+        let point = Point::new(
+            right - text_layout.size().width,
+            text_layout.y_offset(height),
         );
-        left + text_layout.size().width
+        (point, text_layout, svg)
+    }
+
+    fn draw_document_details(
+        &mut self,
+        ctx: &mut PaintCtx,
+        data: &LapceTabData,
+        editor: &LapceEditorData,
+    ) {
+        let size = ctx.size();
+
+        // Language name / change button
+
+        let lang = match data.main_split.content_doc(&editor.content).syntax() {
+            Some(v) => v.language.to_string(),
+            None => String::from("Plain Text"), // TODO: remove after implementing plaintext in lapce-core/src/language.rs
+        };
+        let (point, text_layout, _) = self.paint_icon_with_label_from_right(
+            size.width - 15.0, // We're drawing status items starting from right with slight margin so it's not ending right on window border
+            size.height,
+            None,
+            lang,
+            ctx,
+            &data.config,
+        );
+        let rect = Rect::ZERO
+            .with_origin(Point::new(point.x - 2.0, 0.0)) // expand hover effect slightly so it doesn't look weird
+            .with_size(Size::new(
+                text_layout.layout.width() as f64 + 4.0,
+                size.height,
+            )); // since we start rectangle 2.0 earlier, we need to add to size to compensate, double that for same reason as above
+        if rect.contains(self.mouse_pos) {
+            ctx.fill(
+                rect,
+                data.config
+                    .get_color_unchecked(LapceTheme::PANEL_CURRENT_BACKGROUND),
+            );
+        }
+        ctx.draw_text(&text_layout, point);
+        self.clickable_items.push((
+            rect,
+            Command::new(
+                LAPCE_COMMAND,
+                LapceCommand {
+                    kind: CommandKind::Workbench(
+                        LapceWorkbenchCommand::ChangeFileLanguage,
+                    ),
+                    data: None,
+                },
+                Target::Widget(data.id),
+            ),
+        ));
+
+        // Document text/cursor details (line, column, character) / Go to line
+
+        let mut string = "".to_string();
+        let editor_content = data.editor_view_content(editor.view_id);
+        if let Some(cursor_pos) =
+            editor.cursor.get_line_col_char(editor_content.doc.buffer())
+        {
+            string += &format!(
+                "Ln {}, Col {}, Char {}",
+                cursor_pos.0 + 1,
+                cursor_pos.1 + 1,
+                cursor_pos.2
+            );
+        }
+
+        if let Some(selection) = editor.cursor.get_selection() {
+            let selection_range = selection.0.abs_diff(selection.1);
+
+            if selection.0 != selection.1 {
+                string += &format!(" ({selection_range} selected)");
+            }
+        }
+        let selection_count = editor.cursor.get_selection_count();
+        if selection_count > 1 {
+            string += &format!(" {selection_count} selections");
+        }
+
+        if !string.is_empty() {
+            let (point, text_layout, _) = self.paint_icon_with_label_from_right(
+                rect.x0 - 10.0, // give some space between document details and language name
+                size.height,
+                None,
+                string,
+                ctx,
+                &data.config,
+            );
+            let rect = Rect::ZERO
+                .with_origin(Point::new(point.x - 2.0, 0.0))
+                .with_size(Size::new(
+                    text_layout.layout.width() as f64 + 4.0,
+                    size.height,
+                ));
+            if rect.contains(self.mouse_pos) {
+                ctx.fill(
+                    rect,
+                    data.config
+                        .get_color_unchecked(LapceTheme::PANEL_CURRENT_BACKGROUND),
+                );
+            }
+            ctx.draw_text(&text_layout, point);
+            self.clickable_items.push((
+                rect,
+                Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Workbench(
+                            LapceWorkbenchCommand::PaletteLine,
+                        ),
+                        data: None,
+                    },
+                    Target::Widget(data.id),
+                ),
+            ));
+        }
     }
 }
 
@@ -162,11 +340,14 @@ impl Widget<LapceTabData> for LapceStatus {
         match event {
             Event::MouseMove(mouse_event) => {
                 self.mouse_pos = mouse_event.pos;
+                let active_icon = self.active_icon;
                 if self.icon_hit_test(mouse_event) {
                     ctx.set_cursor(&druid::Cursor::Pointer);
-                    ctx.request_paint();
                 } else {
+                    self.active_icon = None;
                     ctx.clear_cursor();
+                }
+                if active_icon != self.active_icon {
                     ctx.request_paint();
                 }
             }
@@ -198,7 +379,9 @@ impl Widget<LapceTabData> for LapceStatus {
             data.main_split.active_editor(),
         ) {
             (Some(old_data), Some(data)) => {
-                if old_data.cursor.get_mode() != data.cursor.get_mode() {
+                if old_data.cursor.get_mode() != data.cursor.get_mode()
+                    || old_data.editor_id != data.editor_id
+                {
                     ctx.request_paint();
                 }
             }
@@ -213,7 +396,7 @@ impl Widget<LapceTabData> for LapceStatus {
             return;
         }
 
-        if !old_data.progresses.ptr_eq(&data.progresses) {
+        if !old_data.progresses.same(&data.progresses) {
             ctx.request_paint();
         }
     }
@@ -232,6 +415,7 @@ impl Widget<LapceTabData> for LapceStatus {
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &druid::Env) {
+        self.clickable_items.clear();
         let size = ctx.size();
         let rect = size.to_rect();
         let shadow_width = data.config.ui.drop_shadow_width() as f64;
@@ -259,22 +443,30 @@ impl Widget<LapceTabData> for LapceStatus {
         );
 
         let mut left = 0.0;
+        let mut _right = 0.0;
 
-        if data.config.lapce.modal {
-            let mode = if data.focus_area == FocusArea::Panel(PanelKind::Terminal) {
-                data.terminal
-                    .terminals
-                    .get(&data.terminal.active_term_id)
-                    .map(|terminal| terminal.mode)
-            } else {
-                data.main_split.active_editor().map(|e| e.cursor.get_mode())
-            };
-
-            let (mode, color) = match mode.unwrap_or(Mode::Normal) {
-                Mode::Normal => ("Normal", LapceTheme::STATUS_MODAL_NORMAL),
-                Mode::Insert => ("Insert", LapceTheme::STATUS_MODAL_INSERT),
-                Mode::Visual => ("Visual", LapceTheme::STATUS_MODAL_VISUAL),
-                Mode::Terminal => ("Terminal", LapceTheme::STATUS_MODAL_TERMINAL),
+        if data.config.core.modal {
+            let (mode, color_bg, color_fg) = match data.mode() {
+                Mode::Normal => (
+                    "Normal",
+                    LapceTheme::STATUS_MODAL_NORMAL_BACKGROUND,
+                    LapceTheme::STATUS_MODAL_NORMAL_FOREGROUND,
+                ),
+                Mode::Insert => (
+                    "Insert",
+                    LapceTheme::STATUS_MODAL_INSERT_BACKGROUND,
+                    LapceTheme::STATUS_MODAL_INSERT_FOREGROUND,
+                ),
+                Mode::Visual => (
+                    "Visual",
+                    LapceTheme::STATUS_MODAL_VISUAL_BACKGROUND,
+                    LapceTheme::STATUS_MODAL_VISUAL_FOREGROUND,
+                ),
+                Mode::Terminal => (
+                    "Terminal",
+                    LapceTheme::STATUS_MODAL_TERMINAL_BACKGROUND,
+                    LapceTheme::STATUS_MODAL_TERMINAL_FOREGROUND,
+                ),
             };
 
             let text_layout = ctx
@@ -284,45 +476,97 @@ impl Widget<LapceTabData> for LapceStatus {
                     data.config.ui.font_family(),
                     data.config.ui.font_size() as f64,
                 )
-                .text_color(
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
-                        .clone(),
-                )
+                .text_color(data.config.get_color_unchecked(color_fg).clone())
                 .build()
                 .unwrap();
             let text_size = text_layout.size();
             let fill_size = Size::new(text_size.width + 10.0, size.height);
-            ctx.fill(fill_size.to_rect(), data.config.get_color_unchecked(color));
+            ctx.fill(
+                fill_size.to_rect(),
+                data.config.get_color_unchecked(color_bg),
+            );
             ctx.draw_text(
                 &text_layout,
-                Point::new(5.0, (size.height - text_layout.size().height) / 2.0),
+                Point::new(5.0, text_layout.y_offset(size.height)),
             );
             left += text_size.width + 10.0;
         }
 
-        left = self.paint_icon_with_label(
-            left,
-            size.height,
-            "error.svg",
-            data.main_split.error_count.to_string(),
-            ctx,
-            &data.config,
-        );
-        left = self.paint_icon_with_label(
-            left - 5.0,
-            size.height,
-            "warning.svg",
-            data.main_split.warning_count.to_string(),
-            ctx,
-            &data.config,
-        );
+        let x = left + 5.0;
+        let (new_left, error_svg, (error_point, error_text_layout)) = self
+            .paint_icon_with_label(
+                left,
+                size.height,
+                LapceIcons::ERROR,
+                data.main_split.error_count.to_string(),
+                ctx,
+                &data.config,
+            );
+        left = new_left;
+        let (new_left, warning_svg, (warning_point, warning_text_layout)) = self
+            .paint_icon_with_label(
+                left - 5.0,
+                size.height,
+                LapceIcons::WARNING,
+                data.main_split.warning_count.to_string(),
+                ctx,
+                &data.config,
+            );
+        left = new_left;
+
+        let problem_rect = Rect::ZERO
+            .with_origin(Point::new(x, 0.0))
+            .with_size(Size::new(left + 5.0 - x, size.height));
+        if problem_rect.contains(self.mouse_pos) {
+            ctx.fill(
+                problem_rect,
+                data.config
+                    .get_color_unchecked(LapceTheme::PANEL_CURRENT_BACKGROUND),
+            );
+        }
+        if let Some((rect, svg)) = error_svg {
+            ctx.draw_svg(
+                &svg,
+                rect,
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::STATUS_FOREGROUND),
+                ),
+            );
+        }
+        ctx.draw_text(&error_text_layout, error_point);
+        if let Some((rect, svg)) = warning_svg {
+            ctx.draw_svg(
+                &svg,
+                rect,
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::STATUS_FOREGROUND),
+                ),
+            );
+        }
+        ctx.draw_text(&warning_text_layout, warning_point);
+        self.clickable_items.push((
+            problem_rect,
+            Command::new(
+                LAPCE_COMMAND,
+                LapceCommand {
+                    kind: CommandKind::Workbench(
+                        LapceWorkbenchCommand::ToggleProblemVisual,
+                    ),
+                    data: None,
+                },
+                Target::Widget(data.id),
+            ),
+        ));
 
         for progress in data.progresses.iter() {
             let mut text = progress.title.clone();
             if let Some(message) = progress.message.as_ref() {
-                text += ": ";
-                text += message;
+                if text.len() + message.len() < 48 {
+                    text += ": ";
+                    text += message;
+                }
             }
             let text_layout = ctx
                 .text()
@@ -340,10 +584,7 @@ impl Widget<LapceTabData> for LapceStatus {
                 .unwrap();
             ctx.draw_text(
                 &text_layout,
-                Point::new(
-                    left + 10.0,
-                    (size.height - text_layout.size().height) / 2.0,
-                ),
+                Point::new(left + 10.0, text_layout.y_offset(size.height)),
             );
             left += 10.0 + text_layout.size().width;
         }
@@ -352,21 +593,41 @@ impl Widget<LapceTabData> for LapceStatus {
         for icon in self.panel_icons.iter() {
             if icon.rect.contains(self.mouse_pos) {
                 ctx.fill(
-                    &icon.rect,
+                    icon.rect,
                     data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
+                        .get_color_unchecked(LapceTheme::PANEL_CURRENT_BACKGROUND),
                 );
             }
-            if let Some(svg) = get_svg(icon.icon) {
+            {
+                let svg = data.config.ui_svg(icon.icon);
                 ctx.draw_svg(
                     &svg,
                     icon.rect.inflate(-icon_padding, -icon_padding),
                     Some(
                         data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                            .get_color_unchecked(LapceTheme::STATUS_FOREGROUND),
                     ),
                 );
             }
         }
+
+        if let Some(editor) = &data.main_split.active_editor() {
+            // Do not draw file language and cursor/text details for non-file tabs
+            if let Some(editor_tab_id) = editor.tab_id {
+                if let Some(editor_tab) =
+                    data.main_split.editor_tabs.get(&editor_tab_id)
+                {
+                    if let Some(child) = editor_tab.active_child() {
+                        match child {
+                            EditorTabChild::Settings { .. }
+                            | EditorTabChild::Plugin { .. } => {}
+                            EditorTabChild::Editor(_, _, _) => {
+                                self.draw_document_details(ctx, data, editor)
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
 }
diff --git a/lapce-ui/src/svg.rs b/lapce-ui/src/svg.rs
index 79f91f8bb3..939e58e11d 100644
--- a/lapce-ui/src/svg.rs
+++ b/lapce-ui/src/svg.rs
@@ -1,159 +1,72 @@
-use std::{collections::HashMap, ffi::OsStr, path::Path, str::FromStr};
-
-use druid::{piet::Svg, Color};
-use include_dir::{include_dir, Dir};
-use lazy_static::lazy_static;
-use lsp_types::{CompletionItemKind, SymbolKind};
-
-use lapce_data::config::{Config, LOGO};
-
-const ICONS_DIR: Dir = include_dir!("../icons");
-
-lazy_static! {
-    static ref SVG_STORE: SvgStore = SvgStore::new();
+use druid::{
+    BoxConstraints, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx,
+    PaintCtx, Rect, Size, UpdateCtx, Widget,
+};
+use lapce_data::{config::LapceTheme, data::LapceTabData};
+
+pub struct LapceIconSvg {
+    icon: &'static str,
+    rect: Rect,
 }
 
-struct SvgStore {
-    svgs: HashMap<&'static str, Option<Svg>>,
-}
-
-impl SvgStore {
-    fn new() -> Self {
-        let mut svgs = HashMap::new();
-        svgs.insert("lapce_logo", Svg::from_str(LOGO).ok());
-
-        for file in ICONS_DIR.files() {
-            if let Some(file_name) = file.path().file_name().and_then(OsStr::to_str)
-            {
-                let svg =
-                    file.contents_utf8().and_then(|str| Svg::from_str(str).ok());
-
-                svgs.insert(file_name, svg);
-            }
+impl LapceIconSvg {
+    pub fn new(icon: &'static str) -> Self {
+        Self {
+            icon,
+            rect: Rect::ZERO,
         }
-
-        Self { svgs }
-    }
-
-    fn get_svg(&self, name: &'static str) -> Option<Svg> {
-        self.svgs.get(name).and_then(Clone::clone)
     }
 }
 
-pub fn logo_svg() -> Svg {
-    get_svg("lapce_logo").unwrap()
-}
-
-pub fn get_svg(name: &'static str) -> Option<Svg> {
-    SVG_STORE.get_svg(name)
-}
-
-pub fn file_svg(path: &Path) -> Svg {
-    let file_type = if path.file_name().and_then(OsStr::to_str) == Some("LICENSE") {
-        "file_type_license.svg"
-    } else {
-        path.extension()
-            .and_then(OsStr::to_str)
-            .and_then(|extension| {
-                const TYPES: &[(&[&str], &str)] = &[
-                    (&["c"], "file_type_c.svg"),
-                    (&["cxx", "cc", "c++", "cpp"], "file_type_cpp.svg"),
-                    (&["go"], "file_type_go.svg"),
-                    (&["json"], "file_type_json.svg"),
-                    (&["markdown", "md"], "file_type_markdown.svg"),
-                    (&["rs"], "file_type_rust.svg"),
-                    (&["toml"], "file_type_toml.svg"),
-                    (&["yaml"], "file_type_yaml.svg"),
-                ];
-
-                for (exts, file_type) in TYPES {
-                    for ext in exts.iter() {
-                        if extension.eq_ignore_ascii_case(ext) {
-                            return Some(*file_type);
-                        }
-                    }
-                }
-
-                None
-            })
-            .unwrap_or("default_file.svg")
-    };
-
-    get_svg(file_type).unwrap()
-}
+impl Widget<LapceTabData> for LapceIconSvg {
+    fn event(
+        &mut self,
+        _ctx: &mut EventCtx,
+        _event: &Event,
+        _data: &mut LapceTabData,
+        _env: &Env,
+    ) {
+    }
 
-pub fn symbol_svg(kind: &SymbolKind) -> Option<Svg> {
-    let kind_str = match kind {
-        SymbolKind::Array => "symbol-array.svg",
-        SymbolKind::Boolean => "symbol-boolean.svg",
-        SymbolKind::Class => "symbol-class.svg",
-        SymbolKind::Constant => "symbol-constant.svg",
-        SymbolKind::EnumMember => "symbol-enum-member.svg",
-        SymbolKind::Enum => "symbol-enum.svg",
-        SymbolKind::Event => "symbol-event.svg",
-        SymbolKind::Field => "symbol-field.svg",
-        SymbolKind::File => "symbol-file.svg",
-        SymbolKind::Interface => "symbol-interface.svg",
-        SymbolKind::Key => "symbol-key.svg",
-        SymbolKind::Function => "symbol-method.svg",
-        SymbolKind::Method => "symbol-method.svg",
-        SymbolKind::Object => "symbol-namespace.svg",
-        SymbolKind::Namespace => "symbol-namespace.svg",
-        SymbolKind::Number => "symbol-numeric.svg",
-        SymbolKind::Operator => "symbol-operator.svg",
-        SymbolKind::TypeParameter => "symbol-parameter.svg",
-        SymbolKind::Property => "symbol-property.svg",
-        SymbolKind::String => "symbol-string.svg",
-        SymbolKind::Struct => "symbol-structure.svg",
-        SymbolKind::Variable => "symbol-variable.svg",
-        _ => return None,
-    };
+    fn lifecycle(
+        &mut self,
+        _ctx: &mut LifeCycleCtx,
+        _event: &LifeCycle,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
 
-    get_svg(kind_str)
-}
+    fn update(
+        &mut self,
+        _ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) {
+    }
 
-pub fn completion_svg(
-    kind: Option<CompletionItemKind>,
-    config: &Config,
-) -> Option<(Svg, Option<Color>)> {
-    let kind = kind?;
-    let kind_str = match kind {
-        CompletionItemKind::Method => "symbol-method.svg",
-        CompletionItemKind::Function => "symbol-method.svg",
-        CompletionItemKind::Enum => "symbol-enum.svg",
-        CompletionItemKind::EnumMember => "symbol-enum-member.svg",
-        CompletionItemKind::Class => "symbol-class.svg",
-        CompletionItemKind::Variable => "symbol-variable.svg",
-        CompletionItemKind::Struct => "symbol-structure.svg",
-        CompletionItemKind::Keyword => "symbol-keyword.svg",
-        CompletionItemKind::Constant => "symbol-constant.svg",
-        CompletionItemKind::Property => "symbol-property.svg",
-        CompletionItemKind::Field => "symbol-field.svg",
-        CompletionItemKind::Interface => "symbol-interface.svg",
-        CompletionItemKind::Snippet => "symbol-snippet.svg",
-        CompletionItemKind::Module => "symbol-namespace.svg",
-        _ => "symbol-string.svg",
-    };
-    let theme_str = match kind {
-        CompletionItemKind::Method => "method",
-        CompletionItemKind::Function => "method",
-        CompletionItemKind::Enum => "enum",
-        CompletionItemKind::EnumMember => "enum-member",
-        CompletionItemKind::Class => "class",
-        CompletionItemKind::Variable => "field",
-        CompletionItemKind::Struct => "structure",
-        CompletionItemKind::Keyword => "keyword",
-        CompletionItemKind::Constant => "constant",
-        CompletionItemKind::Property => "property",
-        CompletionItemKind::Field => "field",
-        CompletionItemKind::Interface => "interface",
-        CompletionItemKind::Snippet => "snippet",
-        CompletionItemKind::Module => "builtinType",
-        _ => "string",
-    };
+    fn layout(
+        &mut self,
+        _ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        _data: &LapceTabData,
+        _env: &Env,
+    ) -> Size {
+        let size = bc.max();
+        self.rect = size.to_rect();
+        size
+    }
 
-    Some((
-        get_svg(kind_str)?,
-        config.get_style_color(theme_str).cloned(),
-    ))
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
+        let svg = data.config.ui_svg(self.icon);
+        ctx.draw_svg(
+            &svg,
+            self.rect,
+            Some(
+                data.config
+                    .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
+            ),
+        );
+    }
 }
diff --git a/lapce-ui/src/tab.rs b/lapce-ui/src/tab.rs
index ef6e9c1071..fc55fd6466 100644
--- a/lapce-ui/src/tab.rs
+++ b/lapce-ui/src/tab.rs
@@ -1,51 +1,69 @@
-use std::{collections::HashMap, path::PathBuf, sync::Arc};
+use std::{process, sync::Arc};
 
 use druid::{
     kurbo::Line,
     piet::{PietTextLayout, Text, TextLayout, TextLayoutBuilder},
     BoxConstraints, Command, Data, Env, Event, EventCtx, InternalLifeCycle,
-    LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, Point, Rect, RenderContext, Size,
-    Target, Widget, WidgetExt, WidgetId, WidgetPod,
+    LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, Point, Rect, RenderContext,
+    Selector, SingleUse, Size, Target, UpdateCtx, Widget, WidgetExt, WidgetId,
+    WidgetPod,
 };
 use itertools::Itertools;
 use lapce_core::{
     command::FocusCommand,
     cursor::{Cursor, CursorMode},
+    language::LapceLanguage,
     selection::Selection,
 };
 use lapce_data::{
     command::{
-        CommandKind, LapceCommand, LapceUICommand, LAPCE_COMMAND, LAPCE_OPEN_FILE,
-        LAPCE_OPEN_FOLDER, LAPCE_SAVE_FILE_AS, LAPCE_UI_COMMAND,
+        CommandKind, LapceCommand, LapceUICommand, LapceWorkbenchCommand,
+        LAPCE_COMMAND, LAPCE_OPEN_FILE, LAPCE_OPEN_FOLDER, LAPCE_SAVE_FILE_AS,
+        LAPCE_UI_COMMAND,
     },
     completion::CompletionStatus,
-    config::{Config, LapceTheme},
+    config::{LapceConfig, LapceIcons, LapceTheme},
     data::{
-        DragContent, EditorDiagnostic, FocusArea, LapceData, LapceTabData,
-        LapceWorkspace, LapceWorkspaceType, PanelKind, WorkProgress,
+        DragContent, EditorDiagnostic, EditorTabChild, FocusArea, LapceData,
+        LapceTabData, LapceWindowData, LapceWorkspace, LapceWorkspaceType,
+        WorkProgress,
     },
     document::{BufferContent, LocalBufferKind},
     editor::EditorLocation,
     hover::HoverStatus,
-    keypress::{DefaultKeyPressHandler, KeyPressData},
+    keypress::{DefaultKeyPressHandler, KeyMap, KeyPressData},
     menu::MenuKind,
     palette::PaletteStatus,
-    panel::{PanelPosition, PanelResizePosition},
+    panel::{
+        PanelContainerPosition, PanelKind, PanelPosition, PanelResizePosition,
+        PanelStyle,
+    },
+    plugin::plugin_install_status::{PluginInstallStatus, PluginInstallType},
     proxy::path_from_url,
+    signature::SignatureStatus,
 };
+use lapce_rpc::proxy::ProxyResponse;
+use lapce_xi_rope::Rope;
 use lsp_types::DiagnosticSeverity;
-use serde::Deserialize;
-use xi_rope::Rope;
 
 use crate::{
-    activity::ActivityBar, alert::AlertBox, completion::CompletionContainer,
-    explorer::FileExplorer, hover::HoverContainer, palette::Palette,
-    picker::FilePicker, plugin::Plugin, problem::new_problem_panel,
-    search::new_search_panel, settings::LapceSettingsPanel,
+    about::AboutBox, alert::AlertBox, completion::CompletionContainer,
+    editor::view::LapceEditorView, explorer::FileExplorer, hover::HoverContainer,
+    message::LapceMessage, panel::PanelContainer, picker::FilePicker,
+    plugin::Plugin, problem::new_problem_panel, scroll::LapceScroll,
+    search::new_search_panel, signature::SignatureContainer,
     source_control::new_source_control_panel, split::split_data_widget,
-    status::LapceStatus, svg::get_svg, terminal::TerminalPanel,
+    status::LapceStatus, terminal::TerminalPanel, title::Title,
 };
 
+pub const LAPCE_TAB_META: Selector<SingleUse<LapceTabMeta>> =
+    Selector::new("lapce.tab_meta");
+
+pub struct LapceTabMeta {
+    pub data: LapceTabData,
+    pub widget: WidgetPod<LapceWindowData, Box<dyn Widget<LapceWindowData>>>,
+}
+
 pub struct LapceIcon {
     pub rect: Rect,
     pub command: Command,
@@ -60,26 +78,42 @@ pub struct LapceButton {
 
 pub struct LapceTab {
     id: WidgetId,
-    activity: WidgetPod<LapceTabData, ActivityBar>,
+    pub title: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
     main_split: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
-    completion: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    completion: WidgetPod<LapceTabData, CompletionContainer>,
+    signature: WidgetPod<LapceTabData, SignatureContainer>,
     hover: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
-    palette: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    rename: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
     status: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
     picker: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
-    settings: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    about: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
     alert: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
-    panels:
-        HashMap<PanelKind, WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>>,
+    message: WidgetPod<LapceTabData, LapceScroll<LapceTabData, LapceMessage>>,
+    panel_left: WidgetPod<LapceTabData, PanelContainer>,
+    panel_bottom: WidgetPod<LapceTabData, PanelContainer>,
+    panel_right: WidgetPod<LapceTabData, PanelContainer>,
     current_bar_hover: Option<PanelResizePosition>,
+    width: f64,
     height: f64,
-    main_split_height: f64,
+    title_height: f64,
     status_height: f64,
     mouse_pos: Point,
 }
 
+fn workspace_title(workspace: &LapceWorkspace) -> Option<String> {
+    let p = workspace.path.as_ref()?;
+    let dir = p.file_name().unwrap_or(p.as_os_str()).to_string_lossy();
+    Some(match &workspace.kind {
+        LapceWorkspaceType::Local => format!("{dir}"),
+        LapceWorkspaceType::RemoteSSH(ssh) => format!("{dir} [{ssh}]"),
+        #[cfg(windows)]
+        LapceWorkspaceType::RemoteWSL => format!("{dir} [wsl]"),
+    })
+}
+
 impl LapceTab {
-    pub fn new(data: &LapceTabData) -> Self {
+    pub fn new(data: &mut LapceTabData) -> Self {
+        let title = WidgetPod::new(Title::new(data).boxed());
         let split_data = data
             .main_split
             .splits
@@ -87,129 +121,421 @@ impl LapceTab {
             .unwrap();
         let main_split = split_data_widget(split_data, data);
 
-        let activity = ActivityBar::new();
         let completion = CompletionContainer::new(&data.completion);
+        let signature = SignatureContainer::new(&data.signature);
         let hover = HoverContainer::new(&data.hover);
-        let palette = Palette::new(data);
+        let rename =
+            LapceEditorView::new(data.rename.view_id, data.rename.editor_id, None)
+                .hide_header()
+                .hide_gutter()
+                .padding((10.0, 5.0, 10.0, 5.0));
         let status = LapceStatus::new();
-
-        let mut panels = HashMap::new();
-        let file_explorer = FileExplorer::new_panel(data);
-        panels.insert(
-            PanelKind::FileExplorer,
-            WidgetPod::new(file_explorer.boxed()),
-        );
-
-        let source_control = new_source_control_panel(data);
-        panels.insert(
-            PanelKind::SourceControl,
-            WidgetPod::new(source_control.boxed()),
-        );
-
-        let plugin = Plugin::new_panel(data);
-        panels.insert(PanelKind::Plugin, WidgetPod::new(plugin.boxed()));
-
-        let terminal = TerminalPanel::new_panel(data);
-        panels.insert(PanelKind::Terminal, WidgetPod::new(terminal.boxed()));
-
-        let search = new_search_panel(data);
-        panels.insert(PanelKind::Search, WidgetPod::new(search.boxed()));
-
-        let problem = new_problem_panel(&data.problem);
-        panels.insert(PanelKind::Problem, WidgetPod::new(problem.boxed()));
-
         let picker = FilePicker::new(data);
 
-        let settings =
-            LapceSettingsPanel::new(data, WidgetId::next(), WidgetId::next());
-
+        let about = AboutBox::new(data);
         let alert = AlertBox::new(data);
+        let message = LapceScroll::new(LapceMessage::new(*data.message_widget_id));
+
+        let mut panel_left = PanelContainer::new(PanelContainerPosition::Left);
+        let mut panel_bottom = PanelContainer::new(PanelContainerPosition::Bottom);
+        let mut panel_right = PanelContainer::new(PanelContainerPosition::Right);
+
+        for (position, order) in data.panel.order.clone().iter() {
+            let panel = match position {
+                PanelPosition::LeftTop | PanelPosition::LeftBottom => {
+                    &mut panel_left
+                }
+                PanelPosition::RightTop | PanelPosition::RightBottom => {
+                    &mut panel_right
+                }
+                PanelPosition::BottomLeft | PanelPosition::BottomRight => {
+                    &mut panel_bottom
+                }
+            };
+            for kind in order.iter() {
+                match kind {
+                    PanelKind::FileExplorer => {
+                        panel.insert_panel(
+                            *kind,
+                            WidgetPod::new(FileExplorer::new_panel(data).boxed()),
+                        );
+                    }
+                    PanelKind::SourceControl => {
+                        panel.insert_panel(
+                            *kind,
+                            WidgetPod::new(new_source_control_panel(data).boxed()),
+                        );
+                    }
+                    PanelKind::Plugin => {
+                        panel.insert_panel(
+                            *kind,
+                            WidgetPod::new(Plugin::new_panel(data).boxed()),
+                        );
+                    }
+                    PanelKind::Terminal => {
+                        panel.insert_panel(
+                            *kind,
+                            WidgetPod::new(TerminalPanel::new_panel(data).boxed()),
+                        );
+                    }
+                    PanelKind::Search => {
+                        panel.insert_panel(
+                            *kind,
+                            WidgetPod::new(new_search_panel(data).boxed()),
+                        );
+                    }
+                    PanelKind::Problem => {
+                        panel.insert_panel(
+                            *kind,
+                            WidgetPod::new(new_problem_panel(&data.problem).boxed()),
+                        );
+                    }
+                }
+            }
+        }
 
         Self {
             id: data.id,
-            activity: WidgetPod::new(activity),
+            title,
             main_split: WidgetPod::new(main_split.boxed()),
-            completion: WidgetPod::new(completion.boxed()),
+            completion: WidgetPod::new(completion),
+            signature: WidgetPod::new(signature),
             hover: WidgetPod::new(hover.boxed()),
+            rename: WidgetPod::new(rename.boxed()),
             picker: WidgetPod::new(picker.boxed()),
-            palette: WidgetPod::new(palette.boxed()),
             status: WidgetPod::new(status.boxed()),
-            settings: WidgetPod::new(settings.boxed()),
+            about: WidgetPod::new(about.boxed()),
             alert: WidgetPod::new(alert.boxed()),
-            panels,
+            message: WidgetPod::new(message),
+            panel_left: WidgetPod::new(panel_left),
+            panel_right: WidgetPod::new(panel_right),
+            panel_bottom: WidgetPod::new(panel_bottom),
             current_bar_hover: None,
+            width: 0.0,
             height: 0.0,
-            main_split_height: 0.0,
             status_height: 0.0,
+            title_height: 0.0,
             mouse_pos: Point::ZERO,
         }
     }
 
-    fn update_split_point(&mut self, data: &mut LapceTabData, mouse_pos: Point) {
+    fn update_split_point(
+        &mut self,
+        ctx: &mut EventCtx,
+        data: &mut LapceTabData,
+        mouse_pos: Point,
+    ) {
         if let Some(position) = self.current_bar_hover.as_ref() {
             match position {
                 PanelResizePosition::Left => {
-                    data.panel_size.left = (mouse_pos.x - 50.0).round().max(50.0);
+                    let maximum = self.width - 100.0 - data.panel.size.right;
+                    Arc::make_mut(&mut data.panel).size.left =
+                        mouse_pos.x.round().max(180.0).min(maximum);
+                    if mouse_pos.x < 90.0 {
+                        if data
+                            .panel
+                            .is_container_shown(&PanelContainerPosition::Left)
+                        {
+                            ctx.submit_command(Command::new(
+                                LAPCE_COMMAND,
+                                LapceCommand {
+                                    kind: CommandKind::Workbench(
+                                        LapceWorkbenchCommand::TogglePanelLeftVisual,
+                                    ),
+                                    data: None,
+                                },
+                                Target::Widget(data.id),
+                            ));
+                        }
+                    } else if !data
+                        .panel
+                        .is_container_shown(&PanelContainerPosition::Left)
+                    {
+                        ctx.submit_command(Command::new(
+                            LAPCE_COMMAND,
+                            LapceCommand {
+                                kind: CommandKind::Workbench(
+                                    LapceWorkbenchCommand::TogglePanelLeftVisual,
+                                ),
+                                data: None,
+                            },
+                            Target::Widget(data.id),
+                        ));
+                    }
+                }
+                PanelResizePosition::Right => {
+                    let maximum = self.width - 100.0 - data.panel.size.left;
+                    let right = self.width - mouse_pos.x.round();
+                    Arc::make_mut(&mut data.panel).size.right =
+                        right.max(180.0).min(maximum);
+                    if right < 90.0 {
+                        if data
+                            .panel
+                            .is_container_shown(&PanelContainerPosition::Right)
+                        {
+                            ctx.submit_command(Command::new(
+                                LAPCE_COMMAND,
+                                LapceCommand {
+                                    kind: CommandKind::Workbench(
+                                        LapceWorkbenchCommand::TogglePanelRightVisual,
+                                    ),
+                                    data: None,
+                                },
+                                Target::Widget(data.id),
+                            ));
+                        }
+                    } else if !data
+                        .panel
+                        .is_container_shown(&PanelContainerPosition::Right)
+                    {
+                        ctx.submit_command(Command::new(
+                            LAPCE_COMMAND,
+                            LapceCommand {
+                                kind: CommandKind::Workbench(
+                                    LapceWorkbenchCommand::TogglePanelRightVisual,
+                                ),
+                                data: None,
+                            },
+                            Target::Widget(data.id),
+                        ));
+                    }
                 }
                 PanelResizePosition::LeftSplit => (),
                 PanelResizePosition::Bottom => {
-                    data.panel_size.bottom =
-                        (self.height - mouse_pos.y.round() - self.status_height)
-                            .max(50.0);
+                    let bottom =
+                        self.height - mouse_pos.y.round() - self.status_height;
+
+                    let header_height = data.config.ui.header_height() as f64;
+                    // The maximum position (from the bottom) that the bottom split is allowed to reach
+                    let minimum = self.height
+                        - self.title_height
+                        - self.status_height
+                        - header_height
+                        - 1.0;
+
+                    Arc::make_mut(&mut data.panel).size.bottom =
+                        bottom.max(180.0).min(minimum);
+
+                    // Check if it should snap the bottom panel away, if you are too low
+                    if bottom < 90.0 {
+                        if data
+                            .panel
+                            .is_container_shown(&PanelContainerPosition::Bottom)
+                        {
+                            ctx.submit_command(Command::new(
+                                LAPCE_COMMAND,
+                                LapceCommand {
+                                    kind: CommandKind::Workbench(
+                                        LapceWorkbenchCommand::TogglePanelBottomVisual,
+                                    ),
+                                    data: None,
+                                },
+                                Target::Widget(data.id),
+                            ));
+                        }
+                    } else if !data
+                        .panel
+                        .is_container_shown(&PanelContainerPosition::Bottom)
+                    {
+                        ctx.submit_command(Command::new(
+                            LAPCE_COMMAND,
+                            LapceCommand {
+                                kind: CommandKind::Workbench(
+                                    LapceWorkbenchCommand::TogglePanelBottomVisual,
+                                ),
+                                data: None,
+                            },
+                            Target::Widget(data.id),
+                        ));
+                    }
                 }
             }
         }
     }
 
-    fn bar_hit_test(
-        &self,
-        data: &LapceTabData,
-        mouse_pos: Point,
-    ) -> Option<PanelResizePosition> {
-        let panel_left_top_shown = data
-            .panels
-            .get(&PanelPosition::LeftTop)
-            .map(|p| p.is_shown())
-            .unwrap_or(false);
-        let panel_left_bottom_shown = data
-            .panels
-            .get(&PanelPosition::LeftBottom)
-            .map(|p| p.is_shown())
-            .unwrap_or(false);
-        let left = if panel_left_bottom_shown || panel_left_top_shown {
-            let left = data.panel_size.left + 50.0;
-            if mouse_pos.x >= left - 3.0 && mouse_pos.x <= left + 3.0 {
-                return Some(PanelResizePosition::Left);
+    fn bar_hit_test(&self, mouse_pos: Point) -> Option<PanelResizePosition> {
+        let rect = self.main_split.layout_rect();
+        let left = rect.x0;
+        let right = rect.x1;
+        let bottom = rect.y1;
+
+        if mouse_pos.x >= left - 2.0 && mouse_pos.x <= left + 2.0 {
+            return Some(PanelResizePosition::Left);
+        }
+
+        if mouse_pos.x >= right - 2.0 && mouse_pos.x <= right + 2.0 {
+            return Some(PanelResizePosition::Right);
+        }
+
+        if mouse_pos.x > left
+            && mouse_pos.x < right
+            && mouse_pos.y >= bottom - 2.0
+            && mouse_pos.y <= bottom + 2.0
+        {
+            return Some(PanelResizePosition::Bottom);
+        }
+
+        None
+    }
+
+    fn panel_rects(&self) -> Vec<(PanelPosition, Rect)> {
+        let mut rects = Vec::new();
+
+        let left_rect = self.panel_left.layout_rect();
+        let left_size = left_rect.size();
+        let new_size = Size::new(left_size.width, (left_size.height / 2.0).round());
+        rects.push((PanelPosition::LeftTop, left_rect.with_size(new_size)));
+        rects.push((
+            PanelPosition::LeftBottom,
+            left_rect.with_size(new_size).with_origin(Point::new(
+                left_rect.x0,
+                left_rect.y0 + new_size.height,
+            )),
+        ));
+
+        let right_rect = self.panel_right.layout_rect();
+        let right_size = right_rect.size();
+        let new_size =
+            Size::new(right_size.width, (right_size.height / 2.0).round());
+        rects.push((PanelPosition::RightTop, right_rect.with_size(new_size)));
+        rects.push((
+            PanelPosition::RightBottom,
+            right_rect.with_size(new_size).with_origin(Point::new(
+                right_rect.x0,
+                right_rect.y0 + new_size.height,
+            )),
+        ));
+
+        let bottom_rect = self.panel_bottom.layout_rect();
+        let bottom_size = bottom_rect.size();
+        let new_size =
+            Size::new((bottom_size.width / 2.0).round(), bottom_size.height);
+        rects.push((PanelPosition::BottomLeft, bottom_rect.with_size(new_size)));
+        rects.push((
+            PanelPosition::BottomRight,
+            bottom_rect.with_size(new_size).with_origin(Point::new(
+                bottom_rect.x0 + new_size.width,
+                bottom_rect.y0,
+            )),
+        ));
+
+        rects
+    }
+
+    fn move_panel(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        kind: PanelKind,
+        from: PanelPosition,
+        to: PanelPosition,
+    ) {
+        let (panel_widget_id, panel) = match from {
+            PanelPosition::LeftTop | PanelPosition::LeftBottom => (
+                self.panel_left.widget().widget_id,
+                self.panel_left.widget_mut().panels.remove(&kind).unwrap(),
+            ),
+            PanelPosition::RightTop | PanelPosition::RightBottom => (
+                self.panel_right.widget().widget_id,
+                self.panel_right.widget_mut().panels.remove(&kind).unwrap(),
+            ),
+            PanelPosition::BottomLeft | PanelPosition::BottomRight => (
+                self.panel_bottom.widget().widget_id,
+                self.panel_bottom.widget_mut().panels.remove(&kind).unwrap(),
+            ),
+        };
+
+        ctx.submit_command(Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::ChildrenChanged,
+            Target::Widget(panel_widget_id),
+        ));
+
+        let new_panel_widget_id = match to {
+            PanelPosition::LeftTop | PanelPosition::LeftBottom => {
+                self.panel_left.widget_mut().panels.insert(kind, panel);
+                self.panel_left.widget().widget_id
+            }
+            PanelPosition::RightTop | PanelPosition::RightBottom => {
+                self.panel_right.widget_mut().panels.insert(kind, panel);
+                self.panel_right.widget().widget_id
+            }
+            PanelPosition::BottomLeft | PanelPosition::BottomRight => {
+                self.panel_bottom.widget_mut().panels.insert(kind, panel);
+                self.panel_bottom.widget().widget_id
             }
-            left
-        } else {
-            0.0
         };
 
-        let panel_bottom_left_shown = data
-            .panels
-            .get(&PanelPosition::BottomLeft)
-            .map(|p| p.is_shown())
-            .unwrap_or(false);
-        let panel_bottom_right_shown = data
-            .panels
-            .get(&PanelPosition::BottomRight)
-            .map(|p| p.is_shown())
-            .unwrap_or(false);
-        if panel_bottom_left_shown || panel_bottom_right_shown {
-            let _bottom = data.panel_size.bottom;
-            let y = self.main_split_height;
-            if mouse_pos.x > left && mouse_pos.y >= y - 3.0 && mouse_pos.y <= y + 3.0
-            {
-                return Some(PanelResizePosition::Bottom);
+        ctx.submit_command(Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::ChildrenChanged,
+            Target::Widget(new_panel_widget_id),
+        ));
+    }
+
+    fn handle_panel_drop(&mut self, _ctx: &mut EventCtx, data: &mut LapceTabData) {
+        if let Some((_, _, DragContent::Panel(kind, _))) = data.drag.as_ref() {
+            let rects = self.panel_rects();
+            for (p, rect) in rects.iter() {
+                if !rect.contains(self.mouse_pos) {
+                    continue;
+                }
+
+                let (_, from_position) = data.panel.panel_position(kind).unwrap();
+                if from_position == *p {
+                    return;
+                }
+
+                let panel = Arc::make_mut(&mut data.panel);
+                if let Some(order) = panel.order.get_mut(&from_position) {
+                    order.retain(|k| k != kind);
+                }
+
+                let order = panel.order.entry(*p).or_insert_with(im::Vector::new);
+
+                order.push_back(*kind);
+
+                let style = panel.style.entry(*p).or_insert(PanelStyle {
+                    active: 0,
+                    shown: true,
+                    maximized: false,
+                });
+
+                style.active = order.len() - 1;
+                style.shown = true;
+                let _ = data.db.save_panel_orders(&panel.order);
+
+                return;
             }
         }
+    }
 
-        None
+    fn paint_drag_on_panel(&self, ctx: &mut PaintCtx, data: &LapceTabData) {
+        if let Some((_, _, DragContent::Panel(_, _))) = data.drag.as_ref() {
+            let rects = self.panel_rects();
+            for (_, rect) in rects.iter() {
+                if !rect.contains(self.mouse_pos) {
+                    continue;
+                }
+
+                ctx.fill(
+                    rect,
+                    data.config.get_color_unchecked(
+                        LapceTheme::EDITOR_DRAG_DROP_TAB_BACKGROUND,
+                    ),
+                );
+                break;
+            }
+        }
     }
 
     fn paint_drag(&self, ctx: &mut PaintCtx, data: &LapceTabData) {
-        if let Some((offset, drag_content)) = data.drag.as_ref() {
+        if let Some((offset, start, drag_content)) = data.drag.as_ref() {
+            if (self.mouse_pos.x - start.x).abs() < 5.
+                && (self.mouse_pos.y - start.y).abs() < 5.
+            {
+                // debounce accidental drags
+                return;
+            }
             match drag_content {
                 DragContent::EditorTab(_, _, _, tab_rect) => {
                     let rect = tab_rect.rect.with_origin(self.mouse_pos - *offset);
@@ -233,10 +559,9 @@ impl LapceTab {
                     }
                     ctx.fill(
                         rect,
-                        &data
-                            .config
-                            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
-                            .clone(),
+                        data.config.get_color_unchecked(
+                            LapceTheme::EDITOR_DRAG_DROP_BACKGROUND,
+                        ),
                     );
 
                     let width = 13.0;
@@ -247,12 +572,51 @@ impl LapceTab {
                             rect.y0 + (size.height - height) / 2.0,
                         ));
                     ctx.draw_svg(&tab_rect.svg, svg_rect, None);
-                    let text_size = tab_rect.text_layout.size();
                     ctx.draw_text(
                         &tab_rect.text_layout,
                         Point::new(
                             rect.x0 + size.height,
-                            rect.y0 + (size.height - text_size.height) / 2.0,
+                            rect.y0 + tab_rect.text_layout.y_offset(size.height),
+                        ),
+                    );
+                }
+                DragContent::Panel(kind, rect) => {
+                    let inflate = (rect.width() / 2.0).round();
+                    let icon_rect = rect
+                        .with_origin(self.mouse_pos - *offset)
+                        .inflate(inflate, inflate);
+                    let padding = (icon_rect.width() * 0.3).round();
+                    let rect = icon_rect.inflate(padding, padding);
+                    let shadow_width = data.config.ui.drop_shadow_width() as f64;
+                    if shadow_width > 0.0 {
+                        ctx.blurred_rect(
+                            rect,
+                            shadow_width,
+                            data.config.get_color_unchecked(
+                                LapceTheme::LAPCE_DROPDOWN_SHADOW,
+                            ),
+                        );
+                    } else {
+                        ctx.stroke(
+                            rect.inflate(0.5, 0.5),
+                            data.config
+                                .get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                            1.0,
+                        );
+                    }
+                    ctx.fill(
+                        rect,
+                        data.config.get_color_unchecked(
+                            LapceTheme::EDITOR_DRAG_DROP_BACKGROUND,
+                        ),
+                    );
+                    let svg = data.config.ui_svg(kind.svg_name());
+                    ctx.draw_svg(
+                        &svg,
+                        icon_rect,
+                        Some(
+                            data.config
+                                .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
                         ),
                     );
                 }
@@ -260,17 +624,21 @@ impl LapceTab {
         }
     }
 
-    fn handle_event(
+    fn handle_mouse_event(
         &mut self,
         ctx: &mut EventCtx,
         event: &Event,
         data: &mut LapceTabData,
-        env: &Env,
+        _env: &Env,
     ) {
         match event {
+            Event::MouseMove(mouse) => {
+                Arc::make_mut(&mut data.rename).mouse_within = data.rename.active
+                    && self.rename.layout_rect().contains(mouse.pos);
+            }
             Event::MouseDown(mouse) => {
-                if mouse.button.is_left() {
-                    if let Some(position) = self.bar_hit_test(data, mouse.pos) {
+                if !ctx.is_handled() && mouse.button.is_left() {
+                    if let Some(position) = self.bar_hit_test(mouse.pos) {
                         self.current_bar_hover = Some(position);
                         ctx.set_active(true);
                         ctx.set_handled();
@@ -281,35 +649,23 @@ impl LapceTab {
                 if mouse.button.is_left() && ctx.is_active() {
                     ctx.set_active(false);
                 }
-            }
-            Event::MouseMove(mouse) => {
-                self.mouse_pos = mouse.pos;
-                if ctx.is_active() {
-                    self.update_split_point(data, mouse.pos);
-                    ctx.request_layout();
-                    ctx.set_handled();
-                } else {
-                    match self.bar_hit_test(data, mouse.pos) {
-                        Some(position) => {
-                            match position {
-                                PanelResizePosition::Left => {
-                                    ctx.set_cursor(&druid::Cursor::ResizeLeftRight);
-                                }
-                                PanelResizePosition::LeftSplit => {
-                                    ctx.set_cursor(&druid::Cursor::ResizeUpDown);
-                                }
-                                PanelResizePosition::Bottom => {
-                                    ctx.set_cursor(&druid::Cursor::ResizeUpDown)
-                                }
-                            }
-                            ctx.set_handled();
-                        }
-                        None => {
-                            ctx.clear_cursor();
-                        }
-                    }
+                if let Some((_, _, DragContent::Panel(_, _))) = data.drag.as_ref() {
+                    self.handle_panel_drop(ctx, data);
+                    *Arc::make_mut(&mut data.drag) = None;
                 }
             }
+            _ => {}
+        }
+    }
+
+    fn handle_command_event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        match event {
             Event::Command(cmd) if cmd.is(LAPCE_COMMAND) => {
                 let command = cmd.get_unchecked(LAPCE_COMMAND);
                 data.run_command(ctx, command, None, env);
@@ -321,12 +677,12 @@ impl LapceTab {
                 if let Some(info) = data.main_split.current_save_as.as_ref() {
                     ctx.submit_command(Command::new(
                         LAPCE_UI_COMMAND,
-                        LapceUICommand::SaveAs(
-                            info.0.clone(),
-                            file.path.clone(),
-                            info.1,
-                            info.2,
-                        ),
+                        LapceUICommand::SaveAs {
+                            content: info.0.clone(),
+                            path: file.path.clone(),
+                            view_id: info.1,
+                            exit: info.2,
+                        },
                         Target::Widget(data.id),
                     ));
                 }
@@ -345,7 +701,7 @@ impl LapceTab {
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
                     LapceUICommand::SetWorkspace(workspace),
-                    Target::Window(data.window_id),
+                    Target::Window(*data.window_id),
                 ));
             }
             Event::Command(cmd) if cmd.is(LAPCE_OPEN_FILE) => {
@@ -353,13 +709,21 @@ impl LapceTab {
                 let file = cmd.get_unchecked(LAPCE_OPEN_FILE);
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::OpenFile(file.path.clone()),
+                    LapceUICommand::OpenFile(file.path.clone(), false),
                     Target::Widget(data.id),
                 ));
             }
             Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
                 let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
                 match command {
+                    LapceUICommand::UpdateStarted => {
+                        ctx.set_handled();
+                        ctx.request_layout();
+                    }
+                    LapceUICommand::UpdateFailed => {
+                        ctx.set_handled();
+                        ctx.request_layout();
+                    }
                     LapceUICommand::RequestPaint => {
                         ctx.request_paint();
                         ctx.set_handled();
@@ -376,19 +740,21 @@ impl LapceTab {
                                         .keypress
                                         .command_keymaps
                                         .get(i.command.kind.str())
+                                        .and_then(|m| {
+                                            m.iter().find_map(KeyMap::hotkey)
+                                        })
                                     {
-                                        if !key.is_empty() {
-                                            item = item.hotkey(
-                                                key[0].key[0].mods,
-                                                key[0].key[0].key.clone(),
-                                            );
-                                        }
+                                        item = item.dynamic_hotkey(move |_, _| {
+                                            Some(key.clone())
+                                        })
                                     }
-                                    item = item.command(Command::new(
-                                        LAPCE_COMMAND,
-                                        i.command.clone(),
-                                        Target::Widget(data.id),
-                                    ));
+                                    item = item
+                                        .command(Command::new(
+                                            LAPCE_COMMAND,
+                                            i.command.clone(),
+                                            Target::Widget(data.id),
+                                        ))
+                                        .enabled(i.enabled);
                                     menu = menu.entry(item);
                                 }
                                 MenuKind::Separator => {
@@ -398,22 +764,17 @@ impl LapceTab {
                         }
                         ctx.show_context_menu::<LapceData>(menu, *point);
                     }
-                    LapceUICommand::InitBufferContent {
-                        path,
-                        content,
-                        locations,
-                    } => {
-                        let doc = data.main_split.open_docs.get_mut(path).unwrap();
-                        Arc::make_mut(doc).init_content(content.to_owned());
-                        for (view_id, location) in locations {
-                            data.main_split.go_to_location(
-                                ctx,
-                                Some(*view_id),
-                                location.clone(),
-                                &data.config,
-                            );
-                        }
-                        ctx.set_handled();
+                    LapceUICommand::InitBufferContent(init) => {
+                        init.execute(ctx, data)
+                    }
+                    LapceUICommand::InitBufferContentLine(init) => {
+                        init.execute(ctx, data)
+                    }
+                    LapceUICommand::InitBufferContentLineCol(init) => {
+                        init.execute(ctx, data)
+                    }
+                    LapceUICommand::InitBufferContentLsp(init) => {
+                        init.execute(ctx, data)
                     }
                     LapceUICommand::InitPaletteInput(pattern) => {
                         let doc = data
@@ -444,20 +805,24 @@ impl LapceTab {
                             .local_docs
                             .get_mut(&LocalBufferKind::Search)
                             .unwrap();
-                        if &doc.buffer().text().to_string() != pattern {
+                        if &doc.buffer().to_string() != pattern {
                             Arc::make_mut(doc).reload(Rope::from(pattern), true);
                         }
                     }
-                    LapceUICommand::UpdateSearch(pattern) => {
+                    LapceUICommand::UpdateSearch(pattern, new_cs) => {
                         if pattern.is_empty() {
                             Arc::make_mut(&mut data.find).unset();
                             Arc::make_mut(&mut data.search).matches =
-                                Arc::new(HashMap::new());
+                                Arc::new(Default::default());
                         } else {
                             let find = Arc::make_mut(&mut data.find);
-                            find.set_find(pattern, false, false, false);
+                            if let Some(cs) = new_cs {
+                                find.set_case_sensitive(*cs);
+                            }
+                            find.set_find(pattern, false, false);
                             find.visual = true;
                             if data.focus_area == FocusArea::Panel(PanelKind::Search)
+                                && data.config.editor.move_focus_while_search
                             {
                                 if let Some(widget_id) = *data.main_split.active {
                                     ctx.submit_command(Command::new(
@@ -475,38 +840,32 @@ impl LapceTab {
                             let pattern = pattern.to_string();
                             let event_sink = ctx.get_external_handle();
                             let tab_id = data.id;
-                            data.proxy.global_search(
-                                    pattern.clone(),
-                                    Box::new(move |result| {
-                                        if let Ok(matches) = result {
-                                            if let Ok(matches) =
-                                                serde_json::from_value::<
-                                                    HashMap<
-                                                        PathBuf,
-                                                        Vec<(
-                                                            usize,
-                                                            (usize, usize),
-                                                            String,
-                                                        )>,
-                                                    >,
-                                                >(
-                                                    matches
-                                                )
-                                            {
-                                                let _ = event_sink.submit_command(
-                                                    LAPCE_UI_COMMAND,
-                                                    LapceUICommand::GlobalSearchResult(
-                                                        pattern,
-                                                        Arc::new(matches),
-                                                    ),
-                                                    Target::Widget(tab_id),
-                                                );
-                                            }
-                                        }
-                                    }),
-                                )
+                            data.proxy.proxy_rpc.global_search(
+                                pattern.clone(),
+                                find.case_sensitive(),
+                                Box::new(move |result| {
+                                    if let Ok(
+                                        ProxyResponse::GlobalSearchResponse {
+                                            matches,
+                                        },
+                                    ) = result
+                                    {
+                                        let _ = event_sink.submit_command(
+                                            LAPCE_UI_COMMAND,
+                                            LapceUICommand::GlobalSearchResult(
+                                                pattern,
+                                                Arc::new(matches),
+                                            ),
+                                            Target::Widget(tab_id),
+                                        );
+                                    }
+                                }),
+                            )
                         }
                     }
+                    LapceUICommand::OpenPluginInfo(volt) => {
+                        data.main_split.open_plugin_info(ctx, volt);
+                    }
                     LapceUICommand::GlobalSearchResult(pattern, matches) => {
                         let doc = data
                             .main_split
@@ -525,15 +884,41 @@ impl LapceTab {
                     } => {
                         let doc = data.main_split.open_docs.get_mut(path).unwrap();
                         let doc = Arc::make_mut(doc);
-                        doc.load_history(version, content.clone());
+                        doc.load_history(
+                            version,
+                            content.clone(),
+                            data.config.editor.diff_context_lines,
+                        );
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::PrepareRename {
+                        path,
+                        rev,
+                        offset,
+                        start,
+                        end,
+                        placeholder,
+                    } => {
                         ctx.set_handled();
+                        Arc::make_mut(&mut data.rename).handle_prepare_rename(
+                            ctx,
+                            &mut data.main_split,
+                            path.to_path_buf(),
+                            *rev,
+                            *offset,
+                            *start,
+                            *end,
+                            placeholder.clone(),
+                        );
                     }
                     LapceUICommand::UpdateTerminalTitle(term_id, title) => {
-                        let terminal_panel = Arc::make_mut(&mut data.terminal);
-                        if let Some(terminal) =
-                            terminal_panel.terminals.get_mut(term_id)
+                        for (_, split) in
+                            Arc::make_mut(&mut data.terminal).tabs.iter_mut()
                         {
-                            Arc::make_mut(terminal).title = title.to_string();
+                            if let Some(terminal) = split.terminals.get_mut(term_id)
+                            {
+                                Arc::make_mut(terminal).title = title.to_string();
+                            }
                         }
                     }
                     LapceUICommand::CancelFilePicker => {
@@ -549,13 +934,45 @@ impl LapceTab {
                         data.set_picker_pwd(path.clone());
                         ctx.set_handled();
                     }
-                    LapceUICommand::FileChange(event) => {
-                        data.handle_file_change(ctx, event);
+                    LapceUICommand::WorkspaceFileChange => {
+                        data.handle_workspace_file_change(ctx);
                         ctx.set_handled();
                     }
+                    LapceUICommand::UpdateCompletion {
+                        request_id,
+                        input,
+                        resp,
+                        plugin_id,
+                    } => {
+                        let completion = Arc::make_mut(&mut data.completion);
+                        completion.receive(
+                            *request_id,
+                            input.to_owned(),
+                            resp.to_owned(),
+                            *plugin_id,
+                        );
+                    }
+                    LapceUICommand::CancelCompletion { request_id } => {
+                        if data.completion.request_id == *request_id {
+                            let completion = Arc::make_mut(&mut data.completion);
+                            completion.cancel();
+                        }
+                    }
+                    LapceUICommand::UpdateSignature {
+                        request_id,
+                        resp,
+                        plugin_id,
+                    } => {
+                        let signature = Arc::make_mut(&mut data.signature);
+                        signature.receive(*request_id, resp.to_owned(), *plugin_id);
+                    }
                     LapceUICommand::CloseTerminal(id) => {
                         let terminal_panel = Arc::make_mut(&mut data.terminal);
-                        if let Some(terminal) = terminal_panel.terminals.get_mut(id)
+                        if let Some(terminal) = terminal_panel
+                            .active_terminal_split_mut()
+                            .unwrap()
+                            .terminals
+                            .get_mut(id)
                         {
                             ctx.submit_command(Command::new(
                                 LAPCE_UI_COMMAND,
@@ -565,51 +982,251 @@ impl LapceTab {
                                 ),
                                 Target::Widget(terminal.split_id),
                             ));
-                            data.proxy.terminal_close(terminal.term_id);
                         }
                         ctx.set_handled();
                     }
-                    LapceUICommand::UpdateInstalledPlugins(plugins) => {
-                        data.installed_plugins = Arc::new(plugins.to_owned());
+                    LapceUICommand::LoadPluginLatest(info) => {
+                        ctx.set_handled();
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        plugin.installed_latest.insert(info.id(), info.clone());
                     }
-                    LapceUICommand::UpdateDiffInfo(diff) => {
-                        let source_control = Arc::make_mut(&mut data.source_control);
-                        source_control.branch = diff.head.to_string();
-                        source_control.branches = diff.branches.clone();
-                        source_control.file_diffs = diff
-                            .diffs
-                            .iter()
-                            .map(|diff| {
-                                let mut checked = true;
-                                for (p, c) in source_control.file_diffs.iter() {
-                                    if p == diff {
-                                        checked = *c;
-                                        break;
-                                    }
-                                }
-                                (diff.clone(), checked)
-                            })
-                            .collect();
-
-                        for (_path, doc) in data.main_split.open_docs.iter() {
-                            doc.reload_history("head");
-                        }
+                    LapceUICommand::LoadPlugins(info) => {
                         ctx.set_handled();
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        plugin.volts.update_volts(info);
                     }
-                    LapceUICommand::WorkDoneProgress(params) => {
+                    LapceUICommand::LoadPluginsFailed => {
+                        ctx.set_handled();
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        plugin.volts.failed();
+                    }
+                    LapceUICommand::LoadPluginIcon(id, icon) => {
+                        ctx.set_handled();
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        plugin.volts.icons.insert(id.clone(), icon.clone());
+                    }
+                    LapceUICommand::VoltInstalled(volt, icon) => {
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        plugin.volt_installed(
+                            data.id,
+                            volt,
+                            icon,
+                            ctx.get_external_handle(),
+                        );
+
+                        for (_, tabs) in data.main_split.editor_tabs.iter() {
+                            for child in tabs.children.iter() {
+                                if let EditorTabChild::Settings {
+                                    settings_widget_id,
+                                    ..
+                                } = child
+                                {
+                                    ctx.submit_command(Command::new(
+                                        LAPCE_UI_COMMAND,
+                                        LapceUICommand::VoltInstalled(
+                                            volt.clone(),
+                                            icon.clone(),
+                                        ),
+                                        Target::Widget(*settings_widget_id),
+                                    ));
+                                }
+                            }
+                        }
+                    }
+                    LapceUICommand::VoltInstalling(volt, error) => {
+                        let plugin = Arc::make_mut(&mut data.plugin);
+
+                        let event_sink = ctx.get_external_handle();
+                        let id = data.id;
+                        let volt_id = volt.id();
+                        if !error.is_empty() {
+                            std::thread::spawn(move || {
+                                std::thread::sleep(std::time::Duration::from_secs(
+                                    3,
+                                ));
+                                let _ = event_sink.submit_command(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::VoltInstallStatusClear(volt_id),
+                                    Target::Widget(id),
+                                );
+                            });
+                        }
+
+                        if let Some(elem) = plugin.installing.get_mut(&volt.id()) {
+                            if !error.is_empty() {
+                                elem.set_error(error);
+                            }
+                        } else {
+                            plugin.installing.insert(
+                                volt.id(),
+                                PluginInstallStatus::new(
+                                    PluginInstallType::Installation,
+                                    &volt.display_name,
+                                    error.to_string(),
+                                ),
+                            );
+                        }
+                    }
+                    LapceUICommand::VoltRemoving(volt, error) => {
+                        let plugin = Arc::make_mut(&mut data.plugin);
+
+                        let event_sink = ctx.get_external_handle();
+                        let id = data.id;
+                        let volt_id = volt.id();
+                        if !error.is_empty() {
+                            std::thread::spawn(move || {
+                                std::thread::sleep(std::time::Duration::from_secs(
+                                    3,
+                                ));
+                                let _ = event_sink.submit_command(
+                                    LAPCE_UI_COMMAND,
+                                    LapceUICommand::VoltInstallStatusClear(volt_id),
+                                    Target::Widget(id),
+                                );
+                            });
+                        }
+
+                        if let Some(elem) = plugin.installing.get_mut(&volt.id()) {
+                            if !error.is_empty() {
+                                elem.set_error(error);
+                            }
+                        } else {
+                            plugin.installing.insert(
+                                volt.id(),
+                                PluginInstallStatus::new(
+                                    PluginInstallType::Uninstallation,
+                                    &volt.display_name,
+                                    error.to_string(),
+                                ),
+                            );
+                        }
+                    }
+                    LapceUICommand::VoltInstallStatusClear(volt_id) => {
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        plugin.installing.remove(volt_id);
+                    }
+                    LapceUICommand::VoltRemoved(volt, only_installing) => {
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        let id = volt.id();
+
+                        // if there is a value inside the installing map, remove it from there as soon as it is installed.
+                        plugin.installing.remove(&volt.id());
+
+                        if !(*only_installing) {
+                            plugin.installed.remove(&id);
+
+                            if plugin.disabled.remove(&id) {
+                                let _ = data.db.save_disabled_volts(
+                                    plugin.disabled.iter().collect(),
+                                );
+                            }
+                            if plugin.workspace_disabled.remove(&id) {
+                                let _ = data.db.save_disabled_volts(
+                                    plugin.workspace_disabled.iter().collect(),
+                                );
+                            }
+
+                            for (_, tabs) in data.main_split.editor_tabs.iter() {
+                                for child in tabs.children.iter() {
+                                    if let EditorTabChild::Settings {
+                                        settings_widget_id,
+                                        ..
+                                    } = child
+                                    {
+                                        ctx.submit_command(Command::new(
+                                            LAPCE_UI_COMMAND,
+                                            LapceUICommand::VoltRemoved(
+                                                volt.clone(),
+                                                false,
+                                            ),
+                                            Target::Widget(*settings_widget_id),
+                                        ));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    LapceUICommand::DisableVoltWorkspace(volt) => {
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        plugin.workspace_disabled.insert(volt.id());
+                        data.proxy.proxy_rpc.disable_volt(volt.clone());
+                        let _ = data.db.save_workspace_disabled_volts(
+                            &data.workspace,
+                            plugin.workspace_disabled.iter().collect(),
+                        );
+                    }
+                    LapceUICommand::EnableVoltWorkspace(volt) => {
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        let id = volt.id();
+                        plugin.workspace_disabled.remove(&id);
+                        if !plugin.plugin_disabled(&id) {
+                            data.proxy.proxy_rpc.enable_volt(volt.clone());
+                        }
+                        let _ = data.db.save_workspace_disabled_volts(
+                            &data.workspace,
+                            plugin.workspace_disabled.iter().collect(),
+                        );
+                    }
+                    LapceUICommand::DisableVolt(volt) => {
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        plugin.disabled.insert(volt.id());
+                        data.proxy.proxy_rpc.disable_volt(volt.clone());
+                        let _ = data
+                            .db
+                            .save_disabled_volts(plugin.disabled.iter().collect());
+                    }
+                    LapceUICommand::EnableVolt(volt) => {
+                        let plugin = Arc::make_mut(&mut data.plugin);
+                        let id = volt.id();
+                        plugin.disabled.remove(&id);
+                        if !plugin.plugin_disabled(&id) {
+                            data.proxy.proxy_rpc.enable_volt(volt.clone());
+                        }
+                        let _ = data
+                            .db
+                            .save_disabled_volts(plugin.disabled.iter().collect());
+                    }
+                    LapceUICommand::UpdateDiffInfo(diff) => {
+                        let source_control = Arc::make_mut(&mut data.source_control);
+                        source_control.branch = diff.head.to_string();
+                        source_control.branches =
+                            diff.branches.iter().cloned().collect();
+                        source_control.file_diffs = diff
+                            .diffs
+                            .iter()
+                            .cloned()
+                            .map(|diff| {
+                                let checked = source_control
+                                    .file_diffs
+                                    .get(diff.path())
+                                    .map_or(true, |(_, c)| *c);
+                                (diff.path().clone(), (diff, checked))
+                            })
+                            .collect();
+
+                        for (_path, doc) in data.main_split.open_docs.iter() {
+                            doc.reload_history("head");
+                        }
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::WorkDoneProgress(params) => {
                         match &params.value {
                             lsp_types::ProgressParamsValue::WorkDone(progress) => {
                                 match progress {
                                     lsp_types::WorkDoneProgress::Begin(begin) => {
-                                        data.progresses.push_back(WorkProgress {
-                                            token: params.token.clone(),
-                                            title: begin.title.clone(),
-                                            message: begin.message.clone(),
-                                            percentage: begin.percentage,
-                                        });
+                                        Arc::make_mut(&mut data.progresses).push(
+                                            WorkProgress {
+                                                token: params.token.clone(),
+                                                title: begin.title.clone(),
+                                                message: begin.message.clone(),
+                                                percentage: begin.percentage,
+                                            },
+                                        );
                                     }
                                     lsp_types::WorkDoneProgress::Report(report) => {
-                                        for p in data.progresses.iter_mut() {
+                                        for p in Arc::make_mut(&mut data.progresses)
+                                            .iter_mut()
+                                        {
                                             if p.token == params.token {
                                                 p.message = report.message.clone();
                                                 p.percentage = report.percentage;
@@ -617,6 +1234,12 @@ impl LapceTab {
                                         }
                                     }
                                     lsp_types::WorkDoneProgress::End(_end) => {
+                                        for view_id in data.main_split.editors.keys()
+                                        {
+                                            let editor_data =
+                                                data.editor_view_content(*view_id);
+                                            editor_data.doc.get_inlay_hints();
+                                        }
                                         for i in data
                                             .progresses
                                             .iter()
@@ -624,7 +1247,8 @@ impl LapceTab {
                                             .sorted()
                                             .rev()
                                         {
-                                            data.progresses.remove(i);
+                                            Arc::make_mut(&mut data.progresses)
+                                                .remove(i);
                                         }
                                     }
                                 }
@@ -637,7 +1261,7 @@ impl LapceTab {
                             .diagnostics
                             .iter()
                             .map(|d| EditorDiagnostic {
-                                range: None,
+                                range: (0, 0),
                                 diagnostic: d.clone(),
                                 lines: d
                                     .related_information
@@ -655,10 +1279,20 @@ impl LapceTab {
                                     + d.message.matches('\n').count()
                                     + 1,
                             })
+                            .sorted_by_key(|d| d.diagnostic.range.start)
                             .collect();
-                        data.main_split
-                            .diagnostics
-                            .insert(path, Arc::new(diagnostics));
+                        let diagnostics: Arc<Vec<EditorDiagnostic>> =
+                            Arc::new(diagnostics);
+
+                        // inform the document about the diagnostics
+                        if let Some(document) =
+                            data.main_split.open_docs.get_mut(&path)
+                        {
+                            let document = Arc::make_mut(document);
+                            document.set_diagnostics(&diagnostics);
+                        }
+
+                        data.main_split.diagnostics.insert(path, diagnostics);
 
                         let mut errors = 0;
                         let mut warnings = 0;
@@ -668,8 +1302,8 @@ impl LapceTab {
                                     diagnostic.diagnostic.severity
                                 {
                                     match severity {
-                                        DiagnosticSeverity::Error => errors += 1,
-                                        DiagnosticSeverity::Warning => warnings += 1,
+                                        DiagnosticSeverity::ERROR => errors += 1,
+                                        DiagnosticSeverity::WARNING => warnings += 1,
                                         _ => (),
                                     }
                                 }
@@ -680,25 +1314,35 @@ impl LapceTab {
 
                         ctx.set_handled();
                     }
-                    LapceUICommand::DocumentSave(path, exit) => {
+                    LapceUICommand::DocumentSave { path, exit } => {
                         data.main_split.document_save(ctx, path, *exit);
                         ctx.set_handled();
                     }
-                    LapceUICommand::DocumentFormatAndSave(
+                    LapceUICommand::DocumentFormatAndSave {
                         path,
                         rev,
                         result,
                         exit,
-                    ) => {
+                    } => {
                         data.main_split.document_format_and_save(
                             ctx, path, *rev, result, *exit,
                         );
                         ctx.set_handled();
                     }
-                    LapceUICommand::DocumentFormat(path, rev, result) => {
+                    LapceUICommand::DocumentFormat { path, rev, result } => {
                         data.main_split.document_format(path, *rev, result);
                         ctx.set_handled();
                     }
+                    LapceUICommand::ShowAbout => {
+                        let about = Arc::make_mut(&mut data.about);
+                        about.active = true;
+                        ctx.submit_command(Command::new(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::Focus,
+                            Target::Widget(about.widget_id),
+                        ));
+                        ctx.set_handled();
+                    }
                     LapceUICommand::ShowAlert(content) => {
                         let alert = Arc::make_mut(&mut data.alert);
                         alert.active = true;
@@ -710,7 +1354,11 @@ impl LapceTab {
                         ));
                         ctx.set_handled();
                     }
-                    LapceUICommand::BufferSave(path, rev, exit_widget_id) => {
+                    LapceUICommand::BufferSave {
+                        path,
+                        rev,
+                        exit: exit_widget_id,
+                    } => {
                         let doc = data.main_split.open_docs.get_mut(path).unwrap();
                         if doc.rev() == *rev {
                             Arc::make_mut(doc).buffer_mut().set_pristine();
@@ -729,40 +1377,28 @@ impl LapceTab {
                         }
                         ctx.set_handled();
                     }
-                    LapceUICommand::LoadBufferAndGoToPosition {
-                        path,
-                        content,
-                        editor_view_id,
-                        location,
-                    } => {
-                        let doc = data.main_split.open_docs.get_mut(path).unwrap();
-                        Arc::make_mut(doc).reload(Rope::from(content), true);
-                        data.main_split.go_to_location(
-                            ctx,
-                            Some(*editor_view_id),
-                            location.clone(),
-                            &data.config,
-                        );
+                    LapceUICommand::UpdateSettingsFile { kind, key, value } => {
                         ctx.set_handled();
-                    }
-                    LapceUICommand::UpdateSettingsFile(parent, key, value) => {
-                        if let Ok(value) = toml::Value::deserialize(value) {
+                        if let Some(value) = toml_edit::ser::to_item(value)
+                            .ok()
+                            .and_then(|i| i.into_value().ok())
+                        {
                             let update_result =
-                                Config::update_file(parent, key, value);
+                                LapceConfig::update_file(kind, key, value);
                             debug_assert!(update_result.is_some());
                         }
                     }
-                    LapceUICommand::ResetSettingsFile(parent, key) => {
-                        Config::reset_setting(parent, key);
+                    LapceUICommand::ResetSettingsFile { kind, key } => {
+                        LapceConfig::reset_setting(kind, key);
                     }
-                    LapceUICommand::OpenFileDiff(path, history) => {
-                        let editor_view_id = data.main_split.active.clone();
+                    LapceUICommand::OpenFileDiff { path, history } => {
                         let editor_view_id = data.main_split.jump_to_location(
                             ctx,
-                            *editor_view_id,
+                            None,
+                            false,
                             EditorLocation {
                                 path: path.clone(),
-                                position: None,
+                                position: None::<usize>,
                                 scroll_offset: None,
                                 history: Some(history.to_string()),
                             },
@@ -780,30 +1416,44 @@ impl LapceTab {
                         let keypress = Arc::make_mut(&mut data.keypress);
                         keypress.filter_commands(pattern);
                     }
-                    LapceUICommand::FilterKeymaps(
+                    LapceUICommand::FilterKeymaps {
                         pattern,
-                        filtered_commands_with_keymap,
-                        filtered_commands_without_keymap,
-                    ) => {
+                        keymaps,
+                        commands,
+                    } => {
                         ctx.set_handled();
                         let keypress = Arc::make_mut(&mut data.keypress);
                         if &keypress.filter_pattern == pattern {
-                            keypress.filtered_commands_with_keymap =
-                                filtered_commands_with_keymap.clone();
+                            keypress.filtered_commands_with_keymap = keymaps.clone();
                             keypress.filtered_commands_without_keymap =
-                                filtered_commands_without_keymap.clone();
+                                commands.clone();
                         }
                     }
                     LapceUICommand::UpdateKeymap(keymap, keys) => {
                         KeyPressData::update_file(keymap, keys);
                     }
-                    LapceUICommand::OpenFile(path) => {
+                    LapceUICommand::OpenURI(uri) => {
+                        ctx.set_handled();
+                        if !uri.is_empty() {
+                            log::debug!(target: "lapce_ui::tab::handle_event::open_uri", "uri: {uri}");
+                            match open::that(uri) {
+                                Ok(_) => {
+                                    log::debug!(target: "lapce_ui::tab::handle_event::open_uri", "successfully opened URI: {uri}")
+                                }
+                                Err(e) => {
+                                    log::error!(target: "lapce_ui::tab::handle_event::open_uri", "{e}")
+                                }
+                            }
+                        }
+                    }
+                    LapceUICommand::OpenFile(path, same_tab) => {
                         data.main_split.jump_to_location(
                             ctx,
                             None,
+                            *same_tab,
                             EditorLocation {
                                 path: path.clone(),
-                                position: None,
+                                position: None::<usize>,
                                 scroll_offset: None,
                                 history: None,
                             },
@@ -811,28 +1461,107 @@ impl LapceTab {
                         );
                         ctx.set_handled();
                     }
-                    LapceUICommand::GoToLocationNew(editor_view_id, location) => {
+                    LapceUICommand::RevealInFileExplorer(path) => {
+                        // TODO: replace with proper implementation from druid that
+                        // highlights items in file explorer
+                        let path = match path.parent() {
+                            Some(p) => p,
+                            None => path,
+                        };
+                        if path.exists() {
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::OpenURI(
+                                    path.to_str().unwrap().to_string(),
+                                ),
+                                Target::Auto,
+                            ));
+                        }
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::GoToLocation(
+                        editor_view_id,
+                        location,
+                        same_tab,
+                    ) => {
                         data.main_split.go_to_location(
                             ctx,
-                            Some(*editor_view_id),
+                            *editor_view_id,
+                            *same_tab,
                             location.clone(),
                             &data.config,
                         );
                         ctx.set_handled();
                     }
-                    LapceUICommand::JumpToPosition(editor_view_id, position) => {
+                    LapceUICommand::JumpToPosition(
+                        editor_view_id,
+                        position,
+                        same_tab,
+                    ) => {
                         data.main_split.jump_to_position(
                             ctx,
                             *editor_view_id,
+                            *same_tab,
                             *position,
                             &data.config,
                         );
                         ctx.set_handled();
                     }
-                    LapceUICommand::JumpToLocation(editor_view_id, location) => {
+                    LapceUICommand::JumpToLocation(
+                        editor_view_id,
+                        location,
+                        same_tab,
+                    ) => {
+                        data.main_split.jump_to_location(
+                            ctx,
+                            *editor_view_id,
+                            *same_tab,
+                            location.clone(),
+                            &data.config,
+                        );
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::JumpToLspLocation(
+                        editor_view_id,
+                        location,
+                        same_tab,
+                    ) => {
+                        data.main_split.jump_to_location(
+                            ctx,
+                            *editor_view_id,
+                            *same_tab,
+                            location.clone(),
+                            &data.config,
+                        );
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::ToggleProblem(path) => {
+                        let problem = Arc::make_mut(&mut data.problem);
+                        let state = problem
+                            .collapsed
+                            .entry(path.to_owned())
+                            .or_insert(false);
+                        *state = !*state;
+                    }
+                    LapceUICommand::JumpToLineLocation(editor_view_id, location) => {
+                        data.main_split.jump_to_location(
+                            ctx,
+                            *editor_view_id,
+                            true,
+                            location.clone(),
+                            &data.config,
+                        );
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::JumpToLineColLocation(
+                        editor_view_id,
+                        location,
+                        same_tab,
+                    ) => {
                         data.main_split.jump_to_location(
                             ctx,
                             *editor_view_id,
+                            *same_tab,
                             location.clone(),
                             &data.config,
                         );
@@ -848,11 +1577,7 @@ impl LapceTab {
                         ctx.set_handled();
                     }
                     LapceUICommand::TerminalJumpToLine(line) => {
-                        if let Some(terminal) = data
-                            .terminal
-                            .terminals
-                            .get(&data.terminal.active_term_id)
-                        {
+                        if let Some(terminal) = data.terminal.active_terminal() {
                             terminal.raw.lock().term.vi_goto_point(
                                 alacritty_terminal::index::Point::new(
                                     alacritty_terminal::index::Line(*line),
@@ -867,11 +1592,11 @@ impl LapceTab {
                         // ));
                         ctx.set_handled();
                     }
-                    LapceUICommand::GotoDefinition(
+                    LapceUICommand::GotoDefinition {
                         editor_view_id,
                         offset,
                         location,
-                    ) => {
+                    } => {
                         if let Some(editor) = data.main_split.active_editor() {
                             if *editor_view_id == editor.view_id
                                 && *offset == editor.cursor.offset()
@@ -879,6 +1604,7 @@ impl LapceTab {
                                 data.main_split.jump_to_location(
                                     ctx,
                                     None,
+                                    true,
                                     location.clone(),
                                     &data.config,
                                 );
@@ -886,31 +1612,32 @@ impl LapceTab {
                         }
                         ctx.set_handled();
                     }
-                    LapceUICommand::GotoReference(
-                        editor_view_id,
-                        offset,
-                        location,
-                    ) => {
-                        if let Some(editor) = data.main_split.active_editor() {
-                            if *editor_view_id == editor.view_id
-                                && *offset == editor.cursor.offset()
-                            {
-                                data.main_split.jump_to_location(
-                                    ctx,
-                                    Some(*editor_view_id),
-                                    location.clone(),
-                                    &data.config,
-                                );
+                    LapceUICommand::UpdateInlayHints { path, rev, hints } => {
+                        if let Some(doc) = data.main_split.open_docs.get_mut(path) {
+                            if doc.rev() == *rev {
+                                Arc::make_mut(doc).set_inlay_hints(hints.clone());
+                            }
+                        }
+                    }
+                    LapceUICommand::CodeActionsError { path, rev, offset } => {
+                        if let Some(doc) = data.main_split.open_docs.get_mut(path) {
+                            if doc.rev() == *rev {
+                                Arc::make_mut(doc).code_actions.remove(offset);
                             }
                         }
-                        ctx.set_handled();
                     }
-                    LapceUICommand::UpdateCodeActions(path, rev, offset, resp) => {
+                    LapceUICommand::UpdateCodeActions {
+                        path,
+                        plugin_id,
+                        rev,
+                        offset,
+                        resp,
+                    } => {
                         if let Some(doc) = data.main_split.open_docs.get_mut(path) {
                             if doc.rev() == *rev {
                                 Arc::make_mut(doc)
                                     .code_actions
-                                    .insert(*offset, resp.clone());
+                                    .insert(*offset, (*plugin_id, resp.clone()));
                             }
                         }
                     }
@@ -935,17 +1662,22 @@ impl LapceTab {
                         }
                         ctx.set_handled();
                     }
-                    LapceUICommand::SaveAs(content, path, view_id, exit) => {
+                    LapceUICommand::SaveAs {
+                        content,
+                        path,
+                        view_id,
+                        exit,
+                    } => {
                         data.main_split.save_as(ctx, content, path, *view_id, *exit);
                         ctx.set_handled();
                     }
-                    LapceUICommand::SaveAsSuccess(
+                    LapceUICommand::SaveAsSuccess {
                         content,
                         rev,
                         path,
                         view_id,
                         exit,
-                    ) => {
+                    } => {
                         data.main_split.save_as_success(
                             ctx, content, *rev, path, *view_id, *exit,
                         );
@@ -967,7 +1699,7 @@ impl LapceTab {
                                     && editor.cursor.offset() >= doc.buffer().len()
                                 {
                                     let editor = Arc::make_mut(editor);
-                                    if data.config.lapce.modal {
+                                    if data.config.core.modal {
                                         editor.cursor = Cursor::new(
                                             CursorMode::Normal(
                                                 doc.buffer().offset_line_end(
@@ -995,7 +1727,12 @@ impl LapceTab {
                         }
                         ctx.set_handled();
                     }
-                    LapceUICommand::UpdateSemanticStyles(_id, path, rev, styles) => {
+                    LapceUICommand::UpdateSemanticStyles {
+                        path,
+                        rev,
+                        styles,
+                        ..
+                    } => {
                         let doc = data.main_split.open_docs.get_mut(path).unwrap();
                         if doc.rev() == *rev {
                             let doc = Arc::make_mut(doc);
@@ -1005,67 +1742,19 @@ impl LapceTab {
                         ctx.set_handled();
                     }
                     LapceUICommand::Focus => {
-                        let dir = data
-                            .workspace
-                            .path
-                            .as_ref()
-                            .map(|p| {
-                                let dir = p
-                                    .file_name()
-                                    .unwrap_or(p.as_os_str())
-                                    .to_string_lossy();
-                                let dir = match &data.workspace.kind {
-                                    LapceWorkspaceType::Local => dir.to_string(),
-                                    LapceWorkspaceType::RemoteSSH(user, host) => {
-                                        format!("{} [{}@{}]", dir, user, host)
-                                    }
-                                    LapceWorkspaceType::RemoteWSL => {
-                                        format!("{dir} [wsl]")
-                                    }
-                                };
-                                dir
-                            })
-                            .unwrap_or_else(|| "Lapce".to_string());
-                        ctx.window().set_title(&dir);
+                        ctx.window().set_title(
+                            &workspace_title(&data.workspace)
+                                .map(|x| format!("{x} - Lapce"))
+                                .unwrap_or_else(|| String::from("Lapce")),
+                        );
                         ctx.submit_command(Command::new(
                             LAPCE_UI_COMMAND,
                             LapceUICommand::Focus,
-                            Target::Widget(data.focus),
+                            Target::Widget(*data.focus),
                         ));
                         ctx.set_handled();
                     }
-                    LapceUICommand::FocusSourceControl => {
-                        for (_, panel) in data.panels.iter_mut() {
-                            for kind in panel.widgets.clone() {
-                                if kind == PanelKind::SourceControl {
-                                    let panel = Arc::make_mut(panel);
-                                    panel.active = PanelKind::SourceControl;
-                                    panel.shown = true;
-                                    ctx.submit_command(Command::new(
-                                        LAPCE_UI_COMMAND,
-                                        LapceUICommand::Focus,
-                                        Target::Widget(data.source_control.active),
-                                    ));
-                                }
-                            }
-                        }
-                        ctx.set_handled();
-                    }
-                    LapceUICommand::FocusEditor => {
-                        if let Some(active) = *data.main_split.active_tab {
-                            ctx.submit_command(Command::new(
-                                LAPCE_UI_COMMAND,
-                                LapceUICommand::Focus,
-                                Target::Widget(active),
-                            ));
-                        }
-                        ctx.set_handled();
-                    }
-                    LapceUICommand::UpdateSyntax {
-                        content,
-                        rev,
-                        syntax,
-                    } => {
+                    LapceUICommand::UpdateSyntax { content, syntax } => {
                         ctx.set_handled();
                         let doc = match content {
                             BufferContent::File(path) => {
@@ -1074,7 +1763,7 @@ impl LapceTab {
                             BufferContent::Local(kind) => {
                                 data.main_split.local_docs.get_mut(kind).unwrap()
                             }
-                            BufferContent::SettingsValue(name, _, _, _) => {
+                            BufferContent::SettingsValue(name) => {
                                 data.main_split.value_docs.get_mut(name).unwrap()
                             }
                             BufferContent::Scratch(id, _) => {
@@ -1082,17 +1771,43 @@ impl LapceTab {
                             }
                         };
                         let doc = Arc::make_mut(doc);
-                        if doc.rev() == *rev {
-                            if let Some(syntax) = syntax.take() {
+                        if let Some(syntax) = syntax.take() {
+                            if doc.rev() == syntax.rev {
                                 doc.set_syntax(Some(syntax));
                             }
                         }
                     }
+                    LapceUICommand::SetLanguage(name) => {
+                        ctx.set_handled();
+                        let editor = if let Some(editor) =
+                            data.main_split.active_editor().cloned()
+                        {
+                            editor
+                        } else {
+                            return;
+                        };
+
+                        let doc = data.main_split.content_doc_mut(&editor.content);
+                        let doc = Arc::make_mut(doc);
+
+                        if name.is_empty() || name.to_lowercase().eq("plain text") {
+                            doc.set_syntax(None);
+                        } else {
+                            let lang = match LapceLanguage::from_name(name) {
+                                Some(v) => v,
+                                None => return,
+                            };
+
+                            doc.set_language(lang);
+                        }
+                        doc.trigger_syntax_change(None);
+                    }
                     LapceUICommand::UpdateHistoryChanges {
                         path,
                         rev,
                         history,
                         changes,
+                        diff_context_lines,
                         ..
                     } => {
                         ctx.set_handled();
@@ -1101,6 +1816,7 @@ impl LapceTab {
                             *rev,
                             history,
                             changes.clone(),
+                            *diff_context_lines,
                         );
                     }
                     LapceUICommand::UpdateHistoryStyle {
@@ -1125,7 +1841,11 @@ impl LapceTab {
                             .set_item_children(path, items.clone());
                         ctx.set_handled();
                     }
-                    LapceUICommand::UpdateExplorerItems(path, items, expand) => {
+                    LapceUICommand::UpdateExplorerItems {
+                        path,
+                        items,
+                        expand,
+                    } => {
                         let file_explorer = Arc::make_mut(&mut data.file_explorer);
                         file_explorer.update_children(
                             path,
@@ -1134,19 +1854,214 @@ impl LapceTab {
                         );
                         ctx.set_handled();
                     }
-                    _ => (),
-                }
-            }
-            _ => (),
-        }
-    }
-}
-
-impl Widget<LapceTabData> for LapceTab {
-    fn id(&self) -> Option<WidgetId> {
-        Some(self.id)
-    }
-
+                    LapceUICommand::CreateFileOpen { path } => {
+                        let path_c = path.clone();
+                        let event_sink = ctx.get_external_handle();
+                        let tab_id = data.id;
+                        let explorer = data.file_explorer.clone();
+                        data.proxy.proxy_rpc.create_file(
+                            path.clone(),
+                            Box::new(move |res| {
+                                match res {
+                                    Ok(_) => {
+                                        let _ = event_sink.submit_command(
+                                            LAPCE_UI_COMMAND,
+                                            LapceUICommand::OpenFile(path_c, false),
+                                            Target::Widget(tab_id),
+                                        );
+                                    }
+                                    Err(err) => {
+                                        // TODO: Inform the user through a corner-notif
+                                        log::warn!(
+                                            "Failed to create file: {:?}",
+                                            err,
+                                        );
+                                    }
+                                }
+                                explorer.reload();
+                            }),
+                        );
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::CreateDirectory { path } => {
+                        let explorer = data.file_explorer.clone();
+                        data.proxy.proxy_rpc.create_directory(
+                            path.clone(),
+                            Box::new(move |res| {
+                                if let Err(err) = res {
+                                    // TODO: Inform the user through a corner-notif
+                                    log::warn!(
+                                        "Failed to create directory: {:?}",
+                                        err
+                                    );
+                                }
+                                explorer.reload();
+                            }),
+                        );
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::DuplicateFileOpen {
+                        existing_path,
+                        new_path,
+                    } => {
+                        let new_path_clone = new_path.clone();
+                        let event_sink = ctx.get_external_handle();
+                        let tab_id = data.id;
+                        let explorer = data.file_explorer.clone();
+                        data.proxy.proxy_rpc.duplicate_path(
+                            existing_path.clone(),
+                            new_path.clone(),
+                            Box::new(move |res| {
+                                match res {
+                                    Ok(_) => {
+                                        let _ = event_sink.submit_command(
+                                            LAPCE_UI_COMMAND,
+                                            LapceUICommand::OpenFile(
+                                                new_path_clone,
+                                                false,
+                                            ),
+                                            Target::Widget(tab_id),
+                                        );
+                                    }
+                                    Err(err) => {
+                                        // TODO: Inform the user through a corner-notif
+                                        log::warn!(
+                                            "Failed to duplicate file: {:?}",
+                                            err,
+                                        );
+                                    }
+                                }
+                                explorer.reload();
+                            }),
+                        );
+                    }
+                    LapceUICommand::RenamePath { from, to } => {
+                        let explorer = data.file_explorer.clone();
+                        data.proxy.proxy_rpc.rename_path(
+                            from.clone(),
+                            to.clone(),
+                            Box::new(move |res| {
+                                if let Err(err) = res {
+                                    // TODO: inform the user through a corner-notif
+                                    log::warn!("Failed to rename path: {:?}", err);
+                                }
+                                explorer.reload();
+                            }),
+                        );
+                    }
+                    LapceUICommand::TrashPath { path } => {
+                        let explorer = data.file_explorer.clone();
+                        data.proxy.proxy_rpc.trash_path(
+                            path.clone(),
+                            Box::new(move |res| {
+                                if let Err(err) = res {
+                                    // TODO: inform the user through a corner-notif
+                                    log::warn!("Failed to trash path: {:?}", err);
+                                }
+                                explorer.reload();
+                            }),
+                        );
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::ExplorerNew {
+                        list_index,
+                        indent_level,
+                        is_dir,
+                        base_path,
+                    } => {
+                        let file_explorer = Arc::make_mut(&mut data.file_explorer);
+                        file_explorer.start_naming(
+                            ctx,
+                            &mut data.main_split,
+                            *list_index,
+                            *indent_level,
+                            *is_dir,
+                            base_path.clone(),
+                        );
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::ExplorerStartDuplicate {
+                        list_index,
+                        indent_level,
+                        base_path,
+                        name,
+                    } => {
+                        let file_explorer = Arc::make_mut(&mut data.file_explorer);
+                        file_explorer.start_duplicating(
+                            ctx,
+                            &mut data.main_split,
+                            *list_index,
+                            *indent_level,
+                            base_path.clone(),
+                            name.clone(),
+                        );
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::ExplorerStartRename {
+                        list_index,
+                        indent_level,
+                        text,
+                    } => {
+                        let file_explorer = Arc::make_mut(&mut data.file_explorer);
+                        file_explorer.start_renaming(
+                            ctx,
+                            &mut data.main_split,
+                            *list_index,
+                            *indent_level,
+                            text.clone(),
+                        );
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::ExplorerEndNaming { apply_naming } => {
+                        let file_explorer = Arc::make_mut(&mut data.file_explorer);
+                        if *apply_naming {
+                            file_explorer.apply_naming(ctx, &data.main_split);
+                        } else {
+                            file_explorer.cancel_naming();
+                        }
+                    }
+                    LapceUICommand::PutToClipboard(target_string) => {
+                        let mut clipboard = druid::Application::global().clipboard();
+                        clipboard.put_string(target_string);
+                    }
+                    LapceUICommand::NewMessage {
+                        kind,
+                        title,
+                        message,
+                    } => {
+                        ctx.set_handled();
+                        ctx.submit_command(Command::new(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::NewMessage {
+                                kind: *kind,
+                                title: title.clone(),
+                                message: message.clone(),
+                            },
+                            Target::Widget(*data.message_widget_id),
+                        ));
+                    }
+                    LapceUICommand::RunCommand(cmd, args) => {
+                        ctx.set_handled();
+                        let _ = process::Command::new(cmd).args(args).spawn();
+                    }
+                    LapceUICommand::ImageLoaded { url, image } => {
+                        ctx.set_handled();
+                        let images = Arc::make_mut(&mut data.images);
+                        images.load_finished(url, image)
+                    }
+                    _ => (),
+                }
+            }
+            _ => (),
+        }
+    }
+}
+
+impl Widget<LapceTabData> for LapceTab {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.id)
+    }
+
     fn event(
         &mut self,
         ctx: &mut EventCtx,
@@ -1154,52 +2069,151 @@ impl Widget<LapceTabData> for LapceTab {
         data: &mut LapceTabData,
         env: &Env,
     ) {
-        if event.should_propagate_to_hidden() {
-            self.handle_event(ctx, event, data, env);
-        }
+        self.handle_command_event(ctx, event, data, env);
 
+        if data.about.active || event.should_propagate_to_hidden() {
+            self.about.event(ctx, event, data, env);
+        }
         if data.alert.active || event.should_propagate_to_hidden() {
             self.alert.event(ctx, event, data, env);
         }
         if data.picker.active || event.should_propagate_to_hidden() {
             self.picker.event(ctx, event, data, env);
         }
-        if data.palette.status != PaletteStatus::Inactive
+        self.title.event(ctx, event, data, env);
+        self.message.event(ctx, event, data, env);
+        if data.completion.status == CompletionStatus::Started
             || event.should_propagate_to_hidden()
         {
-            self.palette.event(ctx, event, data, env);
+            self.completion.event(ctx, event, data, env);
         }
-        if data.completion.status == CompletionStatus::Started
+        if data.signature.status == SignatureStatus::Started
             || event.should_propagate_to_hidden()
         {
-            self.completion.event(ctx, event, data, env);
+            self.signature.event(ctx, event, data, env);
         }
         if data.hover.status == HoverStatus::Done
             || event.should_propagate_to_hidden()
         {
             self.hover.event(ctx, event, data, env);
         }
-
-        if !event.should_propagate_to_hidden() && !ctx.is_handled() {
-            self.handle_event(ctx, event, data, env);
+        if data.rename.active || event.should_propagate_to_hidden() {
+            self.rename.event(ctx, event, data, env);
         }
 
+        self.handle_mouse_event(ctx, event, data, env);
+
         self.main_split.event(ctx, event, data, env);
+
         self.status.event(ctx, event, data, env);
-        for (_, panel) in data.panels.clone().iter() {
-            if panel.is_shown() || event.should_propagate_to_hidden() {
-                self.panels
-                    .get_mut(&panel.active)
-                    .unwrap()
-                    .event(ctx, event, data, env);
+        if data.panel.is_container_shown(&PanelContainerPosition::Left)
+            || event.should_propagate_to_hidden()
+        {
+            self.panel_left.event(ctx, event, data, env);
+        }
+        if data
+            .panel
+            .is_container_shown(&PanelContainerPosition::Right)
+            || event.should_propagate_to_hidden()
+        {
+            self.panel_right.event(ctx, event, data, env);
+        }
+        if data
+            .panel
+            .is_container_shown(&PanelContainerPosition::Bottom)
+            || event.should_propagate_to_hidden()
+        {
+            self.panel_bottom.event(ctx, event, data, env);
+        }
+
+        if data.hover.status != HoverStatus::Inactive {
+            if let Event::MouseMove(mouse_event) = &event {
+                if !self.hover.layout_rect().contains(mouse_event.pos)
+                    && !self.main_split.layout_rect().contains(mouse_event.pos)
+                {
+                    Arc::make_mut(&mut data.hover).cancel();
+                }
+            }
+            if !data.main_split.editor_tabs.iter().any(|(_, tab)| {
+                tab.active_child().map(|c| c.widget_id())
+                    == Some(data.hover.editor_view_id)
+            }) {
+                Arc::make_mut(&mut data.hover).cancel();
             }
         }
-        self.activity.event(ctx, event, data, env);
+
+        if ctx.is_handled() {
+            return;
+        }
 
         match event {
-            Event::MouseUp(_) => {
-                if data.drag.is_some() {
-                    *Arc::make_mut(&mut data.drag) = None;
+            Event::MouseMove(mouse) => {
+                self.mouse_pos = mouse.pos;
+                if ctx.is_active() {
+                    self.update_split_point(ctx, data, mouse.pos);
+                    ctx.request_layout();
+                    ctx.set_handled();
+                } else if data.drag.is_some() {
+                    ctx.request_paint();
+                } else if ctx.has_active() {
+                    ctx.clear_cursor();
+                } else {
+                    match self.bar_hit_test(mouse.pos) {
+                        Some(position) => {
+                            if self.current_bar_hover.as_ref() != Some(&position) {
+                                self.current_bar_hover = Some(position.clone());
+                                ctx.request_paint();
+                            }
+                            match position {
+                                PanelResizePosition::Left => {
+                                    ctx.set_cursor(&druid::Cursor::ResizeLeftRight);
+                                }
+                                PanelResizePosition::Right => {
+                                    ctx.set_cursor(&druid::Cursor::ResizeLeftRight);
+                                }
+                                PanelResizePosition::LeftSplit => {
+                                    ctx.set_cursor(&druid::Cursor::ResizeUpDown);
+                                }
+                                PanelResizePosition::Bottom => {
+                                    ctx.set_cursor(&druid::Cursor::ResizeUpDown)
+                                }
+                            }
+                        }
+                        None => {
+                            if self.current_bar_hover.is_some() {
+                                self.current_bar_hover = None;
+                                ctx.request_paint();
+                            }
+                            ctx.clear_cursor();
+                        }
+                    }
+                }
+            }
+            Event::MouseDown(_) => {
+                if !ctx.is_handled() {
+                    if data.palette.status != PaletteStatus::Inactive {
+                        ctx.submit_command(Command::new(
+                            LAPCE_COMMAND,
+                            LapceCommand {
+                                kind: CommandKind::Focus(FocusCommand::ModalClose),
+                                data: None,
+                            },
+                            Target::Widget(data.palette.widget_id),
+                        ));
+                    }
+                    if data.title.branches.active {
+                        Arc::make_mut(&mut data.title).branches.active = false;
+                    }
+                    if data.focus_area == FocusArea::Rename {
+                        ctx.submit_command(Command::new(
+                            LAPCE_COMMAND,
+                            LapceCommand {
+                                kind: CommandKind::Focus(FocusCommand::ModalClose),
+                                data: None,
+                            },
+                            Target::Widget(data.rename.view_id),
+                        ));
+                    }
                 }
             }
             Event::KeyDown(key_event) if !ctx.is_handled() => {
@@ -1232,19 +2246,20 @@ impl Widget<LapceTabData> for LapceTab {
                 ctx.request_layout();
             }
         }
-        self.palette.lifecycle(ctx, event, data, env);
-        self.activity.lifecycle(ctx, event, data, env);
+        self.title.lifecycle(ctx, event, data, env);
         self.main_split.lifecycle(ctx, event, data, env);
         self.status.lifecycle(ctx, event, data, env);
         self.completion.lifecycle(ctx, event, data, env);
+        self.signature.lifecycle(ctx, event, data, env);
         self.hover.lifecycle(ctx, event, data, env);
+        self.rename.lifecycle(ctx, event, data, env);
         self.picker.lifecycle(ctx, event, data, env);
-        self.settings.lifecycle(ctx, event, data, env);
+        self.about.lifecycle(ctx, event, data, env);
         self.alert.lifecycle(ctx, event, data, env);
-
-        for (_, panel) in self.panels.iter_mut() {
-            panel.lifecycle(ctx, event, data, env);
-        }
+        self.message.lifecycle(ctx, event, data, env);
+        self.panel_left.lifecycle(ctx, event, data, env);
+        self.panel_right.lifecycle(ctx, event, data, env);
+        self.panel_bottom.lifecycle(ctx, event, data, env);
     }
 
     fn update(
@@ -1266,11 +2281,24 @@ impl Widget<LapceTabData> for LapceTab {
             ctx.request_paint();
         }
 
-        if !old_data.alert.active != data.alert.active {
+        if !old_data.plugin.same(&data.plugin) {
+            if old_data.plugin.installed.len() != data.plugin.installed.len()
+                || old_data.plugin.volts.volts.len() != data.plugin.volts.volts.len()
+            {
+                ctx.request_layout();
+            } else {
+                ctx.request_paint();
+            }
+        }
+
+        if old_data.about.active != data.about.active {
+            ctx.request_layout();
+        }
+        if old_data.alert.active != data.alert.active {
             ctx.request_layout();
         }
 
-        if old_data
+        if !old_data
             .main_split
             .diagnostics
             .same(&data.main_split.diagnostics)
@@ -1278,7 +2306,19 @@ impl Widget<LapceTabData> for LapceTab {
             ctx.request_paint();
         }
 
-        if !old_data.panels.same(&data.panels) {
+        if !old_data.panel.order.same(&data.panel.order) {
+            for (pos, order) in old_data.panel.order.iter() {
+                for kind in order.iter() {
+                    if let Some((_, new_pos)) = data.panel.panel_position(kind) {
+                        if pos != &new_pos {
+                            self.move_panel(ctx, *kind, *pos, new_pos);
+                        }
+                    }
+                }
+            }
+        }
+
+        if !old_data.panel.same(&data.panel) {
             ctx.request_layout();
         }
 
@@ -1286,27 +2326,28 @@ impl Widget<LapceTabData> for LapceTab {
             ctx.request_layout();
         }
 
+        if old_data.rename.active != data.rename.active {
+            ctx.request_layout();
+        }
+
         if old_data.picker.active != data.picker.active {
             ctx.request_layout();
         }
 
-        self.palette.update(ctx, data, env);
-        self.activity.update(ctx, data, env);
+        self.title.update(ctx, data, env);
         self.main_split.update(ctx, data, env);
         self.completion.update(ctx, data, env);
+        self.signature.update(ctx, data, env);
         self.hover.update(ctx, data, env);
+        self.rename.update(ctx, data, env);
         self.status.update(ctx, data, env);
         self.picker.update(ctx, data, env);
-        self.settings.update(ctx, data, env);
+        self.about.update(ctx, data, env);
         self.alert.update(ctx, data, env);
-        for (_, panel) in data.panels.iter() {
-            if panel.is_shown() {
-                self.panels
-                    .get_mut(&panel.active)
-                    .unwrap()
-                    .update(ctx, data, env);
-            }
-        }
+        self.message.update(ctx, data, env);
+        self.panel_left.update(ctx, data, env);
+        self.panel_right.update(ctx, data, env);
+        self.panel_bottom.update(ctx, data, env);
     }
 
     fn layout(
@@ -1316,12 +2357,14 @@ impl Widget<LapceTabData> for LapceTab {
         data: &LapceTabData,
         env: &Env,
     ) -> Size {
-        // ctx.set_paint_insets((0.0, 10.0, 0.0, 0.0));
         let self_size = bc.max();
         self.height = self_size.height;
+        self.width = self_size.width;
 
-        let activity_size = self.activity.layout(ctx, bc, data, env);
-        self.activity.set_origin(ctx, data, env, Point::ZERO);
+        self.title.layout(ctx, bc, data, env);
+        self.title.set_origin(ctx, data, env, Point::ZERO);
+        self.title_height = 36.0;
+        let title_height = self.title_height;
 
         let status_size = self.status.layout(ctx, bc, data, env);
         self.status.set_origin(
@@ -1332,217 +2375,91 @@ impl Widget<LapceTabData> for LapceTab {
         );
         self.status_height = status_size.height;
 
-        let mut active_panels = Vec::new();
-        let panel_left_top_shown = data
-            .panels
-            .get(&PanelPosition::LeftTop)
-            .map(|p| p.is_shown())
-            .unwrap_or(false);
-        let panel_left_bottom_shown = data
-            .panels
-            .get(&PanelPosition::LeftBottom)
-            .map(|p| p.is_shown())
-            .unwrap_or(false);
-        let panel_left_width = if panel_left_top_shown || panel_left_bottom_shown {
-            let left_width = data.panel_size.left;
-            if panel_left_top_shown && panel_left_bottom_shown {
-                let top_height = (self_size.height - status_size.height)
-                    * data.panel_size.left_split;
-                let bottom_height =
-                    self_size.height - status_size.height - top_height;
-
-                let panel_left_top =
-                    data.panels.get(&PanelPosition::LeftTop).unwrap().active;
-                active_panels.push(panel_left_top);
-                let panel_left_top = self.panels.get_mut(&panel_left_top).unwrap();
-                panel_left_top.layout(
-                    ctx,
-                    &BoxConstraints::tight(Size::new(left_width, top_height)),
-                    data,
-                    env,
-                );
-                panel_left_top.set_origin(
-                    ctx,
-                    data,
-                    env,
-                    Point::new(activity_size.width, 0.0),
-                );
+        let left_width = data.panel.size.left;
+        self.panel_left.layout(
+            ctx,
+            &BoxConstraints::tight(Size::new(
+                left_width,
+                self_size.height - status_size.height - title_height,
+            )),
+            data,
+            env,
+        );
+        self.panel_left
+            .set_origin(ctx, data, env, Point::new(0.0, title_height));
+        let panel_left_width =
+            if data.panel.is_container_shown(&PanelContainerPosition::Left) {
+                left_width
+            } else {
+                0.0
+            };
 
-                let panel_left_bottom =
-                    data.panels.get(&PanelPosition::LeftBottom).unwrap().active;
-                active_panels.push(panel_left_bottom);
-                let panel_left_bottom =
-                    self.panels.get_mut(&panel_left_bottom).unwrap();
-                panel_left_bottom.layout(
-                    ctx,
-                    &BoxConstraints::tight(Size::new(left_width, bottom_height)),
-                    data,
-                    env,
-                );
-                panel_left_bottom.set_origin(
-                    ctx,
-                    data,
-                    env,
-                    Point::new(activity_size.width, top_height),
-                );
-            } else if panel_left_top_shown {
-                let top_height = self_size.height - status_size.height;
-                let panel_left_top =
-                    data.panels.get(&PanelPosition::LeftTop).unwrap().active;
-                active_panels.push(panel_left_top);
-                let panel_left_top = self.panels.get_mut(&panel_left_top).unwrap();
-                panel_left_top.layout(
-                    ctx,
-                    &BoxConstraints::tight(Size::new(left_width, top_height)),
-                    data,
-                    env,
-                );
-                panel_left_top.set_origin(
-                    ctx,
-                    data,
-                    env,
-                    Point::new(activity_size.width, 0.0),
-                );
-            } else if panel_left_bottom_shown {
-                let bottom_height = self_size.height - status_size.height;
-                let panel_left_bottom =
-                    data.panels.get(&PanelPosition::LeftBottom).unwrap().active;
-                active_panels.push(panel_left_bottom);
-                let panel_left_bottom =
-                    self.panels.get_mut(&panel_left_bottom).unwrap();
-                panel_left_bottom.layout(
-                    ctx,
-                    &BoxConstraints::tight(Size::new(left_width, bottom_height)),
-                    data,
-                    env,
-                );
-                panel_left_bottom.set_origin(
-                    ctx,
-                    data,
-                    env,
-                    Point::new(activity_size.width, 0.0),
-                );
-            }
-            left_width
+        let right_width = data.panel.size.right;
+        self.panel_right.layout(
+            ctx,
+            &BoxConstraints::tight(Size::new(
+                right_width,
+                self_size.height - status_size.height - title_height,
+            )),
+            data,
+            env,
+        );
+        self.panel_right.set_origin(
+            ctx,
+            data,
+            env,
+            Point::new(self_size.width - right_width, title_height),
+        );
+        let panel_right_width = if data
+            .panel
+            .is_container_shown(&PanelContainerPosition::Right)
+        {
+            right_width
         } else {
             0.0
         };
 
-        let (panel_bottom_left_shown, panel_bottom_left_maximized) = data
-            .panels
-            .get(&PanelPosition::BottomLeft)
-            .map(|p| (p.is_shown(), p.is_maximized()))
-            .unwrap_or((false, false));
-        let (panel_bottom_right_shown, panel_bottom_right_maximized) = data
-            .panels
-            .get(&PanelPosition::BottomRight)
-            .map(|p| (p.is_shown(), p.is_maximized()))
-            .unwrap_or((false, false));
-        let panel_bottom_height = if panel_bottom_left_shown
-            || panel_bottom_right_shown
+        let bottom_height = if data.panel.panel_bottom_maximized() {
+            self_size.height - status_size.height - title_height
+        } else {
+            data.panel.size.bottom
+        };
+        self.panel_bottom.layout(
+            ctx,
+            &BoxConstraints::tight(Size::new(
+                self_size.width - panel_left_width - panel_right_width,
+                bottom_height,
+            )),
+            data,
+            env,
+        );
+        self.panel_bottom.set_origin(
+            ctx,
+            data,
+            env,
+            Point::new(
+                panel_left_width,
+                self_size.height - status_size.height - bottom_height,
+            ),
+        );
+        let panel_bottom_height = if data
+            .panel
+            .is_container_shown(&PanelContainerPosition::Bottom)
         {
-            let maximized =
-                panel_bottom_left_maximized || panel_bottom_right_maximized;
-            let bottom_height = if maximized {
-                self_size.height - status_size.height
-            } else {
-                data.panel_size.bottom
-            };
-            let panel_x = panel_left_width + activity_size.width;
-            let panel_y = self_size.height - status_size.height - bottom_height;
-            let panel_width =
-                self_size.width - activity_size.width - panel_left_width;
-            if panel_bottom_left_shown && panel_bottom_right_shown {
-                let left_width = panel_width * data.panel_size.bottom_split;
-                let right_width = panel_width - left_width;
-
-                let panel_bottom_left =
-                    data.panels.get(&PanelPosition::BottomLeft).unwrap().active;
-                active_panels.push(panel_bottom_left);
-                let panel_bottom_left =
-                    self.panels.get_mut(&panel_bottom_left).unwrap();
-                panel_bottom_left.layout(
-                    ctx,
-                    &BoxConstraints::tight(Size::new(left_width, bottom_height)),
-                    data,
-                    env,
-                );
-                panel_bottom_left.set_origin(
-                    ctx,
-                    data,
-                    env,
-                    Point::new(panel_left_width + activity_size.width, panel_y),
-                );
-
-                let panel_bottom_right =
-                    data.panels.get(&PanelPosition::BottomRight).unwrap().active;
-                active_panels.push(panel_bottom_right);
-                let panel_bottom_right =
-                    self.panels.get_mut(&panel_bottom_right).unwrap();
-                panel_bottom_right.layout(
-                    ctx,
-                    &BoxConstraints::tight(Size::new(right_width, bottom_height)),
-                    data,
-                    env,
-                );
-                panel_bottom_right.set_origin(
-                    ctx,
-                    data,
-                    env,
-                    Point::new(
-                        panel_left_width + left_width + activity_size.width,
-                        panel_y,
-                    ),
-                );
-            } else if panel_bottom_left_shown {
-                let panel_bottom_left =
-                    data.panels.get(&PanelPosition::BottomLeft).unwrap().active;
-                active_panels.push(panel_bottom_left);
-                let panel_bottom_left =
-                    self.panels.get_mut(&panel_bottom_left).unwrap();
-                panel_bottom_left.layout(
-                    ctx,
-                    &BoxConstraints::tight(Size::new(panel_width, bottom_height)),
-                    data,
-                    env,
-                );
-                panel_bottom_left.set_origin(
-                    ctx,
-                    data,
-                    env,
-                    Point::new(panel_x, panel_y),
-                );
-            } else if panel_bottom_right_shown {
-                let panel_bottom_right =
-                    data.panels.get(&PanelPosition::BottomRight).unwrap().active;
-                active_panels.push(panel_bottom_right);
-                let panel_bottom_right =
-                    self.panels.get_mut(&panel_bottom_right).unwrap();
-                panel_bottom_right.layout(
-                    ctx,
-                    &BoxConstraints::tight(Size::new(panel_width, bottom_height)),
-                    data,
-                    env,
-                );
-                panel_bottom_right.set_origin(
-                    ctx,
-                    data,
-                    env,
-                    Point::new(panel_x, panel_y),
-                );
-            }
             bottom_height
         } else {
             0.0
         };
 
         let main_split_size = Size::new(
-            self_size.width - panel_left_width - activity_size.width,
-            self_size.height - status_size.height - panel_bottom_height,
+            self_size.width - panel_left_width - panel_right_width,
+            self_size.height
+                - status_size.height
+                - panel_bottom_height
+                - title_height,
         );
         let main_split_bc = BoxConstraints::tight(main_split_size);
-        let main_split_origin =
-            Point::new(panel_left_width + activity_size.width, 0.0);
+        let main_split_origin = Point::new(panel_left_width, title_height);
         data.main_split.update_split_layout_rect(
             *data.main_split.split_id,
             main_split_size.to_rect().with_origin(main_split_origin),
@@ -1550,16 +2467,32 @@ impl Widget<LapceTabData> for LapceTab {
         self.main_split.layout(ctx, &main_split_bc, data, env);
         self.main_split
             .set_origin(ctx, data, env, main_split_origin);
-        self.main_split_height = main_split_size.height;
 
         if data.completion.status != CompletionStatus::Inactive {
-            let completion_origin =
-                data.completion_origin(ctx.text(), self_size, &data.config);
-            self.completion.layout(ctx, bc, data, env);
+            let completion_size = self.completion.layout(ctx, bc, data, env);
+            let completion_origin = data.completion_origin(
+                ctx.text(),
+                self_size,
+                completion_size,
+                &data.config,
+            );
             self.completion
                 .set_origin(ctx, data, env, completion_origin);
         }
 
+        if data.signature.status != SignatureStatus::Inactive {
+            let signature_size = self.signature.layout(ctx, bc, data, env);
+            let label_offset = self.signature.widget().label_offset;
+            let signature_origin = data.signature_origin(
+                ctx.text(),
+                self_size,
+                signature_size,
+                label_offset,
+                &data.config,
+            );
+            self.signature.set_origin(ctx, data, env, signature_origin);
+        }
+
         if data.hover.status == HoverStatus::Done {
             self.hover.layout(ctx, bc, data, env);
             let hover_origin =
@@ -1567,14 +2500,16 @@ impl Widget<LapceTabData> for LapceTab {
             self.hover.set_origin(ctx, data, env, hover_origin);
         }
 
-        if data.palette.status != PaletteStatus::Inactive {
-            let palette_size = self.palette.layout(ctx, bc, data, env);
-            self.palette.set_origin(
+        if data.rename.active {
+            let rename_size = self.rename.layout(
                 ctx,
+                &BoxConstraints::tight(Size::new(200.0, 200.0)),
                 data,
                 env,
-                Point::new((self_size.width - palette_size.width) / 2.0, 0.0),
             );
+            let rename_origin =
+                data.rename_origin(ctx.text(), self_size, rename_size, &data.config);
+            self.rename.set_origin(ctx, data, env, rename_origin);
         }
 
         if data.picker.active {
@@ -1590,110 +2525,180 @@ impl Widget<LapceTabData> for LapceTab {
             );
         }
 
+        if data.about.active {
+            self.about.layout(ctx, bc, data, env);
+            self.about.set_origin(ctx, data, env, Point::ZERO);
+        }
         if data.alert.active {
             self.alert.layout(ctx, bc, data, env);
             self.alert.set_origin(ctx, data, env, Point::ZERO);
         }
 
+        let message_size = self.message.layout(
+            ctx,
+            &BoxConstraints::new(
+                Size::ZERO,
+                Size::new(
+                    self_size.width,
+                    self_size.height - title_height - status_size.height - 20.0,
+                ),
+            ),
+            data,
+            env,
+        );
+        self.message.set_origin(
+            ctx,
+            data,
+            env,
+            Point::new(
+                (self_size.width - message_size.width - 10.0).max(0.0),
+                title_height + 10.0,
+            ),
+        );
+
         self_size
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
         self.main_split.paint(ctx, data, env);
-        for pos in &[
-            PanelPosition::BottomLeft,
-            PanelPosition::BottomRight,
-            PanelPosition::LeftTop,
-            PanelPosition::LeftBottom,
-            PanelPosition::RightTop,
-            PanelPosition::RightBottom,
-        ] {
-            if let Some(panel) = data.panels.get(pos) {
-                if panel.shown {
-                    if let Some(panel) = self.panels.get_mut(&panel.active) {
-                        let bg = match pos {
-                            PanelPosition::LeftTop
-                            | PanelPosition::LeftBottom
-                            | PanelPosition::RightTop
-                            | PanelPosition::RightBottom => data
-                                .config
-                                .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
-                            PanelPosition::BottomLeft
-                            | PanelPosition::BottomRight => data
-                                .config
-                                .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
-                        };
-                        let rect = panel.layout_rect();
-                        let shadow_width = data.config.ui.drop_shadow_width() as f64;
-                        if shadow_width > 0.0 {
-                            ctx.blurred_rect(
-                                rect,
-                                shadow_width,
-                                data.config.get_color_unchecked(
-                                    LapceTheme::LAPCE_DROPDOWN_SHADOW,
-                                ),
-                            );
-                        } else {
-                            ctx.stroke(
-                                Line::new(
-                                    Point::new(rect.x1 + 0.5, rect.y0),
-                                    Point::new(rect.x1 + 0.5, rect.y1),
-                                ),
-                                data.config
-                                    .get_color_unchecked(LapceTheme::LAPCE_BORDER),
-                                1.0,
-                            );
-                        }
-                        ctx.fill(rect, bg);
-                        panel.paint(ctx, data, env);
+        ctx.incr_alpha_depth();
+        if data
+            .panel
+            .is_container_shown(&PanelContainerPosition::Bottom)
+        {
+            self.panel_bottom.paint(ctx, data, env);
+        }
+        if data.panel.is_container_shown(&PanelContainerPosition::Left) {
+            self.panel_left.paint(ctx, data, env);
+        }
+        if data
+            .panel
+            .is_container_shown(&PanelContainerPosition::Right)
+        {
+            self.panel_right.paint(ctx, data, env);
+        }
+        if let Some(position) = self.current_bar_hover.as_ref() {
+            let (p0, p1) = match position {
+                PanelResizePosition::Left => {
+                    let rect = self.panel_left.layout_rect();
+                    if !data.panel.is_container_shown(&PanelContainerPosition::Left)
+                    {
+                        (Point::new(1.0, rect.y0), Point::new(1.0, rect.y1))
+                    } else {
+                        (
+                            Point::new(rect.x1.round(), rect.y0),
+                            Point::new(rect.x1.round(), rect.y1),
+                        )
                     }
                 }
-            }
+                PanelResizePosition::Right => {
+                    let rect = self.panel_right.layout_rect();
+                    if !data
+                        .panel
+                        .is_container_shown(&PanelContainerPosition::Right)
+                    {
+                        (
+                            Point::new(rect.x1 - 1.0, rect.y0),
+                            Point::new(rect.x1 - 1.0, rect.y1),
+                        )
+                    } else {
+                        (
+                            Point::new(rect.x0.round(), rect.y0),
+                            Point::new(rect.x0.round(), rect.y1),
+                        )
+                    }
+                }
+                PanelResizePosition::LeftSplit => {
+                    let rect = self.panel_left.layout_rect();
+                    (
+                        Point::new(rect.x1.round(), rect.y0),
+                        Point::new(rect.x1.round(), rect.y1),
+                    )
+                }
+                PanelResizePosition::Bottom => {
+                    let rect = self.panel_bottom.layout_rect();
+                    if !data
+                        .panel
+                        .is_container_shown(&PanelContainerPosition::Bottom)
+                    {
+                        let status_rect = self.status.layout_rect();
+                        (
+                            Point::new(rect.x0, status_rect.y0 - 1.0),
+                            Point::new(rect.x1, status_rect.y0 - 1.0),
+                        )
+                    } else {
+                        (
+                            Point::new(rect.x0, rect.y0.round()),
+                            Point::new(rect.x1, rect.y0.round()),
+                        )
+                    }
+                }
+            };
+            ctx.stroke(
+                Line::new(p0, p1),
+                data.config.get_color_unchecked(LapceTheme::EDITOR_CARET),
+                2.0,
+            );
         }
-        self.activity.paint(ctx, data, env);
-        // if let Some((active_index, (id, kind))) =
-        //     data.panels.get(&PanelPosition::LeftTop).and_then(|panel| {
-        //         panel
-        //             .widgets
-        //             .iter()
-        //             .enumerate()
-        //             .find(|(i, (id, kind))| id == &panel.active)
-        //     })
-        // {
-        //     let active_offset = 50.0 * active_index as f64;
-        //     let rect = Size::new(50.0, 50.0)
-        //         .to_rect()
-        //         .with_origin(Point::new(0.0, active_offset));
-        //     ctx.fill(
-        //         rect,
-        //         data.config
-        //             .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
-        //     );
-        //     // self.activity
-        //     //     .widget_mut()
-        //     //     .paint_svg(ctx, data, active_index, kind);
-        // }
+        self.title.paint(ctx, data, env);
         self.status.paint(ctx, data, env);
+        if data.rename.active {
+            let rect = self.rename.layout_rect();
+            let shadow_width = data.config.ui.drop_shadow_width() as f64;
+            if shadow_width > 0.0 {
+                ctx.blurred_rect(
+                    rect,
+                    shadow_width,
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                );
+            } else {
+                ctx.stroke(
+                    rect.inflate(0.5, 0.5),
+                    data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                    1.0,
+                );
+            }
+            ctx.fill(
+                rect,
+                data.config
+                    .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+            );
+            self.rename.paint(ctx, data, env);
+        }
         self.completion.paint(ctx, data, env);
+        self.signature.paint(ctx, data, env);
         self.hover.paint(ctx, data, env);
-        self.palette.paint(ctx, data, env);
         self.picker.paint(ctx, data, env);
-        self.settings.paint(ctx, data, env);
+        ctx.incr_alpha_depth();
+        self.paint_drag_on_panel(ctx, data);
         self.paint_drag(ctx, data);
+        ctx.incr_alpha_depth();
+        self.about.paint(ctx, data, env);
         self.alert.paint(ctx, data, env);
+        if self.message.widget().child().has_items() {
+            self.message.paint(ctx, data, env);
+        }
     }
 }
 
+/// The tab header of window tabs where you can click to focus and
+/// drag to re order them
+///
+/// Each window tab hosts a separate workspace, which gives you an alternative
+/// way to work with multiple workspaces.
 pub struct LapceTabHeader {
     pub drag_start: Option<(Point, Point)>,
     pub mouse_pos: Point,
     close_icon_rect: Rect,
+    holding_click_rect: Option<Rect>,
 }
 
 impl LapceTabHeader {
     pub fn new() -> Self {
         Self {
             close_icon_rect: Rect::ZERO,
+            holding_click_rect: None,
             drag_start: None,
             mouse_pos: Point::ZERO,
         }
@@ -1705,6 +2710,12 @@ impl LapceTabHeader {
     }
 }
 
+impl Default for LapceTabHeader {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Widget<LapceTabData> for LapceTabHeader {
     fn event(
         &mut self,
@@ -1725,31 +2736,73 @@ impl Widget<LapceTabData> for LapceTabHeader {
                 if self.close_icon_rect.contains(mouse_event.pos) {
                     ctx.set_cursor(&druid::Cursor::Pointer);
                 } else {
-                    ctx.set_cursor(&druid::Cursor::Arrow);
+                    ctx.clear_cursor();
                 }
             }
             Event::MouseDown(mouse_event) => {
-                if self.close_icon_rect.contains(mouse_event.pos) {
-                    ctx.submit_command(Command::new(
-                        LAPCE_UI_COMMAND,
-                        LapceUICommand::CloseTabId(data.id),
-                        Target::Auto,
-                    ));
-                } else {
-                    self.drag_start =
-                        Some((ctx.to_window(mouse_event.pos), ctx.window_origin()));
-                    self.mouse_pos = ctx.to_window(mouse_event.pos);
-                    ctx.set_active(true);
-                    ctx.submit_command(Command::new(
-                        LAPCE_UI_COMMAND,
-                        LapceUICommand::FocusTabId(data.id),
-                        Target::Auto,
-                    ));
+                if mouse_event.button.is_left() {
+                    if self.close_icon_rect.contains(mouse_event.pos) {
+                        self.holding_click_rect = Some(self.close_icon_rect);
+                    } else {
+                        self.drag_start = Some((
+                            ctx.to_window(mouse_event.pos),
+                            ctx.window_origin(),
+                        ));
+                        self.mouse_pos = ctx.to_window(mouse_event.pos);
+                        ctx.set_active(true);
+                        ctx.submit_command(Command::new(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::FocusTabId(data.id),
+                            Target::Auto,
+                        ));
+                    }
                 }
             }
-            Event::MouseUp(_mouse_event) => {
-                ctx.set_active(false);
-                self.drag_start = None;
+            Event::MouseUp(mouse_event) => {
+                if mouse_event.button.is_right() {
+                    let tab_id = data.id;
+                    let window_id = *data.window_id;
+
+                    let mut menu = druid::Menu::<LapceData>::new("Tab");
+                    let item = druid::MenuItem::new("Move Tab To a New Window")
+                        .on_activate(move |ctx, _data, _env| {
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::TabToWindow(window_id, tab_id),
+                                Target::Window(window_id),
+                            ));
+                        });
+                    menu = menu.entry(item);
+
+                    let item = druid::MenuItem::new("Close Tab").on_activate(
+                        move |ctx, _data, _env| {
+                            ctx.submit_command(Command::new(
+                                LAPCE_UI_COMMAND,
+                                LapceUICommand::CloseTabId(tab_id),
+                                Target::Auto,
+                            ));
+                        },
+                    );
+                    menu = menu.entry(item);
+                    ctx.show_context_menu::<LapceData>(
+                        menu,
+                        ctx.to_window(mouse_event.pos),
+                    )
+                } else {
+                    if self.close_icon_rect.contains(mouse_event.pos)
+                        && self.holding_click_rect.eq(&Some(self.close_icon_rect))
+                    {
+                        ctx.submit_command(Command::new(
+                            LAPCE_UI_COMMAND,
+                            LapceUICommand::CloseTabId(data.id),
+                            Target::Auto,
+                        ));
+                    }
+                    self.holding_click_rect = None;
+                    ctx.set_active(false);
+                    self.drag_start = None;
+                    ctx.request_layout();
+                }
             }
             _ => {}
         }
@@ -1786,8 +2839,8 @@ impl Widget<LapceTabData> for LapceTabHeader {
         let size = bc.max();
 
         let close_icon_width = size.height;
-        let padding = 4.0;
-        let origin = Point::new(size.width - close_icon_width, padding);
+        let padding = 9.0;
+        let origin = Point::new(size.width - 25.0, padding);
         self.close_icon_rect = Size::new(close_icon_width, close_icon_width)
             .to_rect()
             .inflate(-padding, -padding)
@@ -1797,27 +2850,46 @@ impl Widget<LapceTabData> for LapceTabHeader {
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
-        let dir = data
-            .workspace
-            .path
-            .as_ref()
-            .map(|p| {
-                let dir = p.file_name().unwrap_or(p.as_os_str()).to_string_lossy();
-                let dir = match &data.workspace.kind {
-                    LapceWorkspaceType::Local => dir.to_string(),
-                    LapceWorkspaceType::RemoteSSH(user, host) => {
-                        format!("{} [{}@{}]", dir, user, host)
-                    }
-                    LapceWorkspaceType::RemoteWSL => {
-                        format!("{dir} [wsl]")
-                    }
-                };
-                dir
-            })
-            .unwrap_or_else(|| "Lapce".to_string());
+        let tab_rect = ctx.size().to_rect();
+
+        if ctx.is_hot() || self.drag_start.is_some() {
+            // Currenlty, we only paint background for the hot tab to prevent showing
+            // overlapped content on drag. In the future, we might want to:
+            // - introduce a tab background color
+            // - introduce a hover color
+            ctx.fill(
+                tab_rect,
+                data.config
+                    .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+            );
+        }
+
+        const BORDER_PADDING: f64 = 8.0;
+
+        ctx.stroke(
+            Line::new(
+                Point::new(tab_rect.x0, tab_rect.y0 + BORDER_PADDING),
+                Point::new(tab_rect.x0, tab_rect.y1 - BORDER_PADDING),
+            ),
+            data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+            1.0,
+        );
+
+        ctx.stroke(
+            Line::new(
+                Point::new(tab_rect.x1, tab_rect.y0 + BORDER_PADDING),
+                Point::new(tab_rect.x1, tab_rect.y1 - BORDER_PADDING),
+            ),
+            data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+            1.0,
+        );
+
         let text_layout = ctx
             .text()
-            .new_text_layout(dir)
+            .new_text_layout(
+                workspace_title(&data.workspace)
+                    .unwrap_or_else(|| String::from("Lapce")),
+            )
             .font(
                 data.config.ui.font_family(),
                 data.config.ui.font_size() as f64,
@@ -1833,11 +2905,11 @@ impl Widget<LapceTabData> for LapceTabHeader {
         let size = ctx.size();
         let text_size = text_layout.size();
         let x = (size.width - text_size.width) / 2.0;
-        let y = (size.height - text_size.height) / 2.0;
+        let y = text_layout.y_offset(size.height);
         ctx.draw_text(&text_layout, Point::new(x, y));
 
-        if ctx.is_hot() {
-            let svg = get_svg("close.svg").unwrap();
+        if ctx.is_hot() || self.drag_start.is_some() {
+            let svg = data.config.ui_svg(LapceIcons::CLOSE);
             ctx.draw_svg(
                 &svg,
                 self.close_icon_rect,
diff --git a/lapce-ui/src/terminal.rs b/lapce-ui/src/terminal.rs
index 3c64e29afd..bae3650295 100644
--- a/lapce-ui/src/terminal.rs
+++ b/lapce-ui/src/terminal.rs
@@ -1,32 +1,40 @@
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
 
 use alacritty_terminal::{
-    grid::Dimensions,
-    index::{Direction, Side},
-    term::{cell::Flags, search::RegexSearch},
+    grid::{Dimensions, Scroll},
+    index::{Column, Direction, Line, Side},
+    selection::{Selection, SelectionType},
+    term::{cell::Flags, search::RegexSearch, Term},
 };
 use druid::{
-    piet::{Text, TextAttribute, TextLayout, TextLayoutBuilder},
-    BoxConstraints, Command, Data, Env, Event, EventCtx, FontWeight, LayoutCtx,
-    LifeCycle, LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect, RenderContext, Size,
-    Target, UpdateCtx, Widget, WidgetExt, WidgetId, WidgetPod,
+    piet::{PietTextLayout, Text, TextAttribute, TextLayout, TextLayoutBuilder},
+    widget::{Click, ControllerHost},
+    BoxConstraints, Command, Cursor, Data, Env, Event, EventCtx, FontWeight,
+    LayoutCtx, LifeCycle, LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect,
+    RenderContext, Size, Target, UpdateCtx, Widget, WidgetExt, WidgetId, WidgetPod,
 };
-use lapce_core::mode::Mode;
+use lapce_core::{mode::Mode, register::Clipboard};
 use lapce_data::{
-    command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::LapceTheme,
-    data::{FocusArea, LapceTabData, PanelKind},
-    split::SplitDirection,
-    terminal::{LapceTerminalData, LapceTerminalViewData},
+    command::{
+        CommandKind, LapceCommand, LapceUICommand, LapceWorkbenchCommand,
+        LAPCE_COMMAND, LAPCE_UI_COMMAND,
+    },
+    config::{LapceIcons, LapceTheme},
+    data::{FocusArea, LapceTabData},
+    document::SystemClipboard,
+    panel::PanelKind,
+    proxy::LapceProxy,
+    terminal::{EventProxy, LapceTerminalData, LapceTerminalViewData},
 };
 use lapce_rpc::terminal::TermId;
+use smallvec::SmallVec;
 use unicode_width::UnicodeWidthChar;
 
 use crate::{
-    panel::{LapcePanel, PanelHeaderKind},
-    scroll::LapcePadding,
+    panel::{LapcePanel, PanelHeaderKind, PanelSizing},
+    scroll::{LapcePadding, LapceScroll},
     split::LapceSplit,
-    svg::get_svg,
+    svg::LapceIconSvg,
     tab::LapceIcon,
 };
 
@@ -36,15 +44,35 @@ pub type TermConfig = alacritty_terminal::config::Config;
 /// where the shell is presented.
 pub struct TerminalPanel {
     widget_id: WidgetId,
-    split: WidgetPod<LapceTabData, LapceSplit>,
+    tabs: HashMap<WidgetId, WidgetPod<LapceTabData, LapceSplit>>,
+    header: WidgetPod<LapceTabData, LapceTerminalPanelHeader>,
 }
 
 impl TerminalPanel {
     pub fn new(data: &LapceTabData) -> Self {
-        let split = LapceSplit::new(data.terminal.split_id);
+        let tabs = data
+            .terminal
+            .tabs
+            .iter()
+            .map(|(term_tab_id, tab)| {
+                let mut split = LapceSplit::new(tab.split_id);
+                for (_, term_data) in tab.terminals.iter() {
+                    let term = LapceTerminalView::new(term_data);
+                    split = split.with_flex_child(
+                        term.boxed(),
+                        Some(term_data.widget_id),
+                        1.0,
+                        true,
+                    );
+                }
+                (*term_tab_id, WidgetPod::new(split))
+            })
+            .collect();
+        let header = WidgetPod::new(LapceTerminalPanelHeader::new());
         Self {
             widget_id: data.terminal.widget_id,
-            split: WidgetPod::new(split),
+            tabs,
+            header,
         }
     }
 
@@ -54,16 +82,32 @@ impl TerminalPanel {
             PanelKind::Terminal,
             data.terminal.widget_id,
             split_id,
-            SplitDirection::Vertical,
-            PanelHeaderKind::Simple("Terminal".into()),
             vec![(
                 split_id,
                 PanelHeaderKind::None,
                 Self::new(data).boxed(),
-                None,
+                PanelSizing::Flex(true),
             )],
         )
     }
+
+    fn handle_focus(&self, ctx: &mut EventCtx, data: &mut LapceTabData) {
+        if let Some(term) = data.terminal.active_terminal() {
+            ctx.submit_command(Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::Focus,
+                Target::Widget(term.widget_id),
+            ));
+        } else {
+            let terminal_panel = Arc::make_mut(&mut data.terminal);
+            terminal_panel.new_tab(
+                data.workspace.clone(),
+                data.proxy.clone(),
+                &data.config,
+                ctx.get_external_handle(),
+            );
+        }
+    }
 }
 
 impl Widget<LapceTabData> for TerminalPanel {
@@ -82,18 +126,82 @@ impl Widget<LapceTabData> for TerminalPanel {
             Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
                 let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
                 if let LapceUICommand::Focus = command {
-                    if !data.terminal.terminals.is_empty() {
-                        ctx.submit_command(Command::new(
-                            LAPCE_UI_COMMAND,
-                            LapceUICommand::Focus,
-                            Target::Widget(data.terminal.active),
-                        ));
-                    }
+                    self.handle_focus(ctx, data);
                 }
             }
             _ => (),
         }
-        self.split.event(ctx, event, data, env);
+        self.header.event(ctx, event, data, env);
+        for (tab_id, tab) in self.tabs.iter_mut() {
+            let active_id =
+                data.terminal.active_terminal_split().map(|s| &s.split_id);
+            if event.should_propagate_to_hidden() || Some(tab_id) == active_id {
+                tab.event(ctx, event, data, env);
+            }
+        }
+
+        // We're using SmallVec here because, strictly speaking, it's impossible to have more
+        // than one empty TerminalSplitData at the same time. Thus `SmallVec<[WidgetId; 1]>`
+        // will allow how to avoid unnecessary allocation and at the same time will not take
+        // up more space on the stack than necessary.
+        //
+        // Note: Here we are using a SmallVec instead of iterating directly with deletion, since
+        // that would require `Arc::make_mut` to be called every time, even if no changes were made.
+        let empty_tabs = data
+            .terminal
+            .tabs
+            .iter()
+            .filter(|(_, t)| t.terminals.is_empty())
+            .map(|(tab_id, _)| *tab_id)
+            .collect::<SmallVec<[WidgetId; 1]>>();
+
+        // We remove all empty entries, but at the same time it is necessary to synchronize
+        // changes in `data.terminal.tabs` with `data.terminal.tabs.tabs_order`.
+        // The `data.terminal.tabstabs_order` is a vector, so `removing` elements from it in
+        // a loop is inefficient due to shifting all elements to the left after each removal.
+        //
+        // Therefore, we first store the first `WidgetId` to be removed in the `id_to_remove`
+        // variable, and in the loop itself, instead of deleting, we will equate all the values
+        // to be removed to `id_to_remove`. After the loop, we simply rebuild the vector again,
+        // excluding all elements equal to `id_to_remove`.
+        //
+        // This will be equally effective with one removed element, and with more of them, as
+        // it will allow us to allocate a vector with the desired capacity only once.
+        if let Some(&id_to_remove) = empty_tabs.get(0) {
+            let removed_len = empty_tabs.len();
+
+            let terminal = Arc::make_mut(&mut data.terminal);
+            let tabs_order = Arc::make_mut(&mut terminal.tabs_order);
+            for tab_id in empty_tabs {
+                self.tabs.remove(&tab_id);
+                terminal.tabs.remove(&tab_id);
+
+                if let Some(id) = tabs_order.iter_mut().find(|id| *id == &tab_id) {
+                    *id = id_to_remove;
+                }
+            }
+            let mut new_order: Vec<WidgetId> =
+                Vec::with_capacity(tabs_order.len() - removed_len);
+            new_order.extend(tabs_order.iter().filter(|id| *id != &id_to_remove));
+            *tabs_order = new_order;
+
+            ctx.children_changed();
+
+            if tabs_order.is_empty() {
+                if data.panel.is_panel_visible(&PanelKind::Terminal) {
+                    Arc::make_mut(&mut data.panel).hide_panel(&PanelKind::Terminal);
+                }
+                if let Some(active) = *data.main_split.active_tab {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::Focus,
+                        Target::Widget(active),
+                    ));
+                }
+            } else {
+                self.handle_focus(ctx, data);
+            }
+        }
     }
 
     fn lifecycle(
@@ -103,7 +211,10 @@ impl Widget<LapceTabData> for TerminalPanel {
         data: &LapceTabData,
         env: &Env,
     ) {
-        self.split.lifecycle(ctx, event, data, env);
+        self.header.lifecycle(ctx, event, data, env);
+        for (_, tab) in self.tabs.iter_mut() {
+            tab.lifecycle(ctx, event, data, env);
+        }
     }
 
     fn update(
@@ -113,17 +224,56 @@ impl Widget<LapceTabData> for TerminalPanel {
         data: &LapceTabData,
         env: &Env,
     ) {
-        if data.terminal.terminals.is_empty() {
-            ctx.submit_command(Command::new(
-                LAPCE_UI_COMMAND,
-                LapceUICommand::InitTerminalPanel(true),
-                Target::Widget(data.terminal.split_id),
-            ));
+        self.header.update(ctx, data, env);
+        for (_, tab) in self.tabs.iter_mut() {
+            tab.update(ctx, data, env);
         }
         if !data.terminal.same(&old_data.terminal) {
+            if data.terminal.active_terminal_split().map(|s| &s.split_id)
+                != old_data
+                    .terminal
+                    .active_terminal_split()
+                    .map(|s| &s.split_id)
+            {
+                ctx.request_layout();
+            }
+            if data.terminal.tabs_order.same(&old_data.terminal.tabs_order) {
+                let mut changed = false;
+                for (tab_id, tab) in data.terminal.tabs.iter() {
+                    if !self.tabs.contains_key(tab_id) {
+                        changed = true;
+                        ctx.children_changed();
+                        let mut split = LapceSplit::new(tab.split_id);
+                        for (_, term_data) in tab.terminals.iter() {
+                            let term = LapceTerminalView::new(term_data);
+                            split = split.with_flex_child(
+                                term.boxed(),
+                                Some(term_data.widget_id),
+                                1.0,
+                                true,
+                            );
+                        }
+                        self.tabs.insert(*tab_id, WidgetPod::new(split));
+                    }
+                }
+                self.tabs.retain(|tab_id, _| {
+                    if !data.terminal.tabs.contains_key(tab_id) {
+                        changed = true;
+                        ctx.children_changed();
+                        return false;
+                    }
+                    true
+                });
+                if changed && !self.tabs.is_empty() {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::Focus,
+                        Target::Widget(self.widget_id),
+                    ));
+                }
+            }
             ctx.request_paint();
         }
-        self.split.update(ctx, data, env);
     }
 
     fn layout(
@@ -133,9 +283,28 @@ impl Widget<LapceTabData> for TerminalPanel {
         data: &LapceTabData,
         env: &Env,
     ) -> Size {
-        self.split.layout(ctx, bc, data, env);
-        self.split.set_origin(ctx, data, env, Point::ZERO);
-        bc.max()
+        let size = bc.max();
+
+        let header_size = self.header.layout(ctx, bc, data, env);
+        self.header.set_origin(ctx, data, env, Point::ZERO);
+        if let Some(tab) = data
+            .terminal
+            .active_terminal_split()
+            .and_then(|s| self.tabs.get_mut(&s.split_id))
+        {
+            tab.layout(
+                ctx,
+                &BoxConstraints::tight(Size::new(
+                    size.width,
+                    size.height - header_size.height,
+                )),
+                data,
+                env,
+            );
+            tab.set_origin(ctx, data, env, Point::new(0.0, header_size.height));
+        }
+
+        size
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
@@ -145,7 +314,599 @@ impl Widget<LapceTabData> for TerminalPanel {
             data.config
                 .get_color_unchecked(LapceTheme::TERMINAL_BACKGROUND),
         );
-        self.split.paint(ctx, data, env);
+        if let Some(tab) = data
+            .terminal
+            .active_terminal_split()
+            .and_then(|s| self.tabs.get_mut(&s.split_id))
+        {
+            tab.paint(ctx, data, env);
+        }
+        self.header.paint(ctx, data, env);
+    }
+}
+
+struct LapceTerminalPanelHeader {
+    content: WidgetPod<
+        LapceTabData,
+        LapceScroll<LapceTabData, LapceTerminalPanelHeaderContent>,
+    >,
+    icon: WidgetPod<
+        LapceTabData,
+        ControllerHost<
+            LapcePadding<LapceTabData, LapceIconSvg>,
+            Click<LapceTabData>,
+        >,
+    >,
+    icon_padding: f64,
+    mouse_pos: Point,
+}
+
+impl LapceTerminalPanelHeader {
+    fn new() -> Self {
+        let content = WidgetPod::new(
+            LapceScroll::new(LapceTerminalPanelHeaderContent::new())
+                .vertical_scroll_for_horizontal(),
+        );
+        let icon_padding = 4.0;
+        let icon = LapcePadding::new(4.0, LapceIconSvg::new(LapceIcons::ADD))
+            .controller(Click::new(|ctx, _data, _env| {
+                ctx.submit_command(Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Workbench(
+                            LapceWorkbenchCommand::NewTerminalTab,
+                        ),
+                        data: None,
+                    },
+                    Target::Auto,
+                ));
+            }));
+        Self {
+            content,
+            icon: WidgetPod::new(icon),
+            mouse_pos: Point::ZERO,
+            icon_padding,
+        }
+    }
+}
+
+impl Widget<LapceTabData> for LapceTerminalPanelHeader {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        if let Event::MouseMove(mouse_event) = event {
+            self.mouse_pos = mouse_event.pos;
+            if self.icon.layout_rect().contains(mouse_event.pos) {
+                ctx.set_cursor(&druid::Cursor::Pointer);
+            } else {
+                ctx.clear_cursor();
+            }
+        }
+        self.content.event(ctx, event, data, env);
+        self.icon.event(ctx, event, data, env);
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.content.lifecycle(ctx, event, data, env);
+        self.icon.lifecycle(ctx, event, data, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        _old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.content.update(ctx, data, env);
+        self.icon.update(ctx, data, env);
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let size = Size::new(bc.max().width, data.config.ui.header_height() as f64);
+
+        self.content.layout(
+            ctx,
+            &BoxConstraints::tight(Size::new(size.width - size.height, size.height)),
+            data,
+            env,
+        );
+        self.content.set_origin(ctx, data, env, Point::ZERO);
+
+        let icon_size = data.config.ui.icon_size() as f64;
+        self.icon.layout(
+            ctx,
+            &BoxConstraints::tight(Size::new(
+                icon_size + self.icon_padding * 2.0,
+                icon_size + self.icon_padding * 2.0,
+            )),
+            data,
+            env,
+        );
+        self.icon.set_origin(
+            ctx,
+            data,
+            env,
+            Point::new(
+                size.width - size.height
+                    + ((size.height - icon_size) / 2.0 - self.icon_padding),
+                (size.height - icon_size) / 2.0 - self.icon_padding,
+            ),
+        );
+
+        size
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        self.content.paint(ctx, data, env);
+
+        {
+            let scroll_offset = self.content.widget().offset().x;
+            let content_rect = self.content.layout_rect();
+            let child_size = self.content.widget().child_size();
+            if scroll_offset > 0.0 {
+                ctx.with_save(|ctx| {
+                    ctx.clip(content_rect);
+                    let rect = Rect::new(
+                        content_rect.x0 - 10.0,
+                        content_rect.y0 - 10.0,
+                        content_rect.x0,
+                        content_rect.y1 + 10.0,
+                    );
+                    ctx.blurred_rect(
+                        rect,
+                        4.0,
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                    );
+                });
+            }
+            if scroll_offset < child_size.width - content_rect.width() {
+                ctx.with_save(|ctx| {
+                    ctx.clip(content_rect);
+                    let rect = Rect::new(
+                        content_rect.x1,
+                        content_rect.y0 - 10.0,
+                        content_rect.x1 + 10.0,
+                        content_rect.y1 + 10.0,
+                    );
+                    ctx.blurred_rect(
+                        rect,
+                        4.0,
+                        data.config
+                            .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                    );
+                });
+            }
+        }
+
+        let icon_rect = self.icon.layout_rect();
+        if icon_rect.contains(self.mouse_pos) {
+            ctx.fill(
+                icon_rect,
+                &data
+                    .config
+                    .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                    .clone()
+                    .with_alpha(0.1),
+            );
+        }
+        self.icon.paint(ctx, data, env);
+
+        let size = ctx.size();
+        let rect = size.to_rect();
+        let shadow_width = data.config.ui.drop_shadow_width() as f64;
+        if shadow_width > 0.0 {
+            ctx.with_save(|ctx| {
+                ctx.clip(rect.inset((0.0, 0.0, 0.0, 50.0)));
+                ctx.blurred_rect(
+                    rect,
+                    shadow_width,
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                );
+            });
+        } else {
+            ctx.stroke(
+                druid::kurbo::Line::new(
+                    Point::new(rect.x0, rect.y1 + 0.5),
+                    Point::new(rect.x1, rect.y1 + 0.5),
+                ),
+                data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                1.0,
+            );
+        }
+    }
+}
+
+struct LapceTerminalPanelHeaderContent {
+    items: HashMap<
+        WidgetId,
+        WidgetPod<LapceTabData, LapceTerminalPanelHeaderContentItem>,
+    >,
+}
+
+impl LapceTerminalPanelHeaderContent {
+    fn new() -> Self {
+        Self {
+            items: HashMap::new(),
+        }
+    }
+}
+
+impl Widget<LapceTabData> for LapceTerminalPanelHeaderContent {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        for (_, item) in self.items.iter_mut() {
+            item.event(ctx, event, data, env);
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        for (_, item) in self.items.iter_mut() {
+            item.lifecycle(ctx, event, data, env);
+        }
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        if !data.terminal.same(&old_data.terminal) || self.items.is_empty() {
+            if !data.terminal.tabs.ptr_eq(&old_data.terminal.tabs) {
+                for (_, item) in self.items.iter_mut() {
+                    item.update(ctx, data, env);
+                }
+            }
+            if !data.terminal.tabs_order.same(&old_data.terminal.tabs_order)
+                || self.items.is_empty()
+            {
+                for (tab_id, tab) in data.terminal.tabs.iter() {
+                    if !self.items.contains_key(tab_id) {
+                        ctx.children_changed();
+                        self.items.insert(
+                            *tab_id,
+                            WidgetPod::new(
+                                LapceTerminalPanelHeaderContentItem::new(
+                                    tab.split_id,
+                                ),
+                            ),
+                        );
+                    }
+                }
+                self.items.retain(|tab_id, _| {
+                    if !data.terminal.tabs.contains_key(tab_id) {
+                        ctx.children_changed();
+                        return false;
+                    }
+                    true
+                });
+            }
+        }
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let mut total_width = 0.0;
+        for id in data.terminal.tabs_order.iter() {
+            if let Some(item) = self.items.get_mut(id) {
+                let size = item.layout(ctx, bc, data, env);
+                item.set_origin(ctx, data, env, Point::new(total_width, 0.0));
+                total_width += size.width;
+            }
+        }
+        Size::new(total_width, bc.max().height)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let active_index = data
+            .terminal
+            .active
+            .min(data.terminal.tabs_order.len().saturating_sub(1));
+        for (i, id) in data.terminal.tabs_order.iter().enumerate() {
+            if let Some(item) = self.items.get_mut(id) {
+                item.paint(ctx, data, env);
+                let rect = item.layout_rect();
+                let x = rect.x1;
+                let size = rect.size();
+                ctx.stroke(
+                    druid::kurbo::Line::new(
+                        Point::new(x - 0.5, (size.height * 0.8).round()),
+                        Point::new(
+                            x - 0.5,
+                            size.height - (size.height * 0.8).round(),
+                        ),
+                    ),
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_TAB_SEPARATOR),
+                    1.0,
+                );
+                if i == active_index {
+                    let stroke = if data.focus_area
+                        == FocusArea::Panel(PanelKind::Terminal)
+                    {
+                        data.config.get_color_unchecked(
+                            LapceTheme::LAPCE_TAB_ACTIVE_UNDERLINE,
+                        )
+                    } else {
+                        data.config.get_color_unchecked(
+                            LapceTheme::LAPCE_TAB_INACTIVE_UNDERLINE,
+                        )
+                    };
+                    ctx.stroke(
+                        druid::kurbo::Line::new(
+                            Point::new(rect.x0 + 2.0, rect.y1 - 1.0),
+                            Point::new(rect.x1 - 2.0, rect.y1 - 1.0),
+                        ),
+                        stroke,
+                        2.0,
+                    );
+                }
+            }
+        }
+    }
+}
+
+struct LapceTerminalPanelHeaderContentItem {
+    text_layout: Option<PietTextLayout>,
+    split_id: WidgetId,
+    padding: f64,
+    icon_padding: f64,
+    title_width: f64,
+    mouse_pos: Point,
+    icon: WidgetPod<
+        LapceTabData,
+        ControllerHost<
+            LapcePadding<LapceTabData, LapceIconSvg>,
+            Click<LapceTabData>,
+        >,
+    >,
+}
+
+impl LapceTerminalPanelHeaderContentItem {
+    fn new(split_id: WidgetId) -> Self {
+        let padding = 10.0;
+        let icon_padding = 4.0;
+        let icon = LapcePadding::new(4.0, LapceIconSvg::new(LapceIcons::CLOSE))
+            .controller(Click::new(move |ctx, _data, _env| {
+                ctx.submit_command(Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Workbench(
+                            LapceWorkbenchCommand::CloseTerminalTab,
+                        ),
+                        data: Some(serde_json::json!(split_id.to_usize())),
+                    },
+                    Target::Auto,
+                ));
+            }));
+        Self {
+            text_layout: None,
+            split_id,
+            mouse_pos: Point::ZERO,
+            padding,
+            icon_padding,
+            title_width: 120.0,
+            icon: WidgetPod::new(icon),
+        }
+    }
+}
+
+impl Widget<LapceTabData> for LapceTerminalPanelHeaderContentItem {
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        match event {
+            Event::MouseMove(mouse_event) => {
+                self.mouse_pos = mouse_event.pos;
+                ctx.set_cursor(&druid::Cursor::Pointer);
+            }
+            Event::MouseDown(mouse_event) => {
+                if !self.icon.layout_rect().contains(mouse_event.pos) {
+                    if let Some(i) = data
+                        .terminal
+                        .tabs_order
+                        .iter()
+                        .position(|t| t == &self.split_id)
+                    {
+                        let terminal = Arc::make_mut(&mut data.terminal);
+                        terminal.active = i;
+                    }
+                }
+            }
+            _ => (),
+        }
+        self.icon.event(ctx, event, data, env);
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.icon.lifecycle(ctx, event, data, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.icon.update(ctx, data, env);
+        let old_title = old_data
+            .terminal
+            .tabs
+            .get(&self.split_id)
+            .and_then(|t| t.active_terminal())
+            .map(|t| &t.title);
+        let new_title = data
+            .terminal
+            .tabs
+            .get(&self.split_id)
+            .and_then(|t| t.active_terminal())
+            .map(|t| &t.title);
+        if old_title != new_title {
+            ctx.request_layout();
+        }
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let text = match data
+            .terminal
+            .tabs
+            .get(&self.split_id)
+            .and_then(|t| t.active_terminal())
+            .map(|t| t.title.clone())
+        {
+            Some(title) => title,
+            None => return Size::new(0.0, bc.max().height),
+        };
+
+        let text_color = data
+            .config
+            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+            .clone();
+
+        self.text_layout = Some({
+            let text_layout = ctx
+                .text()
+                .new_text_layout(text.clone())
+                .font(
+                    data.config.ui.font_family(),
+                    data.config.ui.font_size() as f64,
+                )
+                .text_color(text_color.clone())
+                .build()
+                .unwrap();
+
+            if text_layout.layout.width() > self.title_width as f32 {
+                let ending = ctx
+                    .text()
+                    .new_text_layout("...")
+                    .font(
+                        data.config.ui.font_family(),
+                        data.config.ui.font_size() as f64,
+                    )
+                    .build()
+                    .unwrap();
+                let ending_width = ending.size().width;
+
+                let hit_point = text_layout.hit_test_point(Point::new(
+                    self.title_width - ending_width,
+                    0.0,
+                ));
+
+                ctx.text()
+                    .new_text_layout(format!("{}...", &text[..hit_point.idx]))
+                    .font(
+                        data.config.ui.font_family(),
+                        data.config.ui.font_size() as f64,
+                    )
+                    .text_color(text_color)
+                    .build()
+                    .unwrap()
+            } else {
+                text_layout
+            }
+        });
+
+        let height = bc.max().height;
+
+        let icon_size = data.config.ui.icon_size() as f64;
+        self.icon.layout(
+            ctx,
+            &BoxConstraints::tight(Size::new(
+                icon_size + self.icon_padding * 2.0,
+                icon_size + self.icon_padding * 2.0,
+            )),
+            data,
+            env,
+        );
+        self.icon.set_origin(
+            ctx,
+            data,
+            env,
+            Point::new(
+                self.padding + self.title_width + self.padding - self.icon_padding,
+                (height - icon_size) / 2.0 - self.icon_padding,
+            ),
+        );
+
+        let width = self.padding + self.title_width + icon_size + self.padding * 2.0;
+
+        Size::new(width, height)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let size = ctx.size();
+
+        let text_layout = self.text_layout.as_ref().unwrap();
+        ctx.draw_text(
+            text_layout,
+            Point::new(self.padding, text_layout.y_offset(size.height)),
+        );
+
+        let icon_rect = self.icon.layout_rect();
+        if icon_rect.contains(self.mouse_pos) {
+            ctx.fill(
+                icon_rect,
+                &data
+                    .config
+                    .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                    .clone()
+                    .with_alpha(0.1),
+            );
+        }
+        self.icon.paint(ctx, data, env);
     }
 }
 
@@ -211,84 +972,65 @@ impl Widget<LapceTabData> for LapceTerminalView {
         env: &Env,
     ) -> Size {
         let self_size = bc.max();
-        let header_size = self.header.layout(ctx, bc, data, env);
+        self.header.layout(ctx, bc, data, env);
         self.header.set_origin(ctx, data, env, Point::ZERO);
 
-        if self_size.height > header_size.height {
-            let terminal_size =
-                Size::new(self_size.width, self_size.height - header_size.height);
-            let bc = BoxConstraints::new(Size::ZERO, terminal_size);
-            self.terminal.layout(ctx, &bc, data, env);
-            self.terminal.set_origin(
-                ctx,
-                data,
-                env,
-                Point::new(0.0, header_size.height),
-            );
-        }
+        self.terminal.layout(ctx, bc, data, env);
+        self.terminal.set_origin(ctx, data, env, Point::ZERO);
 
         self_size
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
-        let self_rect = ctx.size().to_rect();
-        ctx.with_save(|ctx| {
-            ctx.clip(self_rect.inflate(0.0, 50.0));
-            let rect = self.header.layout_rect();
-            let shadow_width = data.config.ui.drop_shadow_width() as f64;
-            if shadow_width > 0.0 {
-                ctx.blurred_rect(
-                    rect,
-                    shadow_width,
-                    data.config
-                        .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
-                );
-            }
-            ctx.fill(
-                rect,
-                data.config
-                    .get_color_unchecked(LapceTheme::TERMINAL_BACKGROUND),
-            );
-        });
-
-        self.header.paint(ctx, data, env);
         self.terminal.paint(ctx, data, env);
+        self.header.paint(ctx, data, env);
     }
 }
 
 struct LapceTerminalHeader {
     term_id: TermId,
+    split_id: WidgetId,
     height: f64,
     icon_size: f64,
     icon_padding: f64,
     icons: Vec<LapceIcon>,
     mouse_pos: Point,
     view_is_hot: bool,
+    hover_rect: Option<Rect>,
 }
 
 impl LapceTerminalHeader {
     pub fn new(data: &LapceTerminalData) -> Self {
         Self {
             term_id: data.term_id,
+            split_id: data.split_id,
             height: 30.0,
             icon_size: 24.0,
             mouse_pos: Point::ZERO,
             icon_padding: 4.0,
             icons: Vec::new(),
             view_is_hot: false,
+            hover_rect: None,
         }
     }
 
     fn get_icons(&self, self_size: Size, data: &LapceTabData) -> Vec<LapceIcon> {
         let gap = (self.height - self.icon_size) / 2.0;
 
-        let terminal_data = data.terminal.terminals.get(&self.term_id).unwrap();
+        let terminal_data = data
+            .terminal
+            .tabs
+            .get(&self.split_id)
+            .unwrap()
+            .terminals
+            .get(&self.term_id)
+            .unwrap();
 
         let mut icons = Vec::new();
         let x =
             self_size.width - ((icons.len() + 1) as f64) * (gap + self.icon_size);
         let icon = LapceIcon {
-            icon: "close.svg",
+            icon: LapceIcons::CLOSE,
             rect: Size::new(self.icon_size, self.icon_size)
                 .to_rect()
                 .with_origin(Point::new(x, gap)),
@@ -303,7 +1045,7 @@ impl LapceTerminalHeader {
         let x =
             self_size.width - ((icons.len() + 1) as f64) * (gap + self.icon_size);
         let icon = LapceIcon {
-            icon: "split-horizontal.svg",
+            icon: LapceIcons::SPLIT_HORIZONTAL,
             rect: Size::new(self.icon_size, self.icon_size)
                 .to_rect()
                 .with_origin(Point::new(x, gap)),
@@ -318,9 +1060,10 @@ impl LapceTerminalHeader {
         icons
     }
 
-    fn icon_hit_test(&self, mouse_event: &MouseEvent) -> bool {
+    fn icon_hit_test(&mut self, mouse_event: &MouseEvent) -> bool {
         for icon in self.icons.iter() {
             if icon.rect.contains(mouse_event.pos) {
+                self.hover_rect = Some(icon.rect);
                 return true;
             }
         }
@@ -347,11 +1090,14 @@ impl Widget<LapceTabData> for LapceTerminalHeader {
         match event {
             Event::MouseMove(mouse_event) => {
                 self.mouse_pos = mouse_event.pos;
+                let hover_rect = self.hover_rect;
                 if self.icon_hit_test(mouse_event) {
                     ctx.set_cursor(&druid::Cursor::Pointer);
-                    ctx.request_paint();
                 } else {
+                    self.hover_rect = None;
                     ctx.clear_cursor();
+                }
+                if hover_rect != self.hover_rect {
                     ctx.request_paint();
                 }
             }
@@ -393,66 +1139,23 @@ impl Widget<LapceTabData> for LapceTerminalHeader {
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
-        let mut clip_rect = ctx.size().to_rect();
-        if self.view_is_hot {
-            if let Some(icon) = self.icons.iter().rev().next().as_ref() {
-                clip_rect.x1 = icon.rect.x0;
-            }
-        }
-
-        ctx.with_save(|ctx| {
-            ctx.clip(clip_rect);
-            let svg = get_svg("terminal.svg").unwrap();
-            let width = data.config.terminal_font_size() as f64;
-            let height = data.config.terminal_font_size() as f64;
-            let rect = Size::new(width, height).to_rect().with_origin(Point::new(
-                (self.height - width) / 2.0,
-                (self.height - height) / 2.0,
-            ));
-            ctx.draw_svg(
-                &svg,
-                rect,
-                Some(
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
-                ),
-            );
-
-            let term = data.terminal.terminals.get(&self.term_id).unwrap();
-            let text_layout = ctx
-                .text()
-                .new_text_layout(term.title.clone())
-                .font(
-                    data.config.ui.font_family(),
-                    data.config.ui.font_size() as f64,
-                )
-                .text_color(
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                        .clone(),
-                )
-                .build()
-                .unwrap();
-            let y = (self.height - text_layout.size().height) / 2.0;
-            ctx.draw_text(&text_layout, Point::new(self.height, y));
-        });
-
         if self.view_is_hot {
             for icon in self.icons.iter() {
                 if icon.rect.contains(self.mouse_pos) {
                     ctx.fill(
-                        &icon.rect,
+                        icon.rect,
                         data.config
                             .get_color_unchecked(LapceTheme::EDITOR_CURRENT_LINE),
                     );
                 }
-                if let Some(svg) = get_svg(icon.icon) {
+                {
+                    let svg = data.config.ui_svg(icon.icon);
                     ctx.draw_svg(
                         &svg,
                         icon.rect.inflate(-self.icon_padding, -self.icon_padding),
                         Some(
                             data.config
-                                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                                .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE),
                         ),
                     );
                 }
@@ -464,8 +1167,16 @@ impl Widget<LapceTabData> for LapceTerminalHeader {
 struct LapceTerminal {
     term_id: TermId,
     widget_id: WidgetId,
+    split_id: WidgetId,
     width: f64,
     height: f64,
+    proxy: Arc<LapceProxy>,
+}
+
+impl Drop for LapceTerminal {
+    fn drop(&mut self) {
+        self.proxy.proxy_rpc.terminal_close(self.term_id);
+    }
 }
 
 impl LapceTerminal {
@@ -473,6 +1184,8 @@ impl LapceTerminal {
         Self {
             term_id: data.term_id,
             widget_id: data.widget_id,
+            split_id: data.split_id,
+            proxy: data.proxy.clone(),
             width: 0.0,
             height: 0.0,
         }
@@ -480,15 +1193,46 @@ impl LapceTerminal {
 
     pub fn request_focus(&self, ctx: &mut EventCtx, data: &mut LapceTabData) {
         ctx.request_focus();
-        Arc::make_mut(&mut data.terminal).active = self.widget_id;
-        Arc::make_mut(&mut data.terminal).active_term_id = self.term_id;
-        data.focus = self.widget_id;
+        let terminal_split = Arc::make_mut(&mut data.terminal)
+            .active_terminal_split_mut()
+            .unwrap();
+        terminal_split.active = self.widget_id;
+        terminal_split.active_term_id = self.term_id;
+        data.focus = Arc::new(self.widget_id);
         data.focus_area = FocusArea::Panel(PanelKind::Terminal);
-        for (pos, panel) in data.panels.iter_mut() {
-            if panel.widgets.contains(&PanelKind::Terminal) {
-                Arc::make_mut(panel).active = PanelKind::Terminal;
-                data.panel_active = *pos;
-                break;
+        if let Some((index, position)) =
+            data.panel.panel_position(&PanelKind::Terminal)
+        {
+            let panel = Arc::make_mut(&mut data.panel);
+            if let Some(style) = panel.style.get_mut(&position) {
+                style.active = index;
+            }
+            panel.active = position;
+        }
+    }
+
+    fn select(
+        &self,
+        term: &mut Term<EventProxy>,
+        mouse_event: &MouseEvent,
+        ty: SelectionType,
+    ) {
+        let row_size = self.height / term.screen_lines() as f64;
+        let col_size = self.width / term.columns() as f64;
+        let offset = term.grid().display_offset();
+        let column = Column((mouse_event.pos.x / col_size) as usize);
+        let line = Line((mouse_event.pos.y / row_size) as i32 - offset as i32);
+        match &mut term.selection {
+            Some(selection) => selection.update(
+                alacritty_terminal::index::Point { line, column },
+                Direction::Left,
+            ),
+            None => {
+                term.selection = Some(Selection::new(
+                    ty,
+                    alacritty_terminal::index::Point { line, column },
+                    Direction::Left,
+                ));
             }
         }
     }
@@ -506,23 +1250,66 @@ impl Widget<LapceTabData> for LapceTerminal {
         data: &mut LapceTabData,
         env: &Env,
     ) {
-        let old_terminal_data =
-            data.terminal.terminals.get(&self.term_id).unwrap().clone();
+        let old_terminal_data = data
+            .terminal
+            .tabs
+            .get(&self.split_id)
+            .and_then(|split| split.terminals.get(&self.term_id).cloned());
+        let old_terminal_data = match old_terminal_data {
+            Some(t) => t,
+            None => return,
+        };
+
         let mut term_data = LapceTerminalViewData {
             terminal: old_terminal_data.clone(),
             config: data.config.clone(),
             find: data.find.clone(),
         };
+        ctx.set_cursor(&Cursor::IBeam);
         match event {
-            Event::MouseDown(_mouse_event) => {
+            Event::MouseDown(mouse_event) => {
                 self.request_focus(ctx, data);
+                let terminal = old_terminal_data.clone();
+                let term = &mut terminal.raw.lock().term;
+                if mouse_event.button.is_right() {
+                    let mut clipboard = SystemClipboard {};
+                    match term.selection_to_string() {
+                        Some(selection) => {
+                            clipboard.put_string(selection);
+                            term.selection = None;
+                        }
+                        None => {
+                            if let Some(string) = clipboard.get_string() {
+                                terminal.proxy.proxy_rpc.terminal_write(
+                                    terminal.term_id,
+                                    string.as_str(),
+                                );
+                                term.scroll_display(Scroll::Bottom);
+                            }
+                        }
+                    }
+                } else if mouse_event.button.is_left() {
+                    match mouse_event.count {
+                        2 => self.select(term, mouse_event, SelectionType::Semantic),
+                        _ => {
+                            term.selection = None;
+                            if mouse_event.count == 3 {
+                                self.select(term, mouse_event, SelectionType::Lines);
+                            }
+                        }
+                    }
+                }
+            }
+            Event::MouseMove(mouse_event) => {
+                if mouse_event.buttons.has_left() {
+                    let terminal = old_terminal_data.clone();
+                    let term = &mut terminal.raw.lock().term;
+                    self.select(term, mouse_event, SelectionType::Simple);
+                    ctx.request_paint();
+                }
             }
             Event::Wheel(wheel_event) => {
-                data.terminal
-                    .terminals
-                    .get(&self.term_id)
-                    .unwrap()
-                    .wheel_scroll(wheel_event.wheel_delta.y);
+                old_terminal_data.wheel_scroll(wheel_event.wheel_delta.y);
                 ctx.request_paint();
             }
             Event::KeyDown(key_event) => {
@@ -549,6 +1336,9 @@ impl Widget<LapceTabData> for LapceTerminal {
         }
         if !term_data.terminal.same(&old_terminal_data) {
             Arc::make_mut(&mut data.terminal)
+                .tabs
+                .get_mut(&self.split_id)
+                .unwrap()
                 .terminals
                 .insert(term_data.terminal.term_id, term_data.terminal.clone());
         }
@@ -586,7 +1376,7 @@ impl Widget<LapceTabData> for LapceTerminal {
         if self.width != size.width || self.height != size.height {
             self.width = size.width;
             self.height = size.height;
-            let width = data.config.editor_char_width(ctx.text());
+            let width = data.config.terminal_char_width(ctx.text());
             let line_height = data.config.terminal_line_height() as f64;
             let width = if width > 0.0 {
                 (self.width / width).floor() as usize
@@ -595,6 +1385,9 @@ impl Widget<LapceTabData> for LapceTerminal {
             };
             let height = (self.height / line_height).floor() as usize;
             data.terminal
+                .tabs
+                .get(&self.split_id)
+                .unwrap()
                 .terminals
                 .get(&self.term_id)
                 .unwrap()
@@ -604,12 +1397,18 @@ impl Widget<LapceTabData> for LapceTerminal {
     }
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, _env: &Env) {
-        let char_size = data.config.editor_text_size(ctx.text(), "W");
+        let char_size = data.config.terminal_text_size(ctx.text(), "W");
         let char_width = char_size.width;
         let line_height = data.config.terminal_line_height() as f64;
-        let y_shift = (line_height - char_size.height) / 2.0;
 
-        let terminal = data.terminal.terminals.get(&self.term_id).unwrap();
+        let terminal = data
+            .terminal
+            .tabs
+            .get(&self.split_id)
+            .unwrap()
+            .terminals
+            .get(&self.term_id)
+            .unwrap();
         let raw = terminal.raw.lock();
         let term = &raw.term;
         let content = term.renderable_content();
@@ -679,12 +1478,16 @@ impl Widget<LapceTabData> for LapceTerminal {
             let y =
                 (point.line.0 as f64 + content.display_offset as f64) * line_height;
 
-            let mut bg =
-                data.terminal
-                    .get_color(&cell.bg, content.colors, &data.config);
-            let mut fg =
-                data.terminal
-                    .get_color(&cell.fg, content.colors, &data.config);
+            let mut bg = data.terminal.tabs.get(&self.split_id).unwrap().get_color(
+                &cell.bg,
+                content.colors,
+                &data.config,
+            );
+            let mut fg = data.terminal.tabs.get(&self.split_id).unwrap().get_color(
+                &cell.fg,
+                content.colors,
+                &data.config,
+            );
             if cell.flags.contains(Flags::DIM)
                 || cell.flags.contains(Flags::DIM_BOLD)
             {
@@ -748,12 +1551,15 @@ impl Widget<LapceTabData> for LapceTerminal {
                         .default_attribute(TextAttribute::Weight(FontWeight::BOLD));
                 }
                 let text_layout = builder.build().unwrap();
-                ctx.draw_text(&text_layout, Point::new(x, y + y_shift));
+                ctx.draw_text(
+                    &text_layout,
+                    Point::new(x, y + text_layout.y_offset(line_height)),
+                );
             }
         }
         if data.find.visual {
             if let Some(search_string) = data.find.search_string.as_ref() {
-                if let Ok(dfas) = RegexSearch::new(search_string) {
+                if let Ok(dfas) = RegexSearch::new(&regex::escape(search_string)) {
                     let mut start = alacritty_terminal::index::Point::new(
                         alacritty_terminal::index::Line(
                             -(content.display_offset as i32),
diff --git a/lapce-ui/src/title.rs b/lapce-ui/src/title.rs
index ac7e922613..1b3b5b31ec 100644
--- a/lapce-ui/src/title.rs
+++ b/lapce-ui/src/title.rs
@@ -1,250 +1,201 @@
 use std::sync::Arc;
+use std::time::Duration;
 
-use crate::svg::get_svg;
 use druid::{
-    kurbo::Line,
-    piet::{Text, TextLayout, TextLayoutBuilder},
-    BoxConstraints, Color, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
-    LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect, RenderContext, Size, Target,
-    UpdateCtx, Widget,
+    kurbo::{Circle, Line},
+    piet::{PietText, PietTextLayout, Svg, Text, TextLayout, TextLayoutBuilder},
+    BoxConstraints, Color, Command, Env, Event, EventCtx, InternalEvent, LayoutCtx,
+    LifeCycle, LifeCycleCtx, MouseEvent, PaintCtx, Point, Rect, Region,
+    RenderContext, Size, Target, TimerToken, Widget, WidgetExt, WidgetId, WidgetPod,
+    WindowConfig, WindowState,
 };
-#[cfg(target_os = "macos")]
-use druid::{WindowConfig, WindowState};
+use lapce_core::{command::FocusCommand, meta};
 use lapce_data::{
     command::{
         CommandKind, LapceCommand, LapceUICommand, LapceWorkbenchCommand,
-        LAPCE_UI_COMMAND,
+        LAPCE_COMMAND, LAPCE_UI_COMMAND,
     },
-    config::LapceTheme,
-    data::{LapceWindowData, LapceWorkspaceType},
+    config::{LapceIcons, LapceTheme},
+    data::{FocusArea, LapceTabData, LapceWorkspaceType},
+    document::LocalBufferKind,
+    list::ListData,
     menu::{MenuItem, MenuKind},
+    palette::PaletteStatus,
     proxy::ProxyStatus,
 };
-use serde_json::json;
+use lapce_xi_rope::Rope;
+
+use crate::editor::view::LapceEditorView;
+#[cfg(not(target_os = "macos"))]
+use crate::window::window_controls;
+use crate::{list::List, palette::Palette};
 
 pub struct Title {
+    widget_id: WidgetId,
     mouse_pos: Point,
-    commands: Vec<(Rect, Command)>,
+    menus: Vec<(Rect, Command)>,
+    window_controls: Vec<(Rect, Command)>,
+    holding_click_rect: Option<Rect>,
+    svgs: Vec<(Svg, Rect, Option<Color>, Option<Color>)>,
+    text_layouts: Vec<(PietTextLayout, Point)>,
+    borders: Vec<Line>,
+    rects: Vec<(Rect, Color)>,
+    circles: Vec<(Circle, Color)>,
+    palette: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    branch_list: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    dragable_area: Region,
+    hover_rect: Option<Rect>,
 }
 
 impl Title {
-    pub fn new() -> Self {
+    pub fn new(data: &LapceTabData) -> Self {
+        let palette = Palette::new(data);
+        let branch_list = SourceControlBranches::new(data);
         Self {
+            widget_id: data.title.widget_id,
             mouse_pos: Point::ZERO,
-            commands: Vec::new(),
-        }
-    }
-
-    fn icon_hit_test(&self, mouse_event: &MouseEvent) -> bool {
-        for (rect, _) in self.commands.iter() {
-            if rect.contains(mouse_event.pos) {
-                return true;
-            }
+            menus: Vec::new(),
+            window_controls: Vec::new(),
+            holding_click_rect: None,
+            svgs: Vec::new(),
+            text_layouts: Vec::new(),
+            borders: Vec::new(),
+            rects: Vec::new(),
+            circles: Vec::new(),
+            palette: WidgetPod::new(palette.boxed()),
+            branch_list: WidgetPod::new(branch_list.boxed()),
+            dragable_area: Region::EMPTY,
+            hover_rect: None,
         }
-        false
     }
 
-    fn mouse_down(&self, ctx: &mut EventCtx, mouse_event: &MouseEvent) {
-        for (rect, command) in self.commands.iter() {
-            if rect.contains(mouse_event.pos) {
-                ctx.submit_command(command.clone());
-            }
-        }
-    }
-}
+    fn update_content(
+        &mut self,
+        data: &LapceTabData,
+        window_state: &WindowState,
+        #[cfg(not(target_os = "macos"))] _is_fullscreen: bool,
+        #[cfg(target_os = "macos")] is_fullscreen: bool,
+        piet_text: &mut PietText,
+        size: Size,
+    ) -> Rect {
+        self.menus.clear();
+        self.window_controls.clear();
+        self.svgs.clear();
+        self.text_layouts.clear();
+        self.borders.clear();
+        self.rects.clear();
+        self.circles.clear();
 
-impl Default for Title {
-    fn default() -> Self {
-        Self::new()
-    }
-}
+        #[cfg(not(target_os = "macos"))]
+        let mut x = 0.0;
+        #[cfg(target_os = "macos")]
+        let mut x = if data.multiple_tab || is_fullscreen {
+            0.0
+        } else {
+            78.0
+        };
 
-impl Widget<LapceWindowData> for Title {
-    fn event(
-        &mut self,
-        ctx: &mut EventCtx,
-        event: &Event,
-        #[cfg(target_os = "macos")] data: &mut LapceWindowData,
-        #[cfg(not(target_os = "macos"))] _data: &mut LapceWindowData,
-        _env: &Env,
-    ) {
-        match event {
-            Event::MouseMove(mouse_event) => {
-                self.mouse_pos = mouse_event.pos;
-                if self.icon_hit_test(mouse_event) {
-                    ctx.set_cursor(&druid::Cursor::Pointer);
-                    ctx.request_paint();
-                } else {
-                    ctx.clear_cursor();
-                    ctx.request_paint();
-                }
-            }
-            Event::MouseDown(mouse_event) => {
-                self.mouse_down(ctx, mouse_event);
-            }
-            #[cfg(target_os = "macos")]
-            Event::MouseUp(mouse_event) => {
-                if mouse_event.count >= 2 {
-                    let state = match ctx.window().get_window_state() {
-                        WindowState::Maximized => WindowState::Restored,
-                        WindowState::Restored => WindowState::Maximized,
-                        WindowState::Minimized => WindowState::Maximized,
-                    };
-                    ctx.submit_command(
-                        druid::commands::CONFIGURE_WINDOW
-                            .with(WindowConfig::default().set_window_state(state))
-                            .to(Target::Window(data.window_id)),
-                    )
-                }
-            }
-            _ => {}
+        #[cfg(not(target_os = "macos"))]
+        {
+            let logo_rect = Size::new(size.height, size.height)
+                .to_rect()
+                .with_origin(Point::new(x + 2.0, 0.0))
+                .inflate(-9.0, -9.0);
+            let logo_svg = data.config.logo_svg();
+            self.svgs.push((
+                logo_svg,
+                logo_rect,
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_DIM)
+                        .clone()
+                        .with_alpha(0.5),
+                ),
+                None,
+            ));
+            x += size.height;
         }
-    }
 
-    fn lifecycle(
-        &mut self,
-        _ctx: &mut LifeCycleCtx,
-        _event: &LifeCycle,
-        _data: &LapceWindowData,
-        _env: &Env,
-    ) {
-    }
+        let padding = 15.0;
+        x = self.update_remote(data, size, padding, x);
+        x = self.update_source_control(data, piet_text, size, padding, x);
 
-    fn update(
-        &mut self,
-        _ctx: &mut UpdateCtx,
-        _old_data: &LapceWindowData,
-        _data: &LapceWindowData,
-        _env: &Env,
-    ) {
-    }
+        let mut region = Region::EMPTY;
 
-    fn layout(
-        &mut self,
-        _ctx: &mut LayoutCtx,
-        bc: &BoxConstraints,
-        _data: &LapceWindowData,
-        _env: &Env,
-    ) -> Size {
-        Size::new(bc.max().width, 28.0)
-    }
+        if data.palette.status == PaletteStatus::Inactive {
+            self.update_folder(data, piet_text, size);
+        }
 
-    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceWindowData, _env: &Env) {
-        let size = ctx.size();
-        let rect = size.to_rect();
-        ctx.fill(
-            rect,
-            data.config
-                .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+        let right_x = size.width;
+        let right_x = self.update_settings(
+            data,
+            window_state,
+            piet_text,
+            size,
+            padding,
+            right_x,
         );
 
-        self.commands.clear();
+        if !data.multiple_tab {
+            region.add_rect(
+                Size::new(right_x - x, size.height)
+                    .to_rect()
+                    .with_origin(Point::new(x, 0.0)),
+            );
+        }
 
-        #[cfg(not(target_os = "macos"))]
-        let mut x = 0.0;
-        #[cfg(target_os = "macos")]
-        let mut x = 70.0;
+        self.dragable_area = region;
 
-        let padding = 15.0;
+        Size::new(right_x - x, size.height)
+            .to_rect()
+            .with_origin(Point::new(x, 0.0))
+    }
 
+    fn update_remote(
+        &mut self,
+        data: &LapceTabData,
+        size: Size,
+        _padding: f64,
+        x: f64,
+    ) -> f64 {
         let command_rect = Size::ZERO.to_rect().with_origin(Point::new(x, 0.0));
-        let tab = data.tabs.get(&data.active_id).unwrap();
-        let remote_text = match &tab.workspace.kind {
-            LapceWorkspaceType::Local => None,
-            LapceWorkspaceType::RemoteSSH(_, host) => {
-                let text = match *tab.proxy_status {
-                    ProxyStatus::Connecting => {
-                        format!("Connecting to SSH: {host} ...")
-                    }
-                    ProxyStatus::Connected => format!("SSH: {host}"),
-                    ProxyStatus::Disconnected => {
-                        format!("Disconnected SSH: {host}")
-                    }
-                };
-                let text_layout = ctx
-                    .text()
-                    .new_text_layout(text)
-                    .font(
-                        data.config.ui.font_family(),
-                        data.config.ui.font_size() as f64,
-                    )
-                    .text_color(
-                        data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
-                            .clone(),
-                    )
-                    .build()
-                    .unwrap();
-                Some(text_layout)
-            }
-            LapceWorkspaceType::RemoteWSL => {
-                let text = match *tab.proxy_status {
-                    ProxyStatus::Connecting => "Connecting to WSL ...".to_string(),
-                    ProxyStatus::Connected => "WSL".to_string(),
-                    ProxyStatus::Disconnected => "Disconnected WSL".to_string(),
-                };
-                let text_layout = ctx
-                    .text()
-                    .new_text_layout(text)
-                    .font(
-                        data.config.ui.font_family(),
-                        data.config.ui.font_size() as f64,
-                    )
-                    .text_color(
-                        data.config
-                            .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
-                            .clone(),
-                    )
-                    .build()
-                    .unwrap();
-                Some(text_layout)
-            }
-        };
 
-        let remote_rect = Size::new(
-            size.height
-                + 10.0
-                + remote_text
-                    .as_ref()
-                    .map(|t| t.size().width.round() + padding - 5.0)
-                    .unwrap_or(0.0),
-            size.height,
-        )
-        .to_rect()
-        .with_origin(Point::new(x, 0.0));
-        let color = match &tab.workspace.kind {
-            LapceWorkspaceType::Local => Color::rgb8(64, 120, 242),
-            LapceWorkspaceType::RemoteSSH(_, _) | LapceWorkspaceType::RemoteWSL => {
-                match *tab.proxy_status {
-                    ProxyStatus::Connecting => Color::rgb8(193, 132, 1),
-                    ProxyStatus::Connected => Color::rgb8(80, 161, 79),
-                    ProxyStatus::Disconnected => Color::rgb8(228, 86, 73),
-                }
-            }
+        let remote_rect = Size::new(size.height + 10.0, size.height)
+            .to_rect()
+            .with_origin(Point::new(x, 0.0));
+        let color = match &data.workspace.kind {
+            LapceWorkspaceType::Local => data
+                .config
+                .get_color_unchecked(LapceTheme::LAPCE_REMOTE_LOCAL),
+            // LapceWorkspaceType::Remote*
+            _ => match *data.proxy_status {
+                ProxyStatus::Connecting => data
+                    .config
+                    .get_color_unchecked(LapceTheme::LAPCE_REMOTE_CONNECTING),
+                ProxyStatus::Connected => data
+                    .config
+                    .get_color_unchecked(LapceTheme::LAPCE_REMOTE_CONNECTED),
+                ProxyStatus::Disconnected => data
+                    .config
+                    .get_color_unchecked(LapceTheme::LAPCE_REMOTE_DISCONNECTED),
+            },
         };
-        ctx.fill(remote_rect, &color);
-        let remote_svg = get_svg("remote.svg").unwrap();
-        ctx.draw_svg(
-            &remote_svg,
+        self.rects.push((remote_rect, color.clone()));
+        let remote_svg = data.config.ui_svg(LapceIcons::REMOTE);
+        self.svgs.push((
+            remote_svg,
             Size::new(size.height, size.height)
                 .to_rect()
                 .with_origin(Point::new(x + 5.0, 0.0))
                 .inflate(-5.0, -5.0),
             Some(
                 data.config
-                    .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+                    .get_color_unchecked(LapceTheme::LAPCE_REMOTE_ICON)
+                    .clone(),
             ),
-        );
-        if let Some(text_layout) = remote_text.as_ref() {
-            ctx.draw_text(
-                text_layout,
-                Point::new(
-                    x + size.height + 5.0,
-                    (size.height - text_layout.size().height) / 2.0,
-                ),
-            );
-        }
-        x += remote_rect.width();
+            None,
+        ));
+        let x = x + remote_rect.width();
         let command_rect =
             command_rect.with_size(Size::new(x - command_rect.x0, size.height));
 
@@ -254,19 +205,22 @@ impl Widget<LapceWindowData> for Title {
                 kind: CommandKind::Workbench(LapceWorkbenchCommand::ConnectSshHost),
                 data: None,
             },
+            enabled: true,
         })];
 
-        if cfg!(target_os = "windows") {
+        #[cfg(target_os = "windows")]
+        {
             menu_items.push(MenuKind::Item(MenuItem {
                 desc: None,
                 command: LapceCommand {
                     kind: CommandKind::Workbench(LapceWorkbenchCommand::ConnectWsl),
                     data: None,
                 },
+                enabled: true,
             }));
         }
 
-        if tab.workspace.kind.is_remote() {
+        if data.workspace.kind.is_remote() {
             menu_items.push(MenuKind::Item(MenuItem {
                 desc: None,
                 command: LapceCommand {
@@ -275,125 +229,61 @@ impl Widget<LapceWindowData> for Title {
                     ),
                     data: None,
                 },
+                enabled: true,
             }));
         }
 
-        self.commands.push((
+        self.menus.push((
             command_rect,
             Command::new(
                 LAPCE_UI_COMMAND,
                 LapceUICommand::ShowMenu(
-                    ctx.to_window(Point::new(command_rect.x0, command_rect.y1)),
-                    Arc::new(menu_items),
-                ),
-                Target::Auto,
-            ),
-        ));
-
-        let command_rect = Size::ZERO.to_rect().with_origin(Point::new(x, 0.0));
-
-        x += 5.0;
-        let folder_svg = get_svg("default_folder.svg").unwrap();
-        let folder_rect = Size::new(size.height, size.height)
-            .to_rect()
-            .with_origin(Point::new(x, 0.0));
-        ctx.draw_svg(
-            &folder_svg,
-            folder_rect.inflate(-5.0, -5.0),
-            Some(
-                data.config
-                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
-            ),
-        );
-        x += size.height;
-        let text = if let Some(workspace_path) = tab.workspace.path.as_ref() {
-            workspace_path
-                .file_name()
-                .unwrap_or(workspace_path.as_os_str())
-                .to_string_lossy()
-                .to_string()
-        } else {
-            "Open Folder".to_string()
-        };
-        let text_layout = ctx
-            .text()
-            .new_text_layout(text)
-            .font(
-                data.config.ui.font_family(),
-                data.config.ui.font_size() as f64,
-            )
-            .text_color(
-                data.config
-                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
-                    .clone(),
-            )
-            .build()
-            .unwrap();
-        ctx.draw_text(
-            &text_layout,
-            Point::new(x, (size.height - text_layout.size().height) / 2.0),
-        );
-        x += text_layout.size().width.round() + padding;
-        let menu_items = vec![
-            MenuKind::Item(MenuItem {
-                desc: None,
-                command: LapceCommand {
-                    kind: CommandKind::Workbench(LapceWorkbenchCommand::OpenFolder),
-                    data: None,
-                },
-            }),
-            MenuKind::Item(MenuItem {
-                desc: None,
-                command: LapceCommand {
-                    kind: CommandKind::Workbench(
-                        LapceWorkbenchCommand::PaletteWorkspace,
+                    Point::new(
+                        command_rect.x0,
+                        command_rect.y1 + if data.multiple_tab { 36.0 } else { 0.0 },
                     ),
-                    data: None,
-                },
-            }),
-        ];
-        let command_rect =
-            command_rect.with_size(Size::new(x - command_rect.x0, size.height));
-        self.commands.push((
-            command_rect,
-            Command::new(
-                LAPCE_UI_COMMAND,
-                LapceUICommand::ShowMenu(
-                    ctx.to_window(Point::new(command_rect.x0, command_rect.y1)),
                     Arc::new(menu_items),
                 ),
                 Target::Auto,
             ),
         ));
+        x
+    }
 
-        let line_color = data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER);
-        let line = Line::new(Point::new(x, 0.0), Point::new(x, size.height));
-        ctx.stroke(line, line_color, 1.0);
-
-        if !tab.source_control.branch.is_empty() {
+    fn update_source_control(
+        &mut self,
+        data: &LapceTabData,
+        piet_text: &mut PietText,
+        size: Size,
+        padding: f64,
+        x: f64,
+    ) -> f64 {
+        let mut x = x;
+        if !data.source_control.branch.is_empty() {
             let command_rect = Size::ZERO.to_rect().with_origin(Point::new(x, 0.0));
 
             x += 5.0;
-            let folder_svg = get_svg("git-icon.svg").unwrap();
+            let folder_svg = data.config.ui_svg(LapceIcons::SCM);
             let folder_rect = Size::new(size.height, size.height)
                 .to_rect()
                 .with_origin(Point::new(x, 0.0));
-            ctx.draw_svg(
-                &folder_svg,
-                folder_rect.inflate(-6.5, -6.5),
+            self.svgs.push((
+                folder_svg,
+                folder_rect.inflate(-10.5, -10.5),
                 Some(
                     data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                        .clone(),
                 ),
-            );
+                None,
+            ));
             x += size.height;
 
-            let mut branch = tab.source_control.branch.clone();
-            if !tab.source_control.file_diffs.is_empty() {
+            let mut branch = data.source_control.branch.clone();
+            if !data.source_control.file_diffs.is_empty() {
                 branch += "*";
             }
-            let text_layout = ctx
-                .text()
+            let text_layout = piet_text
                 .new_text_layout(branch)
                 .font(
                     data.config.ui.font_family(),
@@ -406,62 +296,82 @@ impl Widget<LapceWindowData> for Title {
                 )
                 .build()
                 .unwrap();
-            ctx.draw_text(
-                &text_layout,
-                Point::new(x, (size.height - text_layout.size().height) / 2.0),
-            );
+            let point =
+                Point::new(x, (size.height - text_layout.size().height) / 2.0);
             x += text_layout.size().width.round() + padding;
+            self.text_layouts.push((text_layout, point));
 
             let command_rect =
                 command_rect.with_size(Size::new(x - command_rect.x0, size.height));
-            let menu_items = tab
-                .source_control
-                .branches
-                .iter()
-                .map(|b| {
-                    MenuKind::Item(MenuItem {
-                        desc: Some(b.to_string()),
-                        command: LapceCommand {
-                            kind: CommandKind::Workbench(
-                                LapceWorkbenchCommand::CheckoutBranch,
-                            ),
-                            data: Some(json!(b.to_string())),
-                        },
-                    })
-                })
-                .collect();
-            self.commands.push((
+            let branches = data.source_control.branches.clone();
+            self.menus.push((
                 command_rect,
                 Command::new(
                     LAPCE_UI_COMMAND,
-                    LapceUICommand::ShowMenu(
-                        ctx.to_window(Point::new(command_rect.x0, command_rect.y1)),
-                        Arc::new(menu_items),
-                    ),
+                    LapceUICommand::ShowGitBranches {
+                        origin: Point::new(command_rect.x0, command_rect.y1),
+                        branches,
+                    },
                     Target::Auto,
                 ),
             ));
 
-            let line_color =
-                data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER);
-            let line = Line::new(Point::new(x, 0.0), Point::new(x, size.height));
-            ctx.stroke(line, line_color, 1.0);
+            self.borders.push(Line::new(
+                Point::new(command_rect.x1, command_rect.y0),
+                Point::new(command_rect.x1, command_rect.y1),
+            ));
+
+            x = command_rect.x1
+        }
+        x
+    }
+
+    fn update_settings(
+        &mut self,
+        data: &LapceTabData,
+        #[cfg(not(target_os = "macos"))] window_state: &WindowState,
+        #[cfg(target_os = "macos")] _window_state: &WindowState,
+        piet_text: &mut PietText,
+        size: Size,
+        _padding: f64,
+        x: f64,
+    ) -> f64 {
+        let mut x = x;
+        if cfg!(target_os = "macos")
+            || data.multiple_tab
+            || !data.config.core.custom_titlebar
+        {
+            x -= size.height;
+        } else {
+            x = size.width - (size.height * 4.0);
         }
 
-        x = size.width;
-        x -= size.height;
+        let offset = x;
+
         let settings_rect = Size::new(size.height, size.height)
             .to_rect()
             .with_origin(Point::new(x, 0.0));
-        let settings_svg = get_svg("settings.svg").unwrap();
-        ctx.draw_svg(
-            &settings_svg,
-            settings_rect.inflate(-7.0, -7.0),
+        let settings_svg = data.config.ui_svg(LapceIcons::SETTINGS);
+        self.svgs.push((
+            settings_svg,
+            settings_rect.inflate(-10.0, -10.0),
             Some(
                 data.config
-                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                    .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                    .clone(),
             ),
-        );
+            Some(
+                data.config.get_hover_color(
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
+                ),
+            ),
+        ));
+        let latest_version = data
+            .latest_release
+            .as_ref()
+            .as_ref()
+            .map(|r| r.version.as_str());
         let menu_items = vec![
             MenuKind::Item(MenuItem {
                 desc: None,
@@ -471,7 +381,9 @@ impl Widget<LapceWindowData> for Title {
                     ),
                     data: None,
                 },
+                enabled: true,
             }),
+            MenuKind::Separator,
             MenuKind::Item(MenuItem {
                 desc: None,
                 command: LapceCommand {
@@ -480,6 +392,7 @@ impl Widget<LapceWindowData> for Title {
                     ),
                     data: None,
                 },
+                enabled: true,
             }),
             MenuKind::Item(MenuItem {
                 desc: None,
@@ -489,21 +402,894 @@ impl Widget<LapceWindowData> for Title {
                     ),
                     data: None,
                 },
+                enabled: true,
+            }),
+            MenuKind::Separator,
+            MenuKind::Item(MenuItem {
+                desc: Some(if data.update_in_progress && latest_version.is_some() {
+                    format!("Update in progress ({}) ", latest_version.unwrap())
+                } else if latest_version.is_some()
+                    && latest_version != Some(*meta::VERSION)
+                {
+                    format!("Restart to update ({})", latest_version.unwrap())
+                } else {
+                    "No update available".to_string()
+                }),
+                command: LapceCommand {
+                    kind: CommandKind::Workbench(
+                        LapceWorkbenchCommand::RestartToUpdate,
+                    ),
+                    data: None,
+                },
+                enabled: latest_version.is_some()
+                    && latest_version != Some(*meta::VERSION)
+                    && !data.update_in_progress,
+            }),
+            MenuKind::Separator,
+            MenuKind::Item(MenuItem {
+                desc: None,
+                command: LapceCommand {
+                    kind: CommandKind::Workbench(LapceWorkbenchCommand::ShowAbout),
+                    data: None,
+                },
+                enabled: true,
             }),
         ];
-        self.commands.push((
+        if latest_version.is_some() && latest_version != Some(*meta::VERSION) {
+            let text_layout = piet_text
+                .new_text_layout("1")
+                .font(data.config.ui.font_family(), 10.0)
+                .text_color(
+                    data.config
+                        .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND)
+                        .clone(),
+                )
+                .build()
+                .unwrap();
+            let size = text_layout.size();
+            let point = settings_rect.center() + (5.0, 3.0);
+            let circle = Circle::new(
+                Point::new(point.x + size.width / 2.0, point.y + size.height / 2.0),
+                ((size.width / 2.0).powi(2) + (size.height / 2.0).powi(2)).sqrt(),
+            );
+            self.circles.push((
+                circle,
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_CARET)
+                    .clone(),
+            ));
+            self.text_layouts.push((text_layout, point));
+        }
+        self.menus.push((
             settings_rect,
             Command::new(
                 LAPCE_UI_COMMAND,
                 LapceUICommand::ShowMenu(
-                    ctx.to_window(Point::new(
-                        size.width - size.height,
-                        settings_rect.y1,
-                    )),
+                    Point::new(
+                        settings_rect.x0,
+                        settings_rect.y1
+                            + if data.multiple_tab { 36.0 } else { 0.0 },
+                    ),
                     Arc::new(menu_items),
                 ),
                 Target::Auto,
             ),
         ));
+
+        #[cfg(not(target_os = "macos"))]
+        if !data.multiple_tab && data.config.core.custom_titlebar {
+            x += size.height;
+            let (window_controls, svgs) = window_controls(
+                *data.window_id,
+                window_state,
+                x,
+                size.height,
+                &data.config,
+            );
+
+            for command in window_controls {
+                self.window_controls.push(command);
+            }
+
+            for (svg, rect, color) in svgs {
+                self.svgs.push((
+                    svg,
+                    rect,
+                    Some(
+                        data.config
+                            .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                            .clone(),
+                    ),
+                    Some(color),
+                ));
+            }
+        }
+
+        offset
+    }
+
+    fn update_folder(
+        &mut self,
+        data: &LapceTabData,
+        piet_text: &mut PietText,
+        size: Size,
+    ) {
+        let path = if let Some(workspace_path) = data.workspace.path.as_ref() {
+            workspace_path
+                .file_name()
+                .unwrap_or(workspace_path.as_os_str())
+                .to_string_lossy()
+                .to_string()
+        } else {
+            "Open Folder".to_string()
+        };
+        let remote = match &data.workspace.kind {
+            LapceWorkspaceType::Local => "".to_string(),
+            LapceWorkspaceType::RemoteSSH(ssh) => {
+                format!(" [SSH: {}]", ssh.host)
+            }
+            #[cfg(windows)]
+            LapceWorkspaceType::RemoteWSL => " [WSL]".to_string(),
+        };
+        let text = format!("{path}{remote}");
+        let text_layout = piet_text
+            .new_text_layout(text)
+            .font(
+                data.config.ui.font_family(),
+                data.config.ui.font_size() as f64,
+            )
+            .text_color(
+                data.config
+                    .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND)
+                    .clone(),
+            )
+            .build()
+            .unwrap();
+        let text_size = text_layout.size();
+        let x = (size.width - text_size.width) / 2.0;
+        let point = Point::new(x, (size.height - text_layout.size().height) / 2.0);
+        self.text_layouts.push((text_layout, point));
+
+        let folder_rect = Size::new(size.height, size.height)
+            .to_rect()
+            .with_origin(Point::new(x - size.height, 0.0));
+        let (folder_svg, folder_rect) = if data.workspace.path.is_none() {
+            (
+                data.config.ui_svg(LapceIcons::DIRECTORY_CLOSED),
+                folder_rect.inflate(-9.0, -9.0),
+            )
+        } else {
+            (
+                data.config.ui_svg(LapceIcons::SEARCH),
+                folder_rect.inflate(-12.0, -12.0),
+            )
+        };
+
+        self.svgs.push((
+            folder_svg,
+            folder_rect,
+            Some(
+                data.config
+                    .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                    .to_owned(),
+            ),
+            None,
+        ));
+        let menu_items = vec![
+            MenuKind::Item(MenuItem {
+                desc: None,
+                command: LapceCommand {
+                    kind: CommandKind::Workbench(LapceWorkbenchCommand::OpenFolder),
+                    data: None,
+                },
+                enabled: true,
+            }),
+            MenuKind::Item(MenuItem {
+                desc: None,
+                command: LapceCommand {
+                    kind: CommandKind::Workbench(
+                        LapceWorkbenchCommand::PaletteWorkspace,
+                    ),
+                    data: None,
+                },
+                enabled: true,
+            }),
+        ];
+        let command_rect = Size::new(size.height, size.height)
+            .to_rect()
+            .with_origin(Point::new(x + text_size.width - 8.0, 0.0));
+        self.svgs.push((
+            data.config.ui_svg(LapceIcons::PALETTE_MENU),
+            command_rect.inflate(-12.0, -12.0),
+            Some(
+                data.config
+                    .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                    .to_owned(),
+            ),
+            None,
+        ));
+        self.menus.push((
+            command_rect,
+            Command::new(
+                LAPCE_UI_COMMAND,
+                LapceUICommand::ShowMenu(
+                    Point::new(
+                        x,
+                        size.height + if data.multiple_tab { 36.0 } else { 0.0 },
+                    ),
+                    Arc::new(menu_items),
+                ),
+                Target::Auto,
+            ),
+        ));
+    }
+
+    fn icon_hit_test(&mut self, mouse_event: &MouseEvent) -> bool {
+        for (rect, _) in self.menus.iter() {
+            if rect.contains(mouse_event.pos) {
+                self.hover_rect = Some(*rect);
+                return true;
+            }
+        }
+        for (rect, _) in self.window_controls.iter() {
+            if rect.contains(mouse_event.pos) {
+                self.hover_rect = Some(*rect);
+                return true;
+            }
+        }
+        false
+    }
+
+    fn mouse_down(&mut self, ctx: &mut EventCtx, mouse_event: &MouseEvent) {
+        for (rect, command) in self.menus.iter() {
+            if rect.contains(mouse_event.pos) {
+                self.holding_click_rect = Some(*rect);
+                ctx.submit_command(command.clone());
+                ctx.set_handled();
+                return;
+            }
+        }
+        for (rect, _command) in self.window_controls.iter() {
+            if rect.contains(mouse_event.pos) {
+                self.holding_click_rect = Some(*rect);
+                ctx.set_handled();
+                return;
+            }
+        }
+    }
+
+    fn mouse_up(&self, ctx: &mut EventCtx, mouse_event: &MouseEvent) {
+        for (rect, command) in self.window_controls.iter() {
+            if rect.contains(mouse_event.pos)
+                && self.holding_click_rect.eq(&Some(*rect))
+            {
+                ctx.submit_command(command.clone());
+                ctx.set_handled();
+                return;
+            }
+        }
+    }
+}
+
+impl Widget<LapceTabData> for Title {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.widget_id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        match event {
+            Event::Internal(InternalEvent::MouseLeave) => {
+                self.mouse_pos = Point::ZERO;
+                ctx.request_paint();
+            }
+            Event::MouseMove(mouse_event) => {
+                self.mouse_pos = mouse_event.pos;
+                let hover_rect = self.hover_rect;
+                if self.icon_hit_test(mouse_event) {
+                    ctx.set_cursor(&druid::Cursor::Pointer);
+                    ctx.set_handled();
+                } else {
+                    self.hover_rect = None;
+                    ctx.clear_cursor();
+
+                    #[cfg(target_os = "windows")]
+                    // ! Currently implemented on Windows only
+                    if !data.multiple_tab
+                        && self
+                            .dragable_area
+                            .rects()
+                            .iter()
+                            .any(|r| r.contains(mouse_event.pos))
+                    {
+                        ctx.window().handle_titlebar(true);
+                    }
+                }
+                if hover_rect != self.hover_rect {
+                    ctx.request_paint();
+                }
+            }
+            Event::MouseDown(mouse_event) => {
+                if mouse_event.button.is_left() {
+                    self.mouse_down(ctx, mouse_event);
+                }
+            }
+            Event::MouseUp(mouse_event) => {
+                if !data.multiple_tab
+                    && mouse_event.count == 2
+                    && self
+                        .dragable_area
+                        .rects()
+                        .iter()
+                        .any(|r| r.contains(mouse_event.pos))
+                {
+                    let state = match ctx.window().get_window_state() {
+                        WindowState::Maximized => WindowState::Restored,
+                        WindowState::Restored => WindowState::Maximized,
+                        WindowState::Minimized => WindowState::Maximized,
+                    };
+                    ctx.set_handled();
+                    ctx.submit_command(
+                        druid::commands::CONFIGURE_WINDOW
+                            .with(WindowConfig::default().set_window_state(state))
+                            .to(Target::Window(*data.window_id)),
+                    );
+                    return;
+                }
+
+                if mouse_event.button.is_left() {
+                    self.mouse_up(ctx, mouse_event);
+                }
+
+                self.holding_click_rect = None;
+            }
+            _ => {}
+        }
+        self.palette.event(ctx, event, data, env);
+
+        if event.should_propagate_to_hidden() || data.title.branches.active {
+            self.branch_list.event(ctx, event, data, env);
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        self.palette.lifecycle(ctx, event, data, env);
+        self.branch_list.lifecycle(ctx, event, data, env);
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut druid::UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        if data.main_split.can_jump_location_forward()
+            != old_data.main_split.can_jump_location_forward()
+        {
+            ctx.request_layout();
+        }
+        if data.main_split.can_jump_location_backward()
+            != old_data.main_split.can_jump_location_backward()
+        {
+            ctx.request_layout();
+        }
+        if data.source_control.branch != old_data.source_control.branch {
+            ctx.request_layout();
+        }
+        self.palette.update(ctx, data, env);
+        self.branch_list.update(ctx, data, env);
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let window_state = ctx.window().get_window_state();
+        let remaining_rect = self.update_content(
+            data,
+            &window_state,
+            ctx.window().is_fullscreen(),
+            ctx.text(),
+            Size::new(bc.max().width, 36.0),
+        );
+
+        let remaining = bc.max().width
+            - (remaining_rect.x0.max(bc.max().width - remaining_rect.x1)) * 2.0
+            - 36.0 * 4.0;
+
+        let min_palette_width = if data.palette.status == PaletteStatus::Inactive {
+            100.0
+        } else {
+            300.0
+        };
+        let palette_width = remaining.min(500.0).max(min_palette_width);
+        let palette_size = self.palette.layout(
+            ctx,
+            &BoxConstraints::tight(Size::new(palette_width, bc.max().height)),
+            data,
+            env,
+        );
+        let palette_origin =
+            Point::new((bc.max().width - palette_size.width) / 2.0, 0.0);
+        self.palette.set_origin(ctx, data, env, palette_origin);
+        let palette_rect = self.palette.layout_rect();
+
+        // TODO: Let this be configurable
+        let bl_width = 200.0;
+        let bl_height = 500.0;
+        let bl_bc = BoxConstraints::tight(Size::new(bl_width, bl_height));
+        let _bl_size = self.branch_list.layout(ctx, &bl_bc, data, env);
+        self.branch_list
+            .set_origin(ctx, data, env, data.title.branches.origin);
+
+        let target = if let Some(active) = *data.main_split.active {
+            Target::Widget(active)
+        } else {
+            Target::Auto
+        };
+        let arrow_left_rect = Size::new(36.0, 36.0)
+            .to_rect()
+            .with_origin(Point::new(palette_origin.x - 36.0 - 36.0, 0.0));
+        let (arrow_left_svg_color, arrow_left_svg_hover_color) = if !data
+            .main_split
+            .can_jump_location_backward()
+        {
+            (
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_INACTIVE)
+                        .clone(),
+                ),
+                None,
+            )
+        } else {
+            self.menus.push((
+                arrow_left_rect,
+                Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Focus(FocusCommand::JumpLocationBackward),
+                        data: None,
+                    },
+                    target,
+                ),
+            ));
+            (
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                        .clone(),
+                ),
+                Some(
+                    data.config.get_hover_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+                    ),
+                ),
+            )
+        };
+        self.svgs.push((
+            data.config.ui_svg(LapceIcons::LOCATION_BACKWARD),
+            arrow_left_rect.inflate(-10.5, -10.5),
+            arrow_left_svg_color,
+            arrow_left_svg_hover_color,
+        ));
+
+        let arrow_right_rect = Size::new(36.0, 36.0)
+            .to_rect()
+            .with_origin(Point::new(palette_origin.x - 36.0, 0.0));
+        let (arrow_right_svg_color, arrow_right_svg_hover_color) = if !data
+            .main_split
+            .can_jump_location_forward()
+        {
+            (
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_INACTIVE)
+                        .clone(),
+                ),
+                None,
+            )
+        } else {
+            self.menus.push((
+                arrow_right_rect,
+                Command::new(
+                    LAPCE_COMMAND,
+                    LapceCommand {
+                        kind: CommandKind::Focus(FocusCommand::JumpLocationForward),
+                        data: None,
+                    },
+                    target,
+                ),
+            ));
+            (
+                Some(
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_ICON_ACTIVE)
+                        .clone(),
+                ),
+                Some(
+                    data.config.get_hover_color(
+                        data.config
+                            .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+                    ),
+                ),
+            )
+        };
+        self.svgs.push((
+            data.config.ui_svg(LapceIcons::LOCATION_FORWARD),
+            arrow_right_rect.inflate(-10.5, -10.5),
+            arrow_right_svg_color,
+            arrow_right_svg_hover_color,
+        ));
+
+        self.dragable_area.clear();
+        if !data.multiple_tab {
+            self.dragable_area.add_rect(Rect::new(
+                remaining_rect.x0,
+                0.0,
+                palette_rect.x0 - 36.0 * 2.0,
+                36.0,
+            ));
+            self.dragable_area.add_rect(Rect::new(
+                palette_rect.x1,
+                0.0,
+                remaining_rect.x1,
+                36.0,
+            ));
+            ctx.window().set_dragable_area(self.dragable_area.clone());
+        }
+
+        bc.max()
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let size = Size::new(ctx.size().width, 36.0);
+        let rect = size.to_rect();
+        ctx.fill(
+            rect,
+            data.config
+                .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+        );
+        ctx.stroke(
+            Line::new(
+                Point::new(rect.x0, rect.y1 + 0.5),
+                Point::new(rect.x1, rect.y1 + 0.5),
+            ),
+            data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+            1.0,
+        );
+
+        if data.palette.status == PaletteStatus::Inactive {
+            self.palette.paint(ctx, data, env);
+        }
+
+        for (rect, color) in self.rects.iter() {
+            ctx.fill(rect, color);
+        }
+
+        for (svg, rect, color, bg_color) in self.svgs.iter() {
+            let hover_rect = rect.inflate(10.0, 10.0);
+            if hover_rect.contains(self.mouse_pos)
+                && bg_color.is_some()
+                && (self.holding_click_rect.is_none()
+                    || self.holding_click_rect.unwrap().contains(self.mouse_pos))
+            {
+                let bg_color = bg_color.to_owned().unwrap();
+                ctx.fill(hover_rect, &bg_color);
+                ctx.draw_svg(
+                    svg,
+                    *rect,
+                    color
+                        .as_ref()
+                        .map(|color| data.config.get_hover_color(color))
+                        .as_ref(),
+                );
+            } else {
+                ctx.draw_svg(svg, *rect, color.as_ref());
+            }
+        }
+
+        for (circle, color) in self.circles.iter() {
+            ctx.fill(circle, color);
+        }
+
+        for (text_layout, point) in self.text_layouts.iter() {
+            ctx.draw_text(text_layout, *point);
+        }
+
+        for line in self.borders.iter() {
+            ctx.stroke(
+                line,
+                data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                1.0,
+            );
+        }
+
+        if data.palette.status != PaletteStatus::Inactive {
+            self.palette.paint(ctx, data, env);
+        }
+
+        if data.title.branches.active {
+            self.branch_list.paint(ctx, data, env);
+        }
+    }
+}
+
+// TODO: Implement an input for filtering the branches
+pub struct SourceControlBranches {
+    widget_id: WidgetId,
+    input: WidgetPod<LapceTabData, Box<dyn Widget<LapceTabData>>>,
+    list: WidgetPod<ListData<String, ()>, List<String, ()>>,
+    last_idle_timer: TimerToken,
+    branches: im::Vector<String>,
+}
+impl SourceControlBranches {
+    fn new(data: &LapceTabData) -> Self {
+        let widget_id = WidgetId::next();
+        let scroll_id = WidgetId::next();
+        Self {
+            widget_id,
+            input: WidgetPod::new(
+                LapceEditorView::new(
+                    data.title.branches.filter_editor,
+                    WidgetId::next(),
+                    None,
+                )
+                .hide_header()
+                .hide_gutter()
+                .hide_border()
+                .padding((5.0, 2.0, 5.0, 2.0))
+                .boxed(),
+            ),
+            list: WidgetPod::new(List::new(scroll_id)),
+            branches: im::Vector::new(),
+            last_idle_timer: TimerToken::INVALID,
+        }
+    }
+
+    fn request_focus(&self, ctx: &mut EventCtx, data: &mut LapceTabData) {
+        ctx.request_focus();
+        data.focus_area = FocusArea::BranchPicker;
+        data.focus = Arc::new(self.widget_id);
+    }
+}
+impl Widget<LapceTabData> for SourceControlBranches {
+    fn id(&self) -> Option<WidgetId> {
+        Some(self.widget_id)
+    }
+
+    fn event(
+        &mut self,
+        ctx: &mut EventCtx,
+        event: &Event,
+        data: &mut LapceTabData,
+        env: &Env,
+    ) {
+        self.input.event(ctx, event, data, env);
+        let title = Arc::make_mut(&mut data.title);
+        title.branches.list.update_data(data.config.clone());
+        self.list.event(ctx, event, &mut title.branches.list, env);
+
+        match event {
+            Event::Timer(token) if token == &self.last_idle_timer => {
+                log::warn!("title timer");
+                ctx.set_handled();
+                let editor_data =
+                    data.editor_view_content(data.title.branches.filter_editor);
+                let query = editor_data.doc.buffer().text().to_string();
+                log::warn!("title branches filter: {}", query);
+                let title = Arc::make_mut(&mut data.title);
+                title.branches.list.clear_items();
+                let filtered_branches = self
+                    .branches
+                    .iter()
+                    .filter(|branch| branch.contains(&query))
+                    .cloned();
+                title.branches.list.items = im::Vector::from_iter(filtered_branches);
+            }
+            Event::KeyDown(key_event) => {
+                let mut keypress = data.keypress.clone();
+                let title = Arc::make_mut(&mut data.title);
+                Arc::make_mut(&mut keypress).key_down(
+                    ctx,
+                    key_event,
+                    &mut title.branches,
+                    env,
+                );
+            }
+            Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
+                let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
+                match command {
+                    LapceUICommand::Hide => {
+                        Arc::make_mut(&mut data.title).branches.active = false;
+                    }
+                    LapceUICommand::Focus => {
+                        self.request_focus(ctx, data);
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::ShowGitBranches { origin, branches } => {
+                        let doc = data
+                            .main_split
+                            .local_docs
+                            .get_mut(&LocalBufferKind::BranchesFilter)
+                            .unwrap();
+                        Arc::make_mut(doc).reload(Rope::from(""), true);
+
+                        let title = Arc::make_mut(&mut data.title);
+                        title.branches.list.clear_items();
+                        self.branches = branches.clone();
+                        title.branches.list.items = branches.clone();
+                        title.branches.origin = *origin;
+
+                        // Make so the default selected entry is the current branch
+                        let current_branch = &data.source_control.branch;
+                        let current_item_index = title
+                            .branches
+                            .list
+                            .items
+                            .iter()
+                            .enumerate()
+                            .find(|(_, branch)| *branch == current_branch)
+                            .map(|(i, _)| i);
+                        title.branches.list.selected_index =
+                            current_item_index.unwrap_or(0);
+
+                        title.branches.active = true;
+
+                        self.request_focus(ctx, data);
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::ListItemSelected => {
+                        let title = Arc::make_mut(&mut data.title);
+                        if let Some(branch) =
+                            title.branches.list.current_selected_item()
+                        {
+                            ctx.submit_command(Command::new(
+                                LAPCE_COMMAND,
+                                LapceCommand {
+                                    kind: CommandKind::Workbench(
+                                        LapceWorkbenchCommand::CheckoutBranch,
+                                    ),
+                                    data: Some(serde_json::json!(branch.clone())),
+                                },
+                                Target::Auto,
+                            ));
+                        }
+
+                        title.branches.active = false;
+                    }
+                    _ => {}
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(
+        &mut self,
+        ctx: &mut LifeCycleCtx,
+        event: &LifeCycle,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        if let LifeCycle::FocusChanged(focus) = event {
+            if !focus && !&self.input.has_focus() {
+                ctx.submit_command(Command::new(
+                    LAPCE_UI_COMMAND,
+                    LapceUICommand::Hide,
+                    Target::Widget(self.widget_id),
+                ));
+            }
+        }
+        self.input.lifecycle(ctx, event, data, env);
+        self.list.lifecycle(
+            ctx,
+            event,
+            &data.title.branches.list.clone_with(data.config.clone()),
+            env,
+        );
+    }
+
+    fn update(
+        &mut self,
+        ctx: &mut druid::UpdateCtx,
+        old_data: &LapceTabData,
+        data: &LapceTabData,
+        env: &Env,
+    ) {
+        if data.title.branches.active != old_data.title.branches.active {
+            ctx.request_layout();
+        }
+
+        self.input.update(ctx, data, env);
+        self.list.update(
+            ctx,
+            &data.title.branches.list.clone_with(data.config.clone()),
+            env,
+        );
+
+        let editor_data =
+            data.editor_view_content(data.title.branches.filter_editor);
+        let old_editor_data =
+            old_data.editor_view_content(data.title.branches.filter_editor);
+        if editor_data.doc.buffer().len() != old_editor_data.doc.buffer().len()
+            || editor_data.doc.buffer().text().slice_to_cow(..)
+                != old_editor_data.doc.buffer().text().slice_to_cow(..)
+        {
+            self.last_idle_timer =
+                ctx.request_timer(Duration::from_millis(300), None);
+        }
+    }
+
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        data: &LapceTabData,
+        env: &Env,
+    ) -> Size {
+        let max_width = bc.max().width;
+        let max_height = bc.max().height;
+        let input_size = self.input.layout(
+            ctx,
+            &BoxConstraints::tight(Size::new(max_width, max_height)),
+            data,
+            env,
+        );
+        self.input.set_origin(ctx, data, env, Point::ZERO);
+        let list_data = &data.title.branches.list.clone_with(data.config.clone());
+        let list_size = self.list.layout(
+            ctx,
+            &BoxConstraints::tight(Size::new(
+                max_width,
+                max_height - input_size.height,
+            )),
+            list_data,
+            env,
+        );
+        // The moving of the origin is handled by the title widget which contains this
+        self.list.set_origin(
+            ctx,
+            list_data,
+            env,
+            Point::new(0.0, input_size.height),
+        );
+        Size::new(input_size.width, input_size.height + list_size.height)
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceTabData, env: &Env) {
+        let rect = ctx.size().to_rect();
+        ctx.stroke(
+            rect,
+            data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+            1.0,
+        );
+        ctx.fill(
+            rect,
+            data.config
+                .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
+        );
+        self.input.paint(ctx, data, env);
+        self.list.paint(
+            ctx,
+            &data.title.branches.list.clone_with(data.config.clone()),
+            env,
+        )
     }
 }
diff --git a/lapce-ui/src/window.rs b/lapce-ui/src/window.rs
index 234549595d..296bc33209 100644
--- a/lapce-ui/src/window.rs
+++ b/lapce-ui/src/window.rs
@@ -1,42 +1,45 @@
+use std::{cmp::Ordering, sync::Arc};
+
 use druid::{
     kurbo::Line,
     widget::{LensWrap, WidgetExt},
-    BoxConstraints, Command, Env, Event, EventCtx, LayoutCtx, LifeCycle,
-    LifeCycleCtx, PaintCtx, Point, RenderContext, Size, Target, Widget, WidgetId,
-    WidgetPod, WindowState,
+    BoxConstraints, Command, Data, Env, Event, EventCtx, InternalEvent, LayoutCtx,
+    LifeCycle, LifeCycleCtx, PaintCtx, Point, Rect, Region, RenderContext,
+    SingleUse, Size, Target, Widget, WidgetId, WidgetPod, WindowConfig, WindowState,
 };
 use lapce_data::{
     command::{LapceUICommand, LAPCE_UI_COMMAND},
-    config::{Config, LapceTheme},
+    config::{LapceConfig, LapceTheme},
     data::{LapceTabData, LapceTabLens, LapceWindowData, LapceWorkspace},
 };
-use std::cmp::Ordering;
-use std::sync::Arc;
+use lapce_rpc::plugin::VoltID;
 
-use crate::{
-    tab::{LapceTab, LapceTabHeader},
-    title::Title,
-};
+use crate::tab::{LapceTab, LapceTabHeader, LapceTabMeta, LAPCE_TAB_META};
 
 pub struct LapceWindow {
-    pub title: WidgetPod<LapceWindowData, Box<dyn Widget<LapceWindowData>>>,
+    pub mouse_pos: Point,
+    // pub title: WidgetPod<LapceWindowData, Box<dyn Widget<LapceWindowData>>>,
     pub tabs: Vec<WidgetPod<LapceWindowData, Box<dyn Widget<LapceWindowData>>>>,
-    tab_headers: Vec<
+    pub tab_headers: Vec<
         WidgetPod<
             LapceWindowData,
             LensWrap<LapceWindowData, LapceTabData, LapceTabLens, LapceTabHeader>,
         >,
     >,
+    pub draggable_area: Region,
+    pub tab_header_cmds: Vec<(Rect, Command)>,
+    pub mouse_down_cmd: Option<(Rect, Command)>,
+    #[cfg(not(target_os = "macos"))]
+    pub holding_click_rect: Option<Rect>,
 }
 
 impl LapceWindow {
-    pub fn new(data: &LapceWindowData) -> Self {
-        let title = WidgetPod::new(Title::new().boxed());
+    pub fn new(data: &mut LapceWindowData) -> Self {
         let tabs = data
             .tabs_order
             .iter()
             .map(|tab_id| {
-                let data = data.tabs.get(tab_id).unwrap();
+                let data = data.tabs.get_mut(tab_id).unwrap();
                 let tab = LapceTab::new(data);
                 let tab = tab.lens(LapceTabLens(*tab_id));
                 WidgetPod::new(tab.boxed())
@@ -51,9 +54,14 @@ impl LapceWindow {
             })
             .collect();
         Self {
-            title,
+            mouse_pos: Point::ZERO,
+            draggable_area: Region::EMPTY,
             tabs,
             tab_headers,
+            tab_header_cmds: Vec::new(),
+            mouse_down_cmd: None,
+            #[cfg(not(target_os = "macos"))]
+            holding_click_rect: None,
         }
     }
 
@@ -64,20 +72,31 @@ impl LapceWindow {
         workspace: LapceWorkspace,
         replace_current: bool,
     ) {
-        if replace_current {
+        let _ = data.db.update_recent_workspace(workspace.clone());
+
+        let current_panels = {
             let tab = data.tabs.get(&data.active_id).unwrap();
-            let _ = tab.db.save_workspace(tab);
-        }
+            if replace_current {
+                let _ = tab.db.save_workspace(tab);
+            }
+            (*tab.panel).clone()
+        };
+
         let tab_id = WidgetId::next();
-        let tab_data = LapceTabData::new(
+        let mut tab_data = LapceTabData::new(
             data.window_id,
             tab_id,
             workspace,
             data.db.clone(),
             data.keypress.clone(),
+            data.latest_release.clone(),
+            data.update_in_progress,
+            data.log_file.clone(),
+            Some(current_panels),
+            data.panel_orders.clone(),
             ctx.get_external_handle(),
         );
-        let tab = LapceTab::new(&tab_data).lens(LapceTabLens(tab_id));
+        let tab = LapceTab::new(&mut tab_data).lens(LapceTabLens(tab_id));
         let tab_header = LapceTabHeader::new().lens(LapceTabLens(tab_id));
         data.tabs.insert(tab_id, tab_data);
         if replace_current {
@@ -86,19 +105,19 @@ impl LapceWindow {
             if let Some(tab) = data.tabs.remove(&data.active_id) {
                 tab.proxy.stop();
             }
-            data.active_id = tab_id;
+            data.active_id = Arc::new(tab_id);
         } else {
             self.tabs
                 .insert(data.active + 1, WidgetPod::new(tab.boxed()));
             self.tab_headers
                 .insert(data.active + 1, WidgetPod::new(tab_header));
             data.active += 1;
-            data.active_id = tab_id;
+            data.active_id = Arc::new(tab_id);
         }
         ctx.submit_command(Command::new(
             LAPCE_UI_COMMAND,
             LapceUICommand::Focus,
-            Target::Widget(data.active_id),
+            Target::Widget(*data.active_id),
         ));
         data.tabs_order = Arc::new(self.tabs.iter().map(|t| t.id()).collect());
         let _ = data.db.save_tabs_async(data);
@@ -112,17 +131,25 @@ impl LapceWindow {
         ctx: &mut EventCtx,
         data: &mut LapceWindowData,
         index: usize,
-    ) {
+        stop_proxy: bool,
+    ) -> Option<LapceTabMeta> {
+        let mut removed_tab = None;
         if data.tabs.len() == 1 {
-            return;
+            return removed_tab;
         }
 
         let id = self.tabs[index].id();
-        self.tabs.remove(index);
+        let tab_widget = self.tabs.remove(index);
         self.tab_headers.remove(index);
         if let Some(tab) = data.tabs.remove(&id) {
             let _ = tab.db.save_workspace(&tab);
-            tab.proxy.stop();
+            if stop_proxy {
+                tab.proxy.stop();
+            }
+            removed_tab = Some(LapceTabMeta {
+                data: tab,
+                widget: tab_widget,
+            });
         }
 
         match data.active.cmp(&index) {
@@ -131,11 +158,11 @@ impl LapceWindow {
                 if data.active >= self.tabs.len() {
                     data.active = self.tabs.len() - 1;
                 }
-                data.active_id = self.tabs[data.active].id();
+                data.active_id = Arc::new(self.tabs[data.active].id());
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
                     LapceUICommand::Focus,
-                    Target::Widget(data.active_id),
+                    Target::Widget(*data.active_id),
                 ));
             }
             _ => (),
@@ -146,6 +173,8 @@ impl LapceWindow {
         ctx.children_changed();
         ctx.set_handled();
         ctx.request_layout();
+
+        removed_tab
     }
 
     pub fn close_tab_id(
@@ -153,17 +182,18 @@ impl LapceWindow {
         ctx: &mut EventCtx,
         data: &mut LapceWindowData,
         tab_id: WidgetId,
-    ) {
+        stop_proxy: bool,
+    ) -> Option<LapceTabMeta> {
         for (i, tab) in self.tabs.iter().enumerate() {
             if tab_id == tab.id() {
-                self.close_index_tab(ctx, data, i);
-                return;
+                return self.close_index_tab(ctx, data, i, stop_proxy);
             }
         }
+        None
     }
 
     pub fn close_tab(&mut self, ctx: &mut EventCtx, data: &mut LapceWindowData) {
-        self.close_index_tab(ctx, data, data.active);
+        self.close_index_tab(ctx, data, data.active, true);
     }
 }
 
@@ -192,33 +222,133 @@ impl Widget<LapceWindowData> for LapceWindow {
                 ctx.submit_command(Command::new(
                     LAPCE_UI_COMMAND,
                     LapceUICommand::Focus,
-                    Target::Widget(data.active_id),
+                    Target::Widget(*data.active_id),
                 ));
             }
+            Event::Internal(InternalEvent::MouseLeave) => {
+                self.mouse_pos = Point::ZERO;
+                ctx.request_paint();
+            }
+            Event::MouseMove(mouse_event) => {
+                ctx.clear_cursor();
+                self.mouse_pos = mouse_event.pos;
+
+                #[cfg(not(target_os = "macos"))]
+                if data.tabs.len() > 1 && mouse_event.count < 2 {
+                    for (rect, _) in self.tab_header_cmds.iter() {
+                        if rect.contains(mouse_event.pos) {
+                            ctx.set_cursor(&druid::Cursor::Pointer);
+                            ctx.request_paint();
+                            break;
+                        }
+                    }
+                }
+
+                #[cfg(target_os = "windows")]
+                if data.tabs.len() > 1
+                    && self
+                        .draggable_area
+                        .rects()
+                        .iter()
+                        .any(|r| r.contains(mouse_event.pos))
+                {
+                    ctx.window().handle_titlebar(true);
+                }
+            }
+            Event::MouseDown(_mouse_event) => {
+                self.mouse_down_cmd = None;
+                #[cfg(not(target_os = "macos"))]
+                if (data.tabs.len() > 1 && _mouse_event.count == 1)
+                    || data.config.core.custom_titlebar
+                {
+                    for (rect, cmd) in self.tab_header_cmds.iter() {
+                        if rect.contains(_mouse_event.pos) {
+                            self.mouse_down_cmd = Some((*rect, cmd.clone()));
+                            self.holding_click_rect = Some(*rect);
+                            break;
+                        }
+                    }
+                }
+            }
+            Event::MouseUp(mouse_event) => {
+                if data.tabs.len() > 1
+                    && mouse_event.count == 2
+                    && self
+                        .draggable_area
+                        .rects()
+                        .iter()
+                        .any(|r| r.contains(mouse_event.pos))
+                {
+                    let state = match ctx.window().get_window_state() {
+                        WindowState::Maximized => WindowState::Restored,
+                        WindowState::Restored => WindowState::Maximized,
+                        WindowState::Minimized => WindowState::Maximized,
+                    };
+                    ctx.submit_command(
+                        druid::commands::CONFIGURE_WINDOW
+                            .with(WindowConfig::default().set_window_state(state))
+                            .to(Target::Window(data.window_id)),
+                    )
+                }
+
+                #[cfg(not(target_os = "macos"))]
+                if (data.tabs.len() > 1 && mouse_event.count < 2)
+                    || data.config.core.custom_titlebar
+                {
+                    if let Some((rect, cmd)) = self.mouse_down_cmd.as_ref() {
+                        if rect.contains(mouse_event.pos) {
+                            ctx.submit_command(cmd.clone());
+                        }
+                    }
+
+                    for (rect, cmd) in self.tab_header_cmds.iter() {
+                        if let Some(click_rect) = self.holding_click_rect {
+                            if rect.contains(mouse_event.pos)
+                                && click_rect.contains(mouse_event.pos)
+                            {
+                                ctx.submit_command(cmd.clone());
+                                ctx.set_handled();
+                            }
+                        }
+                    }
+
+                    self.holding_click_rect = None;
+                }
+            }
             Event::Command(cmd) if cmd.is(LAPCE_UI_COMMAND) => {
                 let command = cmd.get_unchecked(LAPCE_UI_COMMAND);
                 match command {
-                    LapceUICommand::UpdatePluginDescriptions(plugins) => {
-                        data.plugins = Arc::new(plugins.to_owned());
-                    }
                     LapceUICommand::Focus => {
                         ctx.submit_command(Command::new(
                             LAPCE_UI_COMMAND,
                             LapceUICommand::Focus,
-                            Target::Widget(data.active_id),
+                            Target::Widget(*data.active_id),
                         ));
                         ctx.set_handled();
                     }
                     LapceUICommand::ReloadConfig => {
-                        data.config = Arc::new(
-                            Config::load(&LapceWorkspace::default())
-                                .unwrap_or_default(),
-                        );
+                        data.config = Arc::new(LapceConfig::load(
+                            &LapceWorkspace::default(),
+                            &[],
+                        ));
                         for (_, tab) in data.tabs.iter_mut() {
-                            tab.config = Arc::new(
-                                Config::load(&tab.workspace.clone())
-                                    .unwrap_or_default(),
+                            let mut disabled_volts: Vec<VoltID> =
+                                tab.plugin.disabled.clone().into_iter().collect();
+                            disabled_volts.append(
+                                &mut tab
+                                    .plugin
+                                    .workspace_disabled
+                                    .clone()
+                                    .into_iter()
+                                    .collect(),
                             );
+                            tab.config = Arc::new(LapceConfig::load(
+                                &tab.workspace.clone(),
+                                &disabled_volts,
+                            ));
+                            tab.proxy
+                                .proxy_rpc
+                                .update_plugin_configs(data.config.plugins.clone());
                         }
                         Arc::make_mut(&mut data.keypress)
                             .update_keymaps(&data.config);
@@ -232,41 +362,54 @@ impl Widget<LapceWindowData> for LapceWindow {
                         return;
                     }
                     LapceUICommand::SetWorkspace(workspace) => {
-                        let mut workspaces =
-                            Config::recent_workspaces().unwrap_or_default();
-
-                        let mut exits = false;
-                        for w in workspaces.iter_mut() {
-                            if w.path == workspace.path && w.kind == workspace.kind {
-                                w.last_open = std::time::SystemTime::now()
-                                    .duration_since(std::time::UNIX_EPOCH)
-                                    .unwrap()
-                                    .as_secs();
-                                exits = true;
-                            }
-                        }
-                        if !exits {
-                            workspaces.push(workspace.clone());
-                        }
-                        workspaces.sort_by_key(|w| -(w.last_open as i64));
-                        Config::update_recent_workspaces(workspaces);
-
                         self.new_tab(ctx, data, workspace.clone(), true);
                         return;
                     }
-                    LapceUICommand::SetTheme(theme, preview) => {
+                    LapceUICommand::SetColorTheme { theme, preview } => {
                         let config = Arc::make_mut(&mut data.config);
-                        config.set_theme(theme, *preview);
-                        if *preview {
-                            for (_, tab) in data.tabs.iter_mut() {
-                                Arc::make_mut(&mut tab.config)
-                                    .set_theme(theme, true);
-                            }
+                        config.set_color_theme(
+                            &LapceWorkspace::default(),
+                            theme,
+                            *preview,
+                        );
+                        for (_, tab) in data.tabs.iter_mut() {
+                            Arc::make_mut(&mut tab.config).set_color_theme(
+                                &tab.workspace,
+                                theme,
+                                true,
+                            );
                         }
                         ctx.set_handled();
                     }
-                    LapceUICommand::NewTab => {
-                        self.new_tab(ctx, data, LapceWorkspace::default(), false);
+                    LapceUICommand::SetIconTheme { theme, preview } => {
+                        let config = Arc::make_mut(&mut data.config);
+                        config.set_icon_theme(
+                            &LapceWorkspace::default(),
+                            theme,
+                            *preview,
+                        );
+                        for (_, tab) in data.tabs.iter_mut() {
+                            Arc::make_mut(&mut tab.config).set_icon_theme(
+                                &tab.workspace,
+                                theme,
+                                true,
+                            );
+                        }
+                        ctx.set_handled();
+                    }
+                    LapceUICommand::ShowWindow => {
+                        ctx.set_handled();
+                        ctx.submit_command(druid::commands::SHOW_WINDOW);
+                        return;
+                    }
+                    LapceUICommand::NewTab(workspace) => {
+                        ctx.set_handled();
+                        self.new_tab(
+                            ctx,
+                            data,
+                            workspace.clone().unwrap_or_default(),
+                            false,
+                        );
                         return;
                     }
                     LapceUICommand::CloseTab => {
@@ -274,7 +417,19 @@ impl Widget<LapceWindowData> for LapceWindow {
                         return;
                     }
                     LapceUICommand::CloseTabId(tab_id) => {
-                        self.close_tab_id(ctx, data, *tab_id);
+                        self.close_tab_id(ctx, data, *tab_id, true);
+                        return;
+                    }
+                    LapceUICommand::TabToWindow(_, tab_id) => {
+                        if let Some(meta) =
+                            self.close_tab_id(ctx, data, *tab_id, false)
+                        {
+                            ctx.submit_command(Command::new(
+                                LAPCE_TAB_META,
+                                SingleUse::new(meta),
+                                Target::Global,
+                            ))
+                        }
                         return;
                     }
                     LapceUICommand::FocusTabId(tab_id) => {
@@ -282,12 +437,12 @@ impl Widget<LapceWindowData> for LapceWindow {
                             if tab_id == &tab.id() {
                                 if i != data.active {
                                     data.active = i;
-                                    data.active_id = tab.id();
+                                    data.active_id = Arc::new(tab.id());
                                     let _ = data.db.save_tabs_async(data);
                                     ctx.submit_command(Command::new(
                                         LAPCE_UI_COMMAND,
                                         LapceUICommand::Focus,
-                                        Target::Widget(data.active_id),
+                                        Target::Widget(*data.active_id),
                                     ));
                                 }
                                 return;
@@ -314,12 +469,12 @@ impl Widget<LapceWindowData> for LapceWindow {
                             data.tabs.get(&data.active_id).unwrap(),
                         );
                         data.active = new_index;
-                        data.active_id = self.tabs[new_index].id();
+                        data.active_id = Arc::new(self.tabs[new_index].id());
                         let _ = data.db.save_tabs_async(data);
                         ctx.submit_command(Command::new(
                             LAPCE_UI_COMMAND,
                             LapceUICommand::Focus,
-                            Target::Widget(data.active_id),
+                            Target::Widget(*data.active_id),
                         ));
                         ctx.request_layout();
                         ctx.set_handled();
@@ -334,12 +489,12 @@ impl Widget<LapceWindowData> for LapceWindow {
                             data.tabs.get(&data.active_id).unwrap(),
                         );
                         data.active = new_index;
-                        data.active_id = self.tabs[new_index].id();
+                        data.active_id = Arc::new(self.tabs[new_index].id());
                         let _ = data.db.save_tabs_async(data);
                         ctx.submit_command(Command::new(
                             LAPCE_UI_COMMAND,
                             LapceUICommand::Focus,
-                            Target::Widget(data.active_id),
+                            Target::Widget(*data.active_id),
                         ));
                         ctx.request_layout();
                         ctx.set_handled();
@@ -355,6 +510,7 @@ impl Widget<LapceWindowData> for LapceWindow {
             | Event::MouseUp(_)
             | Event::MouseMove(_)
             | Event::Wheel(_)
+            | Event::AnimFrame(_)
             | Event::KeyDown(_)
             | Event::KeyUp(_) => {}
             _ => {
@@ -368,7 +524,7 @@ impl Widget<LapceWindowData> for LapceWindow {
         for tab_header in self.tab_headers.iter_mut() {
             tab_header.event(ctx, event, data, env);
         }
-        self.title.event(ctx, event, data, env);
+        // self.title.event(ctx, event, data, env);
     }
 
     fn lifecycle(
@@ -378,7 +534,6 @@ impl Widget<LapceWindowData> for LapceWindow {
         data: &LapceWindowData,
         env: &Env,
     ) {
-        self.title.lifecycle(ctx, event, data, env);
         for tab in self.tabs.iter_mut() {
             tab.lifecycle(ctx, event, data, env);
         }
@@ -394,11 +549,16 @@ impl Widget<LapceWindowData> for LapceWindow {
         data: &LapceWindowData,
         env: &Env,
     ) {
-        self.title.update(ctx, data, env);
+        // self.title.update(ctx, data, env);
 
         if old_data.active != data.active {
             ctx.request_layout();
         }
+        #[cfg(not(platform_os = "macos"))]
+        if data.config.core.custom_titlebar != old_data.config.core.custom_titlebar {
+            ctx.window()
+                .show_titlebar(!data.config.core.custom_titlebar);
+        }
         let old_tab = old_data.tabs.get(&old_data.active_id).unwrap();
         let tab = data.tabs.get(&data.active_id).unwrap();
         if old_tab.workspace != tab.workspace {
@@ -407,6 +567,10 @@ impl Widget<LapceWindowData> for LapceWindow {
         for tab in self.tabs.iter_mut() {
             tab.update(ctx, data, env);
         }
+
+        if !old_data.latest_release.same(&data.latest_release) {
+            ctx.request_layout();
+        }
     }
 
     fn layout(
@@ -418,64 +582,112 @@ impl Widget<LapceWindowData> for LapceWindow {
     ) -> Size {
         let self_size = bc.max();
 
-        let title_size = self.title.layout(ctx, bc, data, env);
-        self.title.set_origin(ctx, data, env, Point::ZERO);
-
         let (tab_size, tab_origin) = if self.tabs.len() > 1 {
-            let tab_height = 25.0;
             let tab_size = Size::new(
                 self_size.width,
-                self_size.height - tab_height - title_size.height,
+                self_size.height - TAB_HEADER_HEIGHT - TAB_HEADER_PADDING,
             );
-            let tab_origin = Point::new(0.0, tab_height + title_size.height);
-
-            let num = self.tabs.len();
-            let section = self_size.width / num as f64;
-
+            let tab_origin = Point::new(0.0, TAB_HEADER_HEIGHT + TAB_HEADER_PADDING);
+
+            #[cfg(not(target_os = "macos"))]
+            let left_padding = 0.0;
+            #[cfg(target_os = "macos")]
+            let left_padding = if ctx.window().is_fullscreen()
+                || !data.config.core.custom_titlebar
+            {
+                0.0
+            } else {
+                78.0
+            };
+
+            let right_buttons_width = if cfg!(target_os = "macos") {
+                0.0
+            } else {
+                WINDOW_CONTROL_BUTTON_WIDTH * 3.0
+            };
+            let right_padding = RIGHT_PADDING + right_buttons_width;
+
+            let total_width = self_size.width - left_padding - right_padding;
+            let width =
+                ((total_width / self.tab_headers.len() as f64).min(200.0)).round();
+
+            let mut x = left_padding;
             let mut drag = None;
+            let bc = BoxConstraints::tight(Size::new(width, TAB_HEADER_HEIGHT));
             for (i, tab_header) in self.tab_headers.iter_mut().enumerate() {
-                let bc = BoxConstraints::tight(Size::new(section, tab_height));
-                tab_header.layout(ctx, &bc, data, env);
-                let mut origin = Point::new(section * i as f64, title_size.height);
+                let size = tab_header.layout(ctx, &bc, data, env);
                 let header = tab_header.widget().child();
-                if let Some(o) = header.origin() {
-                    origin = Point::new(o.x, title_size.height);
-                    drag = Some((i, header.mouse_pos));
+
+                let origin = header.origin();
+
+                if origin.is_some() {
+                    drag = Some(i);
                 }
+
+                let origin_x = origin.map_or(x, |origin| origin.x);
+                let origin = Point::new(origin_x, TAB_HEADER_PADDING);
+
                 tab_header.set_origin(ctx, data, env, origin);
+                x += size.width;
             }
 
-            if let Some((index, mouse_pos)) = drag {
-                for (i, tab_header) in self.tab_headers.iter().enumerate() {
-                    if i != index {
-                        let rect = tab_header.layout_rect();
-                        if rect.x0 <= mouse_pos.x && rect.x1 >= mouse_pos.x {
-                            ctx.submit_command(Command::new(
-                                LAPCE_UI_COMMAND,
-                                LapceUICommand::SwapTab(i),
-                                Target::Auto,
-                            ));
-                            break;
-                        }
-                    }
+            self.draggable_area = if data.config.core.custom_titlebar {
+                // Area right of tabs, but left of the window control buttons
+                let mut draggable_area = Region::from(
+                    Size::new(
+                        self_size.width - x - right_buttons_width,
+                        TAB_HEADER_HEIGHT,
+                    )
+                    .to_rect()
+                    .with_origin(Point::new(x, 0.0)),
+                );
+
+                // Area left of the tabs
+                draggable_area.add_rect(
+                    Size::new(left_padding, TAB_HEADER_HEIGHT)
+                        .to_rect()
+                        .with_origin(Point::ZERO),
+                );
+
+                draggable_area
+            } else {
+                Region::EMPTY
+            };
+
+            ctx.window().set_dragable_area(self.draggable_area.clone());
+
+            if let Some(dragged_tab_idx) = drag {
+                // Because tab is opaque, use the tab's center point instead of the mouse position.
+                let dragged_tab_center =
+                    self.tab_headers[dragged_tab_idx].layout_rect().center();
+
+                if let Some((swapped_idx, _)) = self
+                    .tab_headers
+                    .iter()
+                    .enumerate()
+                    .find(|&(idx, tab_header)| {
+                        idx != dragged_tab_idx
+                            && tab_header.layout_rect().contains(dragged_tab_center)
+                    })
+                {
+                    ctx.submit_command(Command::new(
+                        LAPCE_UI_COMMAND,
+                        LapceUICommand::SwapTab(swapped_idx),
+                        Target::Auto,
+                    ));
                 }
             }
 
             (tab_size, tab_origin)
         } else {
-            for (_i, tab_header) in self.tab_headers.iter_mut().enumerate() {
+            for tab_header in self.tab_headers.iter_mut() {
                 let bc = BoxConstraints::tight(Size::new(self_size.width, 0.0));
                 tab_header.layout(ctx, &bc, data, env);
-                tab_header.set_origin(
-                    ctx,
-                    data,
-                    env,
-                    Point::new(0.0, title_size.height),
-                );
+                tab_header.set_origin(ctx, data, env, Point::ZERO);
             }
-            let tab_size =
-                Size::new(self_size.width, self_size.height - title_size.height);
-            (tab_size, Point::new(0.0, title_size.height))
+            let tab_size = self_size;
+
+            (tab_size, Point::ZERO)
         };
 
         let bc = BoxConstraints::tight(tab_size);
@@ -487,76 +699,211 @@ impl Widget<LapceWindowData> for LapceWindow {
 
     fn paint(&mut self, ctx: &mut PaintCtx, data: &LapceWindowData, env: &Env) {
         let _start = std::time::SystemTime::now();
+        self.tabs[data.active].paint(ctx, data, env);
 
-        let title_height = self.title.layout_rect().height();
+        // let title_height = self.title.layout_rect().height();
 
-        let tab_height = 25.0;
         let size = ctx.size();
         if self.tabs.len() > 1 {
+            let rect = Size::new(size.width, TAB_HEADER_HEIGHT).to_rect();
             ctx.fill(
-                Size::new(size.width, tab_height)
-                    .to_rect()
-                    .with_origin(Point::new(0.0, title_height)),
+                rect,
                 data.config
                     .get_color_unchecked(LapceTheme::PANEL_BACKGROUND),
             );
-            for tab_header in self.tab_headers.iter_mut() {
+
+            let mut dragged = None;
+            for (i, tab_header) in self.tab_headers.iter_mut().enumerate() {
+                // Store index and skip if tab is being dragged.
+                if tab_header.widget().child().origin().is_some() {
+                    dragged = Some(i);
+                    continue;
+                }
+
                 tab_header.paint(ctx, data, env);
             }
-        }
 
-        ctx.with_save(|ctx| {
-            ctx.clip(self.tabs[data.active].layout_rect());
-            self.tabs[data.active].paint(ctx, data, env);
-        });
+            // Draw the dragged tab last, above the others
+            if let Some(dragged_tab_idx) = dragged {
+                let tab_header = &mut self.tab_headers[dragged_tab_idx];
 
-        let line_color = data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER);
-        if self.tabs.len() > 1 {
-            let num = self.tabs.len();
-            let section = ctx.size().width / num as f64;
-            for i in 1..num {
-                let line = Line::new(
-                    Point::new(i as f64 * section, title_height),
-                    Point::new(i as f64 * section, title_height + tab_height),
+                tab_header.paint(ctx, data, env);
+            }
+
+            let shadow_width = data.config.ui.drop_shadow_width() as f64;
+            if shadow_width > 0.0 {
+                ctx.blurred_rect(
+                    self.tabs[data.active].layout_rect(),
+                    shadow_width,
+                    data.config
+                        .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                );
+            } else {
+                ctx.stroke(
+                    self.tabs[data.active].layout_rect(),
+                    data.config.get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                    1.0,
                 );
-                ctx.stroke(line, line_color, 1.0);
             }
 
             let rect = self.tab_headers[data.active].layout_rect();
-            let clip_rect = Size::new(size.width, tab_height)
-                .to_rect()
-                .with_origin(Point::new(0.0, title_height));
-            ctx.with_save(|ctx| {
-                ctx.clip(clip_rect);
-                let shadow_width = data.config.ui.drop_shadow_width() as f64;
-                if shadow_width > 0.0 {
-                    ctx.blurred_rect(
+            ctx.stroke(
+                Line::new(
+                    Point::new(rect.x0, rect.y1 - 2.0),
+                    Point::new(rect.x1, rect.y1 - 2.0),
+                ),
+                data.config.get_color_unchecked(LapceTheme::EDITOR_CARET),
+                2.0,
+            );
+
+            self.tab_header_cmds.clear();
+            #[cfg(not(target_os = "macos"))]
+            if data.config.core.custom_titlebar {
+                let (cmds, svgs) = window_controls(
+                    data.window_id,
+                    &ctx.window().get_window_state(),
+                    size.width - WINDOW_CONTROL_BUTTON_WIDTH * 3.0,
+                    WINDOW_CONTROL_BUTTON_WIDTH,
+                    &data.config,
+                );
+                self.tab_header_cmds = cmds;
+
+                for (svg, rect, color) in svgs {
+                    let hover_rect = rect.inflate(10.0, 10.0);
+                    if hover_rect.contains(self.mouse_pos)
+                        && (self.holding_click_rect.is_none()
+                            || self
+                                .holding_click_rect
+                                .unwrap()
+                                .contains(self.mouse_pos))
+                    {
+                        ctx.fill(hover_rect, &color);
+                        ctx.stroke(
+                            Line::new(
+                                Point::new(hover_rect.x0, hover_rect.y1),
+                                Point::new(hover_rect.x1, hover_rect.y1),
+                            ),
+                            data.config
+                                .get_color_unchecked(LapceTheme::LAPCE_BORDER),
+                            1.0,
+                        );
+                    }
+
+                    ctx.draw_svg(
+                        &svg,
                         rect,
-                        shadow_width,
-                        data.config
-                            .get_color_unchecked(LapceTheme::LAPCE_DROPDOWN_SHADOW),
+                        Some(
+                            data.config
+                                .get_color_unchecked(LapceTheme::EDITOR_FOREGROUND),
+                        ),
                     );
                 }
-                ctx.fill(
-                    rect,
-                    data.config
-                        .get_color_unchecked(LapceTheme::EDITOR_BACKGROUND),
-                );
-            });
-            self.tab_headers[data.active].paint(ctx, data, env);
-
-            let line = Line::new(
-                Point::new(0.0, title_height + tab_height - 0.5),
-                Point::new(size.width, title_height + tab_height - 0.5),
-            );
-            ctx.stroke(line, line_color, 1.0);
+            }
         }
-
-        self.title.paint(ctx, data, env);
-        let line = Line::new(
-            Point::new(0.0, title_height - 0.5),
-            Point::new(size.width, title_height - 0.5),
-        );
-        ctx.stroke(line, line_color, 1.0);
     }
 }
+
+#[allow(clippy::type_complexity)]
+#[cfg(not(target_os = "macos"))]
+pub fn window_controls(
+    window_id: druid::WindowId,
+    window_state: &WindowState,
+    x: f64,
+    width: f64,
+    config: &LapceConfig,
+) -> (
+    Vec<(Rect, Command)>,
+    Vec<(druid::piet::Svg, Rect, druid::Color)>,
+) {
+    use druid::Color;
+    use lapce_data::config::LapceIcons;
+
+    let mut commands = Vec::new();
+
+    let minimise_rect = Size::new(width, width)
+        .to_rect()
+        .with_origin(Point::new(x, 0.0));
+    commands.push((
+        minimise_rect,
+        Command::new(
+            druid::commands::CONFIGURE_WINDOW,
+            WindowConfig::default().set_window_state(WindowState::Minimized),
+            Target::Window(window_id),
+        ),
+    ));
+
+    let max_res_state = if window_state == &WindowState::Restored {
+        WindowState::Maximized
+    } else {
+        WindowState::Restored
+    };
+
+    let max_res_rect = Size::new(width, width)
+        .to_rect()
+        .with_origin(Point::new(x + width, 0.0));
+    commands.push((
+        max_res_rect,
+        Command::new(
+            druid::commands::CONFIGURE_WINDOW,
+            WindowConfig::default().set_window_state(max_res_state),
+            Target::Window(window_id),
+        ),
+    ));
+
+    let close_rect = Size::new(width, width)
+        .to_rect()
+        .with_origin(Point::new(x + 2.0 * width, 0.0));
+
+    commands.push((
+        close_rect,
+        Command::new(
+            LAPCE_UI_COMMAND,
+            LapceUICommand::CloseWindow(window_id),
+            Target::Auto,
+        ),
+    ));
+
+    let hover_color = config
+        .get_hover_color(config.get_color_unchecked(LapceTheme::PANEL_BACKGROUND));
+
+    let mut svgs = Vec::new();
+
+    let minimize_rect = Size::new(width, width)
+        .to_rect()
+        .with_origin(Point::new(x, 0.0))
+        .inflate(-10.0, -10.0);
+    svgs.push((
+        config.ui_svg(LapceIcons::WINDOW_MINIMIZE),
+        minimize_rect,
+        hover_color.clone(),
+    ));
+
+    let max_res_rect = Size::new(width, width)
+        .to_rect()
+        .with_origin(Point::new(x + width, 0.0))
+        .inflate(-10.0, -10.0);
+    let max_res_svg = if window_state == &WindowState::Restored {
+        config.ui_svg(LapceIcons::WINDOW_MAXIMIZE)
+    } else {
+        config.ui_svg(LapceIcons::WINDOW_RESTORE)
+    };
+    svgs.push((max_res_svg, max_res_rect, hover_color));
+
+    let close_rect = Size::new(width, width)
+        .to_rect()
+        .with_origin(Point::new(x + 2.0 * width, 0.0))
+        .inflate(-10.0, -10.0);
+    svgs.push((
+        config.ui_svg(LapceIcons::WINDOW_CLOSE),
+        close_rect,
+        Color::rgb8(210, 16, 33),
+    ));
+
+    (commands, svgs)
+}
+
+// TODO(dbuga): find a better place for these
+const TAB_HEADER_HEIGHT: f64 = 36.0;
+const TAB_HEADER_PADDING: f64 = 0.0;
+const RIGHT_PADDING: f64 = 100.0;
+const WINDOW_CONTROL_BUTTON_WIDTH: f64 = 36.0;
diff --git a/lapce.spec b/lapce.spec
new file mode 100644
index 0000000000..ef9da8d2a0
--- /dev/null
+++ b/lapce.spec
@@ -0,0 +1,41 @@
+Name:           lapce-git
+Version:        0.2.6.{{{ git_dir_version }}}
+Release:        1
+Summary:        Lightning-fast and Powerful Code Editor written in Rust
+License:        Apache-2.0
+URL:            https://github.com/lapce/lapce
+
+VCS:            {{{ git_dir_vcs }}}
+Source:        	{{{ git_dir_pack }}}
+
+BuildRequires:  cargo perl-FindBin cairo-devel cairo-gobject-devel atk-devel gdk-pixbuf2-devel pango-devel gtk3-devel perl-lib perl-File-Compare mold clang
+
+%description
+Lapce is written in pure Rust with a UI in Druid (which is also written in Rust).
+It is designed with Rope Science from the Xi-Editor which makes for lightning-fast computation, and leverages OpenGL for rendering.
+
+%prep
+{{{ git_dir_setup_macro }}}
+
+%build
+RUSTFLAGS="-C linker=clang -C link-arg=-fuse-ld=mold" cargo build --profile release-lto
+
+%install
+install -Dm755 target/release-lto/lapce %{buildroot}%{_bindir}/lapce
+install -Dm755 target/release-lto/lapce-proxy %{buildroot}%{_bindir}/lapce-proxy
+install -Dm644 extra/linux/dev.lapce.lapce.desktop %{buildroot}/usr/share/applications/dev.lapce.lapce.desktop
+install -Dm644 extra/linux/dev.lapce.lapce.metainfo.xml %{buildroot}/usr/share/metainfo/dev.lapce.lapce.metainfo.xml
+install -Dm644 extra/images/logo.png %{buildroot}/usr/share/pixmaps/dev.lapce.lapce.png
+
+%files
+%license LICENSE*
+%doc *.md
+%{_bindir}/lapce
+%{_bindir}/lapce-proxy
+/usr/share/applications/dev.lapce.lapce.desktop
+/usr/share/metainfo/dev.lapce.lapce.metainfo.xml
+/usr/share/pixmaps/dev.lapce.lapce.png
+
+%changelog
+* Sat Jul 16 2022 Simon Garding <titaniumtown@gmail.com> - test
+- test
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
new file mode 100644
index 0000000000..292fe499e3
--- /dev/null
+++ b/rust-toolchain.toml
@@ -0,0 +1,2 @@
+[toolchain]
+channel = "stable"