2025-05-06 07:52:57 +00:00
993 changed files with 23865 additions and 54506 deletions
--- a/.github/labeler.yml
+++ b/.github/labeler.yml
@ -1,40 +0,0 @@
-# A bot for automatically labelling pull requests 
-# See https://github.com/actions/labeler
-
-dataframe:
-  - changed-files:
-    - any-glob-to-any-file:
-      - crates/nu_plugin_polars/**
-
-std-library:
-  - changed-files:
-    - any-glob-to-any-file:
-      - crates/nu-std/**
-
-ci:
-  - changed-files:
-    - any-glob-to-any-file:
-      - .github/workflows/**
-
-
-LSP:
-  - changed-files:
-    - any-glob-to-any-file:
-      - crates/nu-lsp/**
-
-parser:
-  - changed-files:
-    - any-glob-to-any-file:
-      - crates/nu-parser/**
-
-pr:plugins:
-  - changed-files:
-    - any-glob-to-any-file:
-      # plugins API
-      - crates/nu-plugin/**
-      - crates/nu-plugin-core/**
-      - crates/nu-plugin-engine/**
-      - crates/nu-plugin-protocol/**
-      - crates/nu-plugin-test-support/**
-      # specific plugins (like polars)
-      - crates/nu_plugin_*/**
--- a/.github/workflows/beta-test.yml
+++ b/.github/workflows/beta-test.yml
@ -1,52 +0,0 @@
-name: Test on Beta Toolchain
-# This workflow is made to run our tests on the beta toolchain to validate that 
-# the beta toolchain works.
-# We do not intend to test here that we are working correctly but rather that 
-# the beta toolchain works correctly.
-# The ci.yml handles our actual testing with our guarantees.
-
-on:
-  schedule:
-    # If this workflow fails, GitHub notifications will go to the last person 
-    # who edited this line.
-    # See: https://docs.github.com/en/actions/monitoring-and-troubleshooting-workflows/monitoring-workflows/notifications-for-workflow-runs
-    - cron: '0 0 * * *'  # Runs daily at midnight UTC
-
-env:
-  NUSHELL_CARGO_PROFILE: ci
-  NU_LOG_LEVEL: DEBUG
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  build-and-test:
-    # this job is more for testing the beta toolchain and not our tests, so if 
-    # this fails but the tests of the regular ci pass, then this is fine
-    continue-on-error: true
-
-    strategy:
-      fail-fast: true
-      matrix:
-        platform: [windows-latest, macos-latest, ubuntu-22.04]
-
-    runs-on: ${{ matrix.platform }}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - run: rustup update beta
-
-      - name: Tests
-        run: cargo +beta test --workspace --profile ci --exclude nu_plugin_*
-      - name: Check for clean repo
-        shell: bash
-        run: |
-          if [ -n "$(git status --porcelain)" ]; then
-            echo "there are changes";
-            git status --porcelain
-            exit 1
-          else
-            echo "no changes in working directory";
-          fi
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -3,7 +3,6 @@ on:
  push:
    branches:
      - main
-      - 'patch-release-*'

 name: continuous-integration

@ -22,14 +21,14 @@ jobs:
    strategy:
      fail-fast: true
      matrix:
-        # Pinning to Ubuntu 22.04 because building on newer Ubuntu versions causes linux-gnu
+        # Pinning to Ubuntu 20.04 because building on newer Ubuntu versions causes linux-gnu
        # builds to link against a too-new-for-many-Linux-installs glibc version. Consider
-        # revisiting this when 22.04 is closer to EOL (June 2027)
+        # revisiting this when 20.04 is closer to EOL (April 2025)
        #
        # Using macOS 13 runner because 14 is based on the M1 and has half as much RAM (7 GB,
        # instead of 14 GB) which is too little for us right now. Revisit when `dfr` commands are
        # removed and we're only building the `polars` plugin instead
-        platform: [windows-latest, macos-13, ubuntu-22.04]
+        platform: [windows-latest, macos-13, ubuntu-20.04]

    runs-on: ${{ matrix.platform }}

@ -37,7 +36,7 @@ jobs:
      - uses: actions/checkout@v4.1.7

      - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        uses: actions-rust-lang/setup-rust-toolchain@v1.10.1

      - name: cargo fmt
        run: cargo fmt --all -- --check
@ -57,7 +56,7 @@ jobs:
    strategy:
      fail-fast: true
      matrix:
-        platform: [windows-latest, macos-latest, ubuntu-22.04]
+        platform: [windows-latest, macos-latest, ubuntu-20.04]

    runs-on: ${{ matrix.platform }}

@ -65,7 +64,7 @@ jobs:
      - uses: actions/checkout@v4.1.7

      - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        uses: actions-rust-lang/setup-rust-toolchain@v1.10.1

      - name: Tests
        run: cargo test --workspace --profile ci --exclude nu_plugin_*
@ -84,7 +83,7 @@ jobs:
    strategy:
      fail-fast: true
      matrix:
-        platform: [ubuntu-22.04, macos-latest, windows-latest]
+        platform: [ubuntu-20.04, macos-latest, windows-latest]
        py:
          - py

@ -94,10 +93,10 @@ jobs:
      - uses: actions/checkout@v4.1.7

      - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        uses: actions-rust-lang/setup-rust-toolchain@v1.10.1

      - name: Install Nushell
-        run: cargo install --path . --locked --force
+        run: cargo install --path . --locked --no-default-features

      - name: Standard library tests
        run: nu -c 'use crates/nu-std/testing.nu; testing run-tests --path crates/nu-std'
@ -137,7 +136,7 @@ jobs:
        # instead of 14 GB) which is too little for us right now.
        #
        # Failure occurring with clippy for rust 1.77.2
-        platform: [windows-latest, macos-13, ubuntu-22.04]
+        platform: [windows-latest, macos-13, ubuntu-20.04]

    runs-on: ${{ matrix.platform }}

@ -145,7 +144,7 @@ jobs:
      - uses: actions/checkout@v4.1.7

      - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+        uses: actions-rust-lang/setup-rust-toolchain@v1.10.1

      - name: Clippy
        run: cargo clippy --package nu_plugin_* -- $CLIPPY_OPTIONS
@ -163,50 +162,3 @@ jobs:
          else
            echo "no changes in working directory";
          fi
-
-  wasm:
-    env:
-      WASM_OPTIONS: --no-default-features --target wasm32-unknown-unknown
-      CLIPPY_CONF_DIR: ${{ github.workspace }}/clippy/wasm/
-
-    strategy:
-      matrix:
-        job:
-          - name: Build WASM
-            command: cargo build
-            args:
-          - name: Clippy WASM
-            command: cargo clippy
-            args: -- $CLIPPY_OPTIONS
-
-    name: ${{ matrix.job.name }}
-
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4.1.7
-
-      - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
-
-      - name: Add wasm32-unknown-unknown target
-        run: rustup target add wasm32-unknown-unknown
-
-      - run: ${{ matrix.job.command }} -p nu-cmd-base $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-cmd-extra $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-cmd-lang $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-color-config $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-command $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-derive-value $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-engine $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-glob $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-json $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-parser $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-path $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-pretty-hex $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-protocol $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-std $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-system $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-table $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-term-grid $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nu-utils $WASM_OPTIONS ${{ matrix.job.args }}
-      - run: ${{ matrix.job.command }} -p nuon $WASM_OPTIONS ${{ matrix.job.args }}
--- a/.github/workflows/labels.yml
+++ b/.github/workflows/labels.yml
@ -1,19 +0,0 @@
-# Automatically labels PRs based on the configuration file
-# you are probably looking for 👉 `.github/labeler.yml`
-name: Label PRs
-
-on:
-  - pull_request_target
-
-jobs:
-  triage:
-    permissions:
-      contents: read
-      pull-requests: write
-    runs-on: ubuntu-latest
-    if: github.repository_owner == 'nushell'
-    steps:
-      - uses: actions/labeler@v5
-        with:
-          repo-token: "${{ secrets.GITHUB_TOKEN }}"
-          sync-labels: true
--- a/.github/workflows/milestone.yml
+++ b/.github/workflows/milestone.yml
@ -22,7 +22,7 @@ jobs:

      # Bind milestone to closed issue that has a merged PR fix
      - name: Set Milestone for Issue
-        uses: hustcer/milestone-action@v2
+        uses: hustcer/milestone-action@main
        if: github.event.issue.state == 'closed'
        with:
          action: bind-issue
--- a/.github/workflows/nightly-build.yml
+++ b/.github/workflows/nightly-build.yml
@ -8,7 +8,6 @@
 name: Nightly Build

 on:
-  workflow_dispatch:
  push:
    branches:
      - nightly   # Just for test purpose only with the nightly repo
@ -40,7 +39,7 @@ jobs:
        uses: hustcer/setup-nu@v3
        if: github.repository == 'nushell/nightly'
        with:
-          version: 0.103.0
+          version: 0.98.0

      # Synchronize the main branch of nightly repo with the main branch of Nushell official repo
      - name: Prepare for Nightly Release
@ -115,7 +114,7 @@ jobs:
        - target: armv7-unknown-linux-musleabihf
          os: ubuntu-22.04
        - target: riscv64gc-unknown-linux-gnu
-          os: ubuntu-22.04
+          os: ubuntu-latest
        - target: loongarch64-unknown-linux-gnu
          os: ubuntu-22.04

@ -132,7 +131,7 @@ jobs:
        echo "targets = ['${{matrix.target}}']" >> rust-toolchain.toml

    - name: Setup Rust toolchain and cache
-      uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+      uses: actions-rust-lang/setup-rust-toolchain@v1.10.1
      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec: Error 0xc0000135`
      with:
        rustflags: ''
@ -140,7 +139,7 @@ jobs:
    - name: Setup Nushell
      uses: hustcer/setup-nu@v3
      with:
-        version: 0.103.0
+        version: 0.98.0

    - name: Release Nu Binary
      id: nu
@ -198,7 +197,7 @@ jobs:
      - name: Setup Nushell
        uses: hustcer/setup-nu@v3
        with:
-          version: 0.103.0
+          version: 0.98.0

      # Keep the last a few releases
      - name: Delete Older Releases
--- a/.github/workflows/release-pkg.nu
+++ b/.github/workflows/release-pkg.nu
@ -117,14 +117,14 @@ if $os in ['macos-latest'] or $USE_UBUNTU {
 # ----------------------------------------------------------------------------
 # Build for Windows without static-link-openssl feature
 # ----------------------------------------------------------------------------
-if $os =~ 'windows' {
+if $os in ['windows-latest'] {
    cargo-build-nu
 }

 # ----------------------------------------------------------------------------
 # Prepare for the release archive
 # ----------------------------------------------------------------------------
-let suffix = if $os =~ 'windows' { '.exe' }
+let suffix = if $os == 'windows-latest' { '.exe' }
 # nu, nu_plugin_* were all included
 let executable = $'target/($target)/release/($bin)*($suffix)'
 print $'Current executable file: ($executable)'
@ -148,10 +148,10 @@ For more information, refer to https://www.nushell.sh/book/plugins.html
 [LICENSE ...(glob $executable)] | each {|it| cp -rv $it $dist } | flatten

 print $'(char nl)Check binary release version detail:'; hr-line
-let ver = if $os =~ 'windows' {
-    (do -i { .\output\nu.exe -c 'version' }) | default '' | str join
+let ver = if $os == 'windows-latest' {
+    (do -i { .\output\nu.exe -c 'version' }) | str join
 } else {
-    (do -i { ./output/nu -c 'version' }) | default '' | str join
+    (do -i { ./output/nu -c 'version' }) | str join
 }
 if ($ver | str trim | is-empty) {
    print $'(ansi r)Incompatible Nu binary: The binary cross compiled is not runnable on current arch...(ansi reset)'
@ -177,7 +177,7 @@ if $os in ['macos-latest'] or $USE_UBUNTU {
    # REF: https://github.blog/changelog/2022-10-11-github-actions-deprecating-save-state-and-set-output-commands/
    echo $"archive=($archive)" | save --append $env.GITHUB_OUTPUT

-} else if $os =~ 'windows' {
+} else if $os == 'windows-latest' {

    let releaseStem = $'($bin)-($version)-($target)'

@ -221,7 +221,7 @@ if $os in ['macos-latest'] or $USE_UBUNTU {
 }

 def 'cargo-build-nu' [] {
-    if $os =~ 'windows' {
+    if $os == 'windows-latest' {
        cargo build --release --all --target $target
    } else {
        cargo build --release --all --target $target --features=static-link-openssl
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -7,9 +7,7 @@ name: Create Release Draft
 on:
  workflow_dispatch:
  push:
-    tags:
-      - '[0-9]+.[0-9]+.[0-9]+*'
-      - '!*nightly*'  # Don't trigger release for nightly tags
+    tags: ["[0-9]+.[0-9]+.[0-9]+*"]

 defaults:
  run:
@ -66,7 +64,7 @@ jobs:
        - target: armv7-unknown-linux-musleabihf
          os: ubuntu-22.04
        - target: riscv64gc-unknown-linux-gnu
-          os: ubuntu-22.04
+          os: ubuntu-latest
        - target: loongarch64-unknown-linux-gnu
          os: ubuntu-22.04

@ -80,7 +78,7 @@ jobs:
        echo "targets = ['${{matrix.target}}']" >> rust-toolchain.toml

    - name: Setup Rust toolchain
-      uses: actions-rust-lang/setup-rust-toolchain@v1.11.0
+      uses: actions-rust-lang/setup-rust-toolchain@v1.10.1
      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec: Error 0xc0000135`
      with:
        cache: false
@ -89,7 +87,7 @@ jobs:
    - name: Setup Nushell
      uses: hustcer/setup-nu@v3
      with:
-        version: 0.103.0
+        version: 0.98.0

    - name: Release Nu Binary
      id: nu
--- a/.github/workflows/typos.yml
+++ b/.github/workflows/typos.yml
@ -10,4 +10,4 @@ jobs:
        uses: actions/checkout@v4.1.7

      - name: Check spelling
-        uses: crate-ci/typos@v1.31.1
+        uses: crate-ci/typos@v1.27.0
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -10,8 +10,8 @@ homepage = "https://www.nushell.sh"
 license = "MIT"
 name = "nu"
 repository = "https://github.com/nushell/nushell"
-rust-version = "1.84.1"
-version = "0.104.1"
+rust-version = "1.80.1"
+version = "0.100.0"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@ -66,12 +66,12 @@ alphanumeric-sort = "1.5"
 ansi-str = "0.8"
 anyhow = "1.0.82"
 base64 = "0.22.1"
-bracoxide = "0.1.6"
-brotli = "7.0"
+bracoxide = "0.1.4"
+brotli = "6.0"
 byteorder = "1.5"
 bytes = "1"
-bytesize = "1.3.3"
-calamine = "0.27"
+bytesize = "1.3"
+calamine = "0.24.0"
 chardetng = "0.1.17"
 chrono = { default-features = false, version = "0.4.34" }
 chrono-humanize = "0.2.3"
@ -80,7 +80,6 @@ crossbeam-channel = "0.5.8"
 crossterm = "0.28.1"
 csv = "1.3"
 ctrlc = "3.4"
-devicons = "0.6.12"
 dialoguer = { default-features = false, version = "0.11" }
 digest = { default-features = false, version = "0.10" }
 dirs = "5.0"
@ -90,9 +89,10 @@ encoding_rs = "0.8"
 fancy-regex = "0.14"
 filesize = "0.2"
 filetime = "0.2"
+fuzzy-matcher = "0.3"
 heck = "0.5.0"
-human-date-parser = "0.3.0"
-indexmap = "2.9"
+human-date-parser = "0.2.0"
+indexmap = "2.6"
 indicatif = "0.17"
 interprocess = "2.2.0"
 is_executable = "1.0"
@ -102,21 +102,19 @@ libproc = "0.14"
 log = "0.4"
 lru = "0.12"
 lscolors = { version = "0.17", default-features = false }
-lsp-server = "0.7.8"
-lsp-types = { version = "0.97.0", features = ["proposed"] }
-lsp-textdocument = "0.4.2"
+lsp-server = "0.7.5"
+lsp-types = { version = "0.95.0", features = ["proposed"] }
 mach2 = "0.4"
 md5 = { version = "0.10", package = "md-5" }
-miette = "7.5"
+miette = "7.2"
 mime = "0.3.17"
 mime_guess = "2.0"
-mockito = { version = "1.7", default-features = false }
-multipart-rs = "0.1.13"
+mockito = { version = "1.5", default-features = false }
+multipart-rs = "0.1.11"
 native-tls = "0.2"
 nix = { version = "0.29", default-features = false }
 notify-debouncer-full = { version = "0.3", default-features = false }
 nu-ansi-term = "0.50.1"
-nucleo-matcher = "0.3"
 num-format = "0.4"
 num-traits = "0.2"
 oem_cp = "2.0.0"
@ -127,66 +125,60 @@ pathdiff = "0.2"
 percent-encoding = "2"
 pretty_assertions = "1.4"
 print-positions = "0.6"
-proc-macro-error2 = "2.0"
+proc-macro-error = { version = "1.0", default-features = false }
 proc-macro2 = "1.0"
-procfs = "0.17.0"
+procfs = "0.16.0"
 pwd = "1.3"
-quick-xml = "0.37.0"
+quick-xml = "0.32.0"
 quickcheck = "1.0"
 quickcheck_macros = "1.0"
 quote = "1.0"
-rand = "0.9"
-getrandom = "0.2" # pick same version that rand requires
-rand_chacha = "0.9"
-ratatui = "0.29"
+rand = "0.8"
+rand_chacha = "0.3.1"
+ratatui = "0.26"
 rayon = "1.10"
-reedline = "0.40.0"
+reedline = "0.37.0"
+regex = "1.9.5"
 rmp = "0.8"
 rmp-serde = "1.3"
-roxmltree = "0.20"
-rstest = { version = "0.23", default-features = false }
-rstest_reuse = "0.7"
+ropey = "1.6.1"
+roxmltree = "0.19"
+rstest = { version = "0.18", default-features = false }
 rusqlite = "0.31"
-rust-embed = "8.7.0"
-scopeguard = { version = "1.2.0" }
+rust-embed = "8.5.0"
 serde = { version = "1.0" }
-serde_json = "1.0.97"
+serde_json = "1.0"
 serde_urlencoded = "0.7.1"
-serde_yaml = "0.9.33"
+serde_yaml = "0.9"
 sha2 = "0.10"
 strip-ansi-escapes = "0.2.0"
-strum = "0.26"
-strum_macros = "0.26"
 syn = "2.0"
-sysinfo = "0.33"
-tabled = { version = "0.17.0", default-features = false }
-tempfile = "3.15"
-titlecase = "3.5"
+sysinfo = "0.32"
+tabled = { version = "0.16.0", default-features = false }
+tempfile = "3.13"
+terminal_size = "0.3"
+titlecase = "2.0"
 toml = "0.8"
 trash = "5.2"
-update-informer = { version = "1.2.0", default-features = false, features = ["github", "native-tls", "ureq"] }
 umask = "2.1"
 unicode-segmentation = "1.12"
-unicode-width = "0.2"
-ureq = { version = "2.12", default-features = false, features = ["socks-proxy"] }
+unicode-width = "0.1"
+ureq = { version = "2.10", default-features = false }
 url = "2.2"
-uu_cp = "0.0.30"
-uu_mkdir = "0.0.30"
-uu_mktemp = "0.0.30"
-uu_mv = "0.0.30"
-uu_touch = "0.0.30"
-uu_whoami = "0.0.30"
-uu_uname = "0.0.30"
-uucore = "0.0.30"
-uuid = "1.16.0"
+uu_cp = "0.0.27"
+uu_mkdir = "0.0.27"
+uu_mktemp = "0.0.27"
+uu_mv = "0.0.27"
+uu_whoami = "0.0.27"
+uu_uname = "0.0.27"
+uucore = "0.0.27"
+uuid = "1.11.0"
 v_htmlescape = "0.15.0"
 wax = "0.6"
-web-time = "1.1.0"
-which = "7.0.0"
+which = "6.0.0"
 windows = "0.56"
 windows-sys = "0.48"
 winreg = "0.52"
-memchr = "2.7.4"

 [workspace.lints.clippy]
 # Warning: workspace lints affect library code as well as tests, so don't enable lints that would be too noisy in tests like that.
@ -197,22 +189,22 @@ unchecked_duration_subtraction = "warn"
 workspace = true

 [dependencies]
-nu-cli = { path = "./crates/nu-cli", version = "0.104.1" }
-nu-cmd-base = { path = "./crates/nu-cmd-base", version = "0.104.1" }
-nu-cmd-lang = { path = "./crates/nu-cmd-lang", version = "0.104.1" }
-nu-cmd-plugin = { path = "./crates/nu-cmd-plugin", version = "0.104.1", optional = true }
-nu-cmd-extra = { path = "./crates/nu-cmd-extra", version = "0.104.1" }
-nu-command = { path = "./crates/nu-command", version = "0.104.1" }
-nu-engine = { path = "./crates/nu-engine", version = "0.104.1" }
-nu-explore = { path = "./crates/nu-explore", version = "0.104.1" }
-nu-lsp = { path = "./crates/nu-lsp/", version = "0.104.1" }
-nu-parser = { path = "./crates/nu-parser", version = "0.104.1" }
-nu-path = { path = "./crates/nu-path", version = "0.104.1" }
-nu-plugin-engine = { path = "./crates/nu-plugin-engine", optional = true, version = "0.104.1" }
-nu-protocol = { path = "./crates/nu-protocol", version = "0.104.1" }
-nu-std = { path = "./crates/nu-std", version = "0.104.1" }
-nu-system = { path = "./crates/nu-system", version = "0.104.1" }
-nu-utils = { path = "./crates/nu-utils", version = "0.104.1" }
+nu-cli = { path = "./crates/nu-cli", version = "0.100.0" }
+nu-cmd-base = { path = "./crates/nu-cmd-base", version = "0.100.0" }
+nu-cmd-lang = { path = "./crates/nu-cmd-lang", version = "0.100.0" }
+nu-cmd-plugin = { path = "./crates/nu-cmd-plugin", version = "0.100.0", optional = true }
+nu-cmd-extra = { path = "./crates/nu-cmd-extra", version = "0.100.0" }
+nu-command = { path = "./crates/nu-command", version = "0.100.0" }
+nu-engine = { path = "./crates/nu-engine", version = "0.100.0" }
+nu-explore = { path = "./crates/nu-explore", version = "0.100.0" }
+nu-lsp = { path = "./crates/nu-lsp/", version = "0.100.0" }
+nu-parser = { path = "./crates/nu-parser", version = "0.100.0" }
+nu-path = { path = "./crates/nu-path", version = "0.100.0" }
+nu-plugin-engine = { path = "./crates/nu-plugin-engine", optional = true, version = "0.100.0" }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.100.0" }
+nu-std = { path = "./crates/nu-std", version = "0.100.0" }
+nu-system = { path = "./crates/nu-system", version = "0.100.0" }
+nu-utils = { path = "./crates/nu-utils", version = "0.100.0" }
 reedline = { workspace = true, features = ["bashisms", "sqlite"] }

 crossterm = { workspace = true }
@ -220,6 +212,7 @@ ctrlc = { workspace = true }
 dirs = { workspace = true }
 log = { workspace = true }
 miette = { workspace = true, features = ["fancy-no-backtrace", "fancy"] }
+mimalloc = { version = "0.1.42", default-features = false, optional = true }
 multipart-rs = { workspace = true }
 serde_json = { workspace = true }
 simplelog = "0.12"
@ -241,38 +234,34 @@ nix = { workspace = true, default-features = false, features = [
 ] }

 [dev-dependencies]
-nu-test-support = { path = "./crates/nu-test-support", version = "0.104.1" }
-nu-plugin-protocol = { path = "./crates/nu-plugin-protocol", version = "0.104.1" }
-nu-plugin-core = { path = "./crates/nu-plugin-core", version = "0.104.1" }
+nu-test-support = { path = "./crates/nu-test-support", version = "0.100.0" }
+nu-plugin-protocol = { path = "./crates/nu-plugin-protocol", version = "0.100.0" }
+nu-plugin-core = { path = "./crates/nu-plugin-core", version = "0.100.0" }
 assert_cmd = "2.0"
 dirs = { workspace = true }
 tango-bench = "0.6"
 pretty_assertions = { workspace = true }
-fancy-regex = { workspace = true }
+regex = { workspace = true }
 rstest = { workspace = true, default-features = false }
-serial_test = "3.2"
+serial_test = "3.1"
 tempfile = { workspace = true }

 [features]
 plugin = [
-  # crates
-  "nu-cmd-plugin",
  "nu-plugin-engine",
-
-  # features
+  "nu-cmd-plugin",
  "nu-cli/plugin",
-  "nu-cmd-lang/plugin",
-  "nu-command/plugin",
-  "nu-engine/plugin",
-  "nu-engine/plugin",
  "nu-parser/plugin",
+  "nu-command/plugin",
  "nu-protocol/plugin",
+  "nu-engine/plugin",
 ]

 default = [
  "plugin",
  "trash-support",
  "sqlite",
+  "mimalloc",
 ]
 stable = ["default"]
 # NOTE: individual features are also passed to `nu-cmd-lang` that uses them to generate the feature matrix in the `version` command
@ -281,6 +270,7 @@ stable = ["default"]
 # otherwise the system version will be used. Not enabled by default because it takes a while to build
 static-link-openssl = ["dep:openssl", "nu-cmd-lang/static-link-openssl"]

+mimalloc = ["nu-cmd-lang/mimalloc", "dep:mimalloc"]
 # Optional system clipboard support in `reedline`, this behavior has problematic compatibility with some systems.
 # Missing X server/ Wayland can cause issues
 system-clipboard = [
@ -293,7 +283,7 @@ system-clipboard = [
 trash-support = ["nu-command/trash-support", "nu-cmd-lang/trash-support"]

 # SQLite commands for nushell
-sqlite = ["nu-command/sqlite", "nu-cmd-lang/sqlite", "nu-std/sqlite"]
+sqlite = ["nu-command/sqlite", "nu-cmd-lang/sqlite"]

 [profile.release]
 opt-level = "s"     # Optimize for size
--- a/2
+++ b/2
@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2019 - 2025 The Nushell Project Developers
+Copyright (c) 2019 - 2023 The Nushell Project Developers

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/README.md
+++ b/README.md
@ -4,6 +4,7 @@
 [![Nightly Build](https://github.com/nushell/nushell/actions/workflows/nightly-build.yml/badge.svg)](https://github.com/nushell/nushell/actions/workflows/nightly-build.yml)
 [![Discord](https://img.shields.io/discord/601130461678272522.svg?logo=discord)](https://discord.gg/NtAbbGn)
 [![The Changelog #363](https://img.shields.io/badge/The%20Changelog-%23363-61c192.svg)](https://changelog.com/podcast/363)
+[![@nu_shell](https://img.shields.io/badge/twitter-@nu_shell-1DA1F3?style=flat-square)](https://twitter.com/nu_shell)
 [![GitHub commit activity](https://img.shields.io/github/commit-activity/m/nushell/nushell)](https://github.com/nushell/nushell/graphs/commit-activity)
 [![GitHub contributors](https://img.shields.io/github/contributors/nushell/nushell)](https://github.com/nushell/nushell/graphs/contributors)

@ -34,7 +35,7 @@ This project has reached a minimum-viable-product level of quality. Many people

 The [Nushell book](https://www.nushell.sh/book/) is the primary source of Nushell documentation. You can find [a full list of Nu commands in the book](https://www.nushell.sh/commands/), and we have many examples of using Nu in our [cookbook](https://www.nushell.sh/cookbook/).

-We're also active on [Discord](https://discord.gg/NtAbbGn); come and chat with us!
+We're also active on [Discord](https://discord.gg/NtAbbGn) and [Twitter](https://twitter.com/nu_shell); come and chat with us!

 ## Installation

@ -57,7 +58,7 @@ For details about which platforms the Nushell team actively supports, see [our p

 ## Configuration

-The default configurations can be found at [sample_config](crates/nu-utils/src/default_files)
+The default configurations can be found at [sample_config](crates/nu-utils/src/sample_config)
 which are the configuration files one gets when they startup Nushell for the first time.

 It sets all of the default configuration to run Nushell.  From here one can
@ -94,44 +95,44 @@ Commands that work in the pipeline fit into one of three categories:
 Commands are separated by the pipe symbol (`|`) to denote a pipeline flowing left to right.

 ```shell
-ls | where type == "dir" | table
-# => ╭────┬──────────┬──────┬─────────┬───────────────╮
-# => │ #  │   name   │ type │  size   │   modified    │
-# => ├────┼──────────┼──────┼─────────┼───────────────┤
-# => │  0 │ .cargo   │ dir  │     0 B │ 9 minutes ago │
-# => │  1 │ assets   │ dir  │     0 B │ 2 weeks ago   │
-# => │  2 │ crates   │ dir  │ 4.0 KiB │ 2 weeks ago   │
-# => │  3 │ docker   │ dir  │     0 B │ 2 weeks ago   │
-# => │  4 │ docs     │ dir  │     0 B │ 2 weeks ago   │
-# => │  5 │ images   │ dir  │     0 B │ 2 weeks ago   │
-# => │  6 │ pkg_mgrs │ dir  │     0 B │ 2 weeks ago   │
-# => │  7 │ samples  │ dir  │     0 B │ 2 weeks ago   │
-# => │  8 │ src      │ dir  │ 4.0 KiB │ 2 weeks ago   │
-# => │  9 │ target   │ dir  │     0 B │ a day ago     │
-# => │ 10 │ tests    │ dir  │ 4.0 KiB │ 2 weeks ago   │
-# => │ 11 │ wix      │ dir  │     0 B │ 2 weeks ago   │
-# => ╰────┴──────────┴──────┴─────────┴───────────────╯
+> ls | where type == "dir" | table
+╭────┬──────────┬──────┬─────────┬───────────────╮
+│ #  │   name   │ type │  size   │   modified    │
+├────┼──────────┼──────┼─────────┼───────────────┤
+│  0 │ .cargo   │ dir  │     0 B │ 9 minutes ago │
+│  1 │ assets   │ dir  │     0 B │ 2 weeks ago   │
+│  2 │ crates   │ dir  │ 4.0 KiB │ 2 weeks ago   │
+│  3 │ docker   │ dir  │     0 B │ 2 weeks ago   │
+│  4 │ docs     │ dir  │     0 B │ 2 weeks ago   │
+│  5 │ images   │ dir  │     0 B │ 2 weeks ago   │
+│  6 │ pkg_mgrs │ dir  │     0 B │ 2 weeks ago   │
+│  7 │ samples  │ dir  │     0 B │ 2 weeks ago   │
+│  8 │ src      │ dir  │ 4.0 KiB │ 2 weeks ago   │
+│  9 │ target   │ dir  │     0 B │ a day ago     │
+│ 10 │ tests    │ dir  │ 4.0 KiB │ 2 weeks ago   │
+│ 11 │ wix      │ dir  │     0 B │ 2 weeks ago   │
+╰────┴──────────┴──────┴─────────┴───────────────╯
 ```

 Because most of the time you'll want to see the output of a pipeline, `table` is assumed.
 We could have also written the above:

 ```shell
-ls | where type == "dir"
+> ls | where type == "dir"
 ```

 Being able to use the same commands and compose them differently is an important philosophy in Nu.
 For example, we could use the built-in `ps` command to get a list of the running processes, using the same `where` as above.

 ```shell
-ps | where cpu > 0
-# => ╭───┬───────┬───────────┬───────┬───────────┬───────────╮
-# => │ # │  pid  │   name    │  cpu  │    mem    │  virtual  │
-# => ├───┼───────┼───────────┼───────┼───────────┼───────────┤
-# => │ 0 │  2240 │ Slack.exe │ 16.40 │ 178.3 MiB │ 232.6 MiB │
-# => │ 1 │ 16948 │ Slack.exe │ 16.32 │ 205.0 MiB │ 197.9 MiB │
-# => │ 2 │ 17700 │ nu.exe    │  3.77 │  26.1 MiB │   8.8 MiB │
-# => ╰───┴───────┴───────────┴───────┴───────────┴───────────╯
+> ps | where cpu > 0
+╭───┬───────┬───────────┬───────┬───────────┬───────────╮
+│ # │  pid  │   name    │  cpu  │    mem    │  virtual  │
+├───┼───────┼───────────┼───────┼───────────┼───────────┤
+│ 0 │  2240 │ Slack.exe │ 16.40 │ 178.3 MiB │ 232.6 MiB │
+│ 1 │ 16948 │ Slack.exe │ 16.32 │ 205.0 MiB │ 197.9 MiB │
+│ 2 │ 17700 │ nu.exe    │  3.77 │  26.1 MiB │   8.8 MiB │
+╰───┴───────┴───────────┴───────┴───────────┴───────────╯
 ```

 ### Opening files
@ -140,46 +141,46 @@ Nu can load file and URL contents as raw text or structured data (if it recogniz
 For example, you can load a .toml file as structured data and explore it:

 ```shell
-open Cargo.toml
-# => ╭──────────────────┬────────────────────╮
-# => │ bin              │ [table 1 row]      │
-# => │ dependencies     │ {record 25 fields} │
-# => │ dev-dependencies │ {record 8 fields}  │
-# => │ features         │ {record 10 fields} │
-# => │ package          │ {record 13 fields} │
-# => │ patch            │ {record 1 field}   │
-# => │ profile          │ {record 3 fields}  │
-# => │ target           │ {record 3 fields}  │
-# => │ workspace        │ {record 1 field}   │
-# => ╰──────────────────┴────────────────────╯
+> open Cargo.toml
+╭──────────────────┬────────────────────╮
+│ bin              │ [table 1 row]      │
+│ dependencies     │ {record 25 fields} │
+│ dev-dependencies │ {record 8 fields}  │
+│ features         │ {record 10 fields} │
+│ package          │ {record 13 fields} │
+│ patch            │ {record 1 field}   │
+│ profile          │ {record 3 fields}  │
+│ target           │ {record 3 fields}  │
+│ workspace        │ {record 1 field}   │
+╰──────────────────┴────────────────────╯
 ```

 We can pipe this into a command that gets the contents of one of the columns:

 ```shell
-open Cargo.toml | get package
-# => ╭───────────────┬────────────────────────────────────╮
-# => │ authors       │ [list 1 item]                      │
-# => │ default-run   │ nu                                 │
-# => │ description   │ A new type of shell                │
-# => │ documentation │ https://www.nushell.sh/book/       │
-# => │ edition       │ 2018                               │
-# => │ exclude       │ [list 1 item]                      │
-# => │ homepage      │ https://www.nushell.sh             │
-# => │ license       │ MIT                                │
-# => │ metadata      │ {record 1 field}                   │
-# => │ name          │ nu                                 │
-# => │ repository    │ https://github.com/nushell/nushell │
-# => │ rust-version  │ 1.60                               │
-# => │ version       │ 0.72.0                             │
-# => ╰───────────────┴────────────────────────────────────╯
+> open Cargo.toml | get package
+╭───────────────┬────────────────────────────────────╮
+│ authors       │ [list 1 item]                      │
+│ default-run   │ nu                                 │
+│ description   │ A new type of shell                │
+│ documentation │ https://www.nushell.sh/book/       │
+│ edition       │ 2018                               │
+│ exclude       │ [list 1 item]                      │
+│ homepage      │ https://www.nushell.sh             │
+│ license       │ MIT                                │
+│ metadata      │ {record 1 field}                   │
+│ name          │ nu                                 │
+│ repository    │ https://github.com/nushell/nushell │
+│ rust-version  │ 1.60                               │
+│ version       │ 0.72.0                             │
+╰───────────────┴────────────────────────────────────╯
 ```

 And if needed we can drill down further:

 ```shell
-open Cargo.toml | get package.version
-# => 0.72.0
+> open Cargo.toml | get package.version
+0.72.0
 ```

 ### Plugins
@ -222,7 +223,6 @@ Please submit an issue or PR to be added to this list.
 -   [Dorothy](http://github.com/bevry/dorothy)
 -   [Direnv](https://github.com/direnv/direnv/blob/master/docs/hook.md#nushell)
 -   [x-cmd](https://x-cmd.com/mod/nu)
-   [vfox](https://github.com/version-fox/vfox)

 ## Contributing

--- a/benches/benchmarks.rs
+++ b/benches/benchmarks.rs
@ -1,6 +1,7 @@
 use nu_cli::{eval_source, evaluate_commands};
 use nu_plugin_core::{Encoder, EncodingType};
 use nu_plugin_protocol::{PluginCallResponse, PluginOutput};
+
 use nu_protocol::{
    engine::{EngineState, Stack},
    PipelineData, Signals, Span, Spanned, Value,
@ -8,11 +9,12 @@ use nu_protocol::{
 use nu_std::load_standard_library;
 use nu_utils::{get_default_config, get_default_env};
 use std::{
-    fmt::Write,
-    hint::black_box,
    rc::Rc,
    sync::{atomic::AtomicBool, Arc},
 };
+
+use std::hint::black_box;
+
 use tango_bench::{benchmark_fn, tango_benchmarks, tango_main, IntoBenchmarks};

 fn load_bench_commands() -> EngineState {
@ -44,6 +46,9 @@ fn setup_stack_and_engine_from_command(command: &str) -> (Stack, EngineState) {

    let mut stack = Stack::new();

+    // Support running benchmarks without IR mode
+    stack.use_ir = std::env::var_os("NU_DISABLE_IR").is_none();
+
    evaluate_commands(
        &commands,
        &mut engine,
@ -139,16 +144,19 @@ fn bench_load_standard_lib() -> impl IntoBenchmarks {
    })]
 }

-fn create_flat_record_string(n: usize) -> String {
-    let mut s = String::from("let record = { ");
+fn create_flat_record_string(n: i32) -> String {
+    let mut s = String::from("let record = {");
    for i in 0..n {
-        write!(s, "col_{i}: {i}, ").unwrap();
+        s.push_str(&format!("col_{}: {}", i, i));
+        if i < n - 1 {
+            s.push_str(", ");
+        }
    }
    s.push('}');
    s
 }

-fn create_nested_record_string(depth: usize) -> String {
+fn create_nested_record_string(depth: i32) -> String {
    let mut s = String::from("let record = {");
    for _ in 0..depth {
        s.push_str("col: {");
@ -161,7 +169,7 @@ fn create_nested_record_string(depth: usize) -> String {
    s
 }

-fn create_example_table_nrows(n: usize) -> String {
+fn create_example_table_nrows(n: i32) -> String {
    let mut s = String::from("let table = [[foo bar baz]; ");
    for i in 0..n {
        s.push_str(&format!("[0, 1, {i}]"));
@ -173,7 +181,7 @@ fn create_example_table_nrows(n: usize) -> String {
    s
 }

-fn bench_record_create(n: usize) -> impl IntoBenchmarks {
+fn bench_record_create(n: i32) -> impl IntoBenchmarks {
    bench_command(
        &format!("record_create_{n}"),
        &create_flat_record_string(n),
@ -182,7 +190,7 @@ fn bench_record_create(n: usize) -> impl IntoBenchmarks {
    )
 }

-fn bench_record_flat_access(n: usize) -> impl IntoBenchmarks {
+fn bench_record_flat_access(n: i32) -> impl IntoBenchmarks {
    let setup_command = create_flat_record_string(n);
    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
    bench_command(
@ -193,10 +201,10 @@ fn bench_record_flat_access(n: usize) -> impl IntoBenchmarks {
    )
 }

-fn bench_record_nested_access(n: usize) -> impl IntoBenchmarks {
+fn bench_record_nested_access(n: i32) -> impl IntoBenchmarks {
    let setup_command = create_nested_record_string(n);
    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
-    let nested_access = ".col".repeat(n);
+    let nested_access = ".col".repeat(n as usize);
    bench_command(
        &format!("record_nested_access_{n}"),
        &format!("$record{} | ignore", nested_access),
@ -205,18 +213,7 @@ fn bench_record_nested_access(n: usize) -> impl IntoBenchmarks {
    )
 }

-fn bench_record_insert(n: usize, m: usize) -> impl IntoBenchmarks {
-    let setup_command = create_flat_record_string(n);
-    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
-    let mut insert = String::from("$record");
-    for i in n..(n + m) {
-        write!(insert, " | insert col_{i} {i}").unwrap();
-    }
-    insert.push_str(" | ignore");
-    bench_command(&format!("record_insert_{n}_{m}"), &insert, stack, engine)
-}
-
-fn bench_table_create(n: usize) -> impl IntoBenchmarks {
+fn bench_table_create(n: i32) -> impl IntoBenchmarks {
    bench_command(
        &format!("table_create_{n}"),
        &create_example_table_nrows(n),
@ -225,7 +222,7 @@ fn bench_table_create(n: usize) -> impl IntoBenchmarks {
    )
 }

-fn bench_table_get(n: usize) -> impl IntoBenchmarks {
+fn bench_table_get(n: i32) -> impl IntoBenchmarks {
    let setup_command = create_example_table_nrows(n);
    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
    bench_command(
@ -236,7 +233,7 @@ fn bench_table_get(n: usize) -> impl IntoBenchmarks {
    )
 }

-fn bench_table_select(n: usize) -> impl IntoBenchmarks {
+fn bench_table_select(n: i32) -> impl IntoBenchmarks {
    let setup_command = create_example_table_nrows(n);
    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
    bench_command(
@ -247,29 +244,7 @@ fn bench_table_select(n: usize) -> impl IntoBenchmarks {
    )
 }

-fn bench_table_insert_row(n: usize, m: usize) -> impl IntoBenchmarks {
-    let setup_command = create_example_table_nrows(n);
-    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
-    let mut insert = String::from("$table");
-    for i in n..(n + m) {
-        write!(insert, " | insert {i} {{ foo: 0, bar: 1, baz: {i} }}").unwrap();
-    }
-    insert.push_str(" | ignore");
-    bench_command(&format!("table_insert_row_{n}_{m}"), &insert, stack, engine)
-}
-
-fn bench_table_insert_col(n: usize, m: usize) -> impl IntoBenchmarks {
-    let setup_command = create_example_table_nrows(n);
-    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
-    let mut insert = String::from("$table");
-    for i in 0..m {
-        write!(insert, " | insert col_{i} {i}").unwrap();
-    }
-    insert.push_str(" | ignore");
-    bench_command(&format!("table_insert_col_{n}_{m}"), &insert, stack, engine)
-}
-
-fn bench_eval_interleave(n: usize) -> impl IntoBenchmarks {
+fn bench_eval_interleave(n: i32) -> impl IntoBenchmarks {
    let engine = setup_engine();
    let stack = Stack::new();
    bench_command(
@ -280,7 +255,7 @@ fn bench_eval_interleave(n: usize) -> impl IntoBenchmarks {
    )
 }

-fn bench_eval_interleave_with_interrupt(n: usize) -> impl IntoBenchmarks {
+fn bench_eval_interleave_with_interrupt(n: i32) -> impl IntoBenchmarks {
    let mut engine = setup_engine();
    engine.set_signals(Signals::new(Arc::new(AtomicBool::new(false))));
    let stack = Stack::new();
@ -292,7 +267,7 @@ fn bench_eval_interleave_with_interrupt(n: usize) -> impl IntoBenchmarks {
    )
 }

-fn bench_eval_for(n: usize) -> impl IntoBenchmarks {
+fn bench_eval_for(n: i32) -> impl IntoBenchmarks {
    let engine = setup_engine();
    let stack = Stack::new();
    bench_command(
@ -303,7 +278,7 @@ fn bench_eval_for(n: usize) -> impl IntoBenchmarks {
    )
 }

-fn bench_eval_each(n: usize) -> impl IntoBenchmarks {
+fn bench_eval_each(n: i32) -> impl IntoBenchmarks {
    let engine = setup_engine();
    let stack = Stack::new();
    bench_command(
@ -314,7 +289,7 @@ fn bench_eval_each(n: usize) -> impl IntoBenchmarks {
    )
 }

-fn bench_eval_par_each(n: usize) -> impl IntoBenchmarks {
+fn bench_eval_par_each(n: i32) -> impl IntoBenchmarks {
    let engine = setup_engine();
    let stack = Stack::new();
    bench_command(
@ -455,14 +430,6 @@ tango_benchmarks!(
    bench_record_nested_access(32),
    bench_record_nested_access(64),
    bench_record_nested_access(128),
-    bench_record_insert(1, 1),
-    bench_record_insert(10, 1),
-    bench_record_insert(100, 1),
-    bench_record_insert(1000, 1),
-    bench_record_insert(1, 10),
-    bench_record_insert(10, 10),
-    bench_record_insert(100, 10),
-    bench_record_insert(1000, 10),
    // Table
    bench_table_create(1),
    bench_table_create(10),
@ -476,22 +443,6 @@ tango_benchmarks!(
    bench_table_select(10),
    bench_table_select(100),
    bench_table_select(1_000),
-    bench_table_insert_row(1, 1),
-    bench_table_insert_row(10, 1),
-    bench_table_insert_row(100, 1),
-    bench_table_insert_row(1000, 1),
-    bench_table_insert_row(1, 10),
-    bench_table_insert_row(10, 10),
-    bench_table_insert_row(100, 10),
-    bench_table_insert_row(1000, 10),
-    bench_table_insert_col(1, 1),
-    bench_table_insert_col(10, 1),
-    bench_table_insert_col(100, 1),
-    bench_table_insert_col(1000, 1),
-    bench_table_insert_col(1, 10),
-    bench_table_insert_col(10, 10),
-    bench_table_insert_col(100, 10),
-    bench_table_insert_col(1000, 10),
    // Eval
    // Interleave
    bench_eval_interleave(100),
--- a/clippy/wasm/clippy.toml
+++ b/clippy/wasm/clippy.toml
@ -1,3 +0,0 @@
-[[disallowed-types]]
-path = "std::time::Instant"
-reason = "WASM panics if used, use `web_time::Instant` instead"
--- a/crates/nu-cli/Cargo.toml
+++ b/crates/nu-cli/Cargo.toml
@ -5,43 +5,40 @@ repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cli"
 edition = "2021"
 license = "MIT"
 name = "nu-cli"
-version = "0.104.1"
+version = "0.100.0"

 [lib]
 bench = false

 [dev-dependencies]
-nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.104.1" }
-nu-command = { path = "../nu-command", version = "0.104.1" }
-nu-std = { path = "../nu-std", version = "0.104.1" }
-nu-test-support = { path = "../nu-test-support", version = "0.104.1" }
+nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.100.0" }
+nu-command = { path = "../nu-command", version = "0.100.0" }
+nu-test-support = { path = "../nu-test-support", version = "0.100.0" }
 rstest = { workspace = true, default-features = false }
 tempfile = { workspace = true }

 [dependencies]
-nu-cmd-base = { path = "../nu-cmd-base", version = "0.104.1" }
-nu-engine = { path = "../nu-engine", version = "0.104.1", features = ["os"] }
-nu-glob = { path = "../nu-glob", version = "0.104.1" }
-nu-path = { path = "../nu-path", version = "0.104.1" }
-nu-parser = { path = "../nu-parser", version = "0.104.1" }
-nu-plugin-engine = { path = "../nu-plugin-engine", version = "0.104.1", optional = true }
-nu-protocol = { path = "../nu-protocol", version = "0.104.1", features = ["os"] }
-nu-utils = { path = "../nu-utils", version = "0.104.1" }
-nu-color-config = { path = "../nu-color-config", version = "0.104.1" }
+nu-cmd-base = { path = "../nu-cmd-base", version = "0.100.0" }
+nu-engine = { path = "../nu-engine", version = "0.100.0" }
+nu-path = { path = "../nu-path", version = "0.100.0" }
+nu-parser = { path = "../nu-parser", version = "0.100.0" }
+nu-plugin-engine = { path = "../nu-plugin-engine", version = "0.100.0", optional = true }
+nu-protocol = { path = "../nu-protocol", version = "0.100.0" }
+nu-utils = { path = "../nu-utils", version = "0.100.0" }
+nu-color-config = { path = "../nu-color-config", version = "0.100.0" }
 nu-ansi-term = { workspace = true }
 reedline = { workspace = true, features = ["bashisms", "sqlite"] }

 chrono = { default-features = false, features = ["std"], workspace = true }
 crossterm = { workspace = true }
 fancy-regex = { workspace = true }
+fuzzy-matcher = { workspace = true }
 is_executable = { workspace = true }
 log = { workspace = true }
-lscolors = { workspace = true, default-features = false, features = ["nu-ansi-term"] }
 miette = { workspace = true, features = ["fancy-no-backtrace"] }
-nucleo-matcher = { workspace = true }
+lscolors = { workspace = true, default-features = false, features = ["nu-ansi-term"] }
 percent-encoding = { workspace = true }
 sysinfo = { workspace = true }
-strum = { workspace = true }
 unicode-segmentation = { workspace = true }
 uuid = { workspace = true, features = ["v4"] }
 which = { workspace = true }
--- a/crates/nu-cli/src/commands/commandline/edit.rs
+++ b/crates/nu-cli/src/commands/commandline/edit.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct CommandlineEdit;
+pub struct SubCommand;

-impl Command for CommandlineEdit {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "commandline edit"
    }
@ -29,7 +29,7 @@ impl Command for CommandlineEdit {
            .required(
                "str",
                SyntaxShape::String,
-                "The string to perform the operation with.",
+                "the string to perform the operation with",
            )
            .category(Category::Core)
    }
--- a/crates/nu-cli/src/commands/commandline/get_cursor.rs
+++ b/crates/nu-cli/src/commands/commandline/get_cursor.rs
@ -2,9 +2,9 @@ use nu_engine::command_prelude::*;
 use unicode_segmentation::UnicodeSegmentation;

 #[derive(Clone)]
-pub struct CommandlineGetCursor;
+pub struct SubCommand;

-impl Command for CommandlineGetCursor {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "commandline get-cursor"
    }
--- a/crates/nu-cli/src/commands/commandline/mod.rs
+++ b/crates/nu-cli/src/commands/commandline/mod.rs
@ -4,6 +4,6 @@ mod get_cursor;
 mod set_cursor;

 pub use commandline_::Commandline;
-pub use edit::CommandlineEdit;
-pub use get_cursor::CommandlineGetCursor;
-pub use set_cursor::CommandlineSetCursor;
+pub use edit::SubCommand as CommandlineEdit;
+pub use get_cursor::SubCommand as CommandlineGetCursor;
+pub use set_cursor::SubCommand as CommandlineSetCursor;
--- a/crates/nu-cli/src/commands/commandline/set_cursor.rs
+++ b/crates/nu-cli/src/commands/commandline/set_cursor.rs
@ -3,9 +3,9 @@ use nu_engine::command_prelude::*;
 use unicode_segmentation::UnicodeSegmentation;

 #[derive(Clone)]
-pub struct CommandlineSetCursor;
+pub struct SubCommand;

-impl Command for CommandlineSetCursor {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "commandline set-cursor"
    }
@ -18,7 +18,7 @@ impl Command for CommandlineSetCursor {
                "set the current cursor position to the end of the buffer",
                Some('e'),
            )
-            .optional("pos", SyntaxShape::Int, "Cursor position to be set.")
+            .optional("pos", SyntaxShape::Int, "Cursor position to be set")
            .category(Category::Core)
    }

--- a/crates/nu-cli/src/commands/history/history_.rs
+++ b/crates/nu-cli/src/commands/history/history_.rs
@ -1,5 +1,5 @@
 use nu_engine::command_prelude::*;
-use nu_protocol::{shell_error::io::IoError, HistoryFileFormat};
+use nu_protocol::HistoryFileFormat;
 use reedline::{
    FileBackedHistory, History as ReedlineHistory, HistoryItem, SearchDirection, SearchQuery,
    SqliteBackedHistory,
@ -93,11 +93,10 @@ impl Command for History {
                        )
                    })
                })
-                .ok_or(IoError::new(
-                    std::io::ErrorKind::NotFound,
-                    head,
-                    history_path,
-                ))?
+                .ok_or(ShellError::FileNotFound {
+                    file: history_path.display().to_string(),
+                    span: head,
+                })?
                .into_pipeline_data(head, signals)),
            HistoryFileFormat::Sqlite => Ok(history_reader
                .and_then(|h| {
@ -105,15 +104,15 @@ impl Command for History {
                        .ok()
                })
                .map(move |entries| {
-                    entries.into_iter().enumerate().map(move |(idx, entry)| {
-                        create_sqlite_history_record(idx, entry, long, head)
-                    })
+                    entries
+                        .into_iter()
+                        .enumerate()
+                        .map(move |(idx, entry)| create_history_record(idx, entry, long, head))
                })
-                .ok_or(IoError::new(
-                    std::io::ErrorKind::NotFound,
-                    head,
-                    history_path,
-                ))?
+                .ok_or(ShellError::FileNotFound {
+                    file: history_path.display().to_string(),
+                    span: head,
+                })?
                .into_pipeline_data(head, signals)),
        }
    }
@ -139,7 +138,7 @@ impl Command for History {
    }
 }

-fn create_sqlite_history_record(idx: usize, entry: HistoryItem, long: bool, head: Span) -> Value {
+fn create_history_record(idx: usize, entry: HistoryItem, long: bool, head: Span) -> Value {
    //1. Format all the values
    //2. Create a record of either short or long columns and values

@ -150,8 +149,11 @@ fn create_sqlite_history_record(idx: usize, entry: HistoryItem, long: bool, head
            .unwrap_or_default(),
        head,
    );
-    let start_timestamp_value = Value::date(
-        entry.start_timestamp.unwrap_or_default().fixed_offset(),
+    let start_timestamp_value = Value::string(
+        entry
+            .start_timestamp
+            .map(|time| time.to_string())
+            .unwrap_or_default(),
        head,
    );
    let command_value = Value::string(entry.command_line, head);
--- a/crates/nu-cli/src/commands/history/history_import.rs
+++ b/crates/nu-cli/src/commands/history/history_import.rs
@ -1,10 +1,7 @@
 use std::path::{Path, PathBuf};

 use nu_engine::command_prelude::*;
-use nu_protocol::{
-    shell_error::{self, io::IoError},
-    HistoryFileFormat,
-};
+use nu_protocol::HistoryFileFormat;

 use reedline::{
    FileBackedHistory, History, HistoryItem, ReedlineError, SearchQuery, SqliteBackedHistory,
@ -21,12 +18,12 @@ impl Command for HistoryImport {
    }

    fn description(&self) -> &str {
-        "Import command line history."
+        "Import command line history"
    }

    fn extra_description(&self) -> &str {
        r#"Can import history from input, either successive command lines or more detailed records. If providing records, available fields are:
-    command, start_timestamp, hostname, cwd, duration, exit_status.
+    command_line, id, start_timestamp, hostname, cwd, duration, exit_status.

 If no input is provided, will import all history items from existing history in the other format: if current history is stored in sqlite, it will store it in plain text and vice versa.

@ -38,7 +35,6 @@ Note that history item IDs are ignored when importing from file."#
            .category(Category::History)
            .input_output_types(vec![
                (Type::Nothing, Type::Nothing),
-                (Type::String, Type::Nothing),
                (Type::List(Box::new(Type::String)), Type::Nothing),
                (Type::table(), Type::Nothing),
            ])
@ -72,16 +68,17 @@ Note that history item IDs are ignored when importing from file."#
        call: &Call,
        input: PipelineData,
    ) -> Result<PipelineData, ShellError> {
-        let span = call.head;
        let ok = Ok(Value::nothing(call.head).into_pipeline_data());

        let Some(history) = engine_state.history_config() else {
            return ok;
        };
        let Some(current_history_path) = history.file_path() else {
-            return Err(ShellError::ConfigDirNotFound { span: span.into() });
+            return Err(ShellError::ConfigDirNotFound {
+                span: Some(call.head),
+            });
        };
-        if let Some(bak_path) = backup(&current_history_path, span)? {
+        if let Some(bak_path) = backup(&current_history_path)? {
            println!("Backed history to {}", bak_path.display());
        }
        match input {
@ -218,7 +215,7 @@ fn item_from_record(mut rec: Record, span: Span) -> Result<HistoryItem, ShellErr
        hostname: get(rec, fields::HOSTNAME, |v| Ok(v.as_str()?.to_owned()))?,
        cwd: get(rec, fields::CWD, |v| Ok(v.as_str()?.to_owned()))?,
        exit_status: get(rec, fields::EXIT_STATUS, |v| v.as_int())?,
-        duration: get(rec, fields::DURATION, |v| duration_from_value(v, span))?,
+        duration: get(rec, fields::DURATION, duration_from_value)?,
        more_info: None,
        // TODO: Currently reedline doesn't let you create session IDs.
        session_id: None,
@ -234,21 +231,19 @@ fn item_from_record(mut rec: Record, span: Span) -> Result<HistoryItem, ShellErr
    Ok(item)
 }

-fn duration_from_value(v: Value, span: Span) -> Result<std::time::Duration, ShellError> {
+fn duration_from_value(v: Value) -> Result<std::time::Duration, ShellError> {
    chrono::Duration::nanoseconds(v.as_duration()?)
        .to_std()
-        .map_err(|_| ShellError::NeedsPositiveValue { span })
+        .map_err(|_| ShellError::IOError {
+            msg: "negative duration not supported".to_string(),
+        })
 }

-fn find_backup_path(path: &Path, span: Span) -> Result<PathBuf, ShellError> {
+fn find_backup_path(path: &Path) -> Result<PathBuf, ShellError> {
    let Ok(mut bak_path) = path.to_path_buf().into_os_string().into_string() else {
        // This isn't fundamentally problem, but trying to work with OsString is a nightmare.
-        return Err(ShellError::GenericError {
-            error: "History path not UTF-8".to_string(),
-            msg: "History path must be representable as UTF-8".to_string(),
-            span: Some(span),
-            help: None,
-            inner: vec![],
+        return Err(ShellError::IOError {
+            msg: "History path mush be representable as UTF-8".to_string(),
        });
    };
    bak_path.push_str(".bak");
@ -264,45 +259,24 @@ fn find_backup_path(path: &Path, span: Span) -> Result<PathBuf, ShellError> {
            return Ok(PathBuf::from(bak_path));
        }
    }
-    Err(ShellError::GenericError {
-        error: "Too many backup files".to_string(),
-        msg: "Found too many existing backup files".to_string(),
-        span: Some(span),
-        help: None,
-        inner: vec![],
+    Err(ShellError::IOError {
+        msg: "Too many existing backup files".to_string(),
    })
 }

-fn backup(path: &Path, span: Span) -> Result<Option<PathBuf>, ShellError> {
+fn backup(path: &Path) -> Result<Option<PathBuf>, ShellError> {
    match path.metadata() {
        Ok(md) if md.is_file() => (),
        Ok(_) => {
-            return Err(IoError::new_with_additional_context(
-                shell_error::io::ErrorKind::NotAFile,
-                span,
-                PathBuf::from(path),
-                "history path exists but is not a file",
-            )
-            .into())
+            return Err(ShellError::IOError {
+                msg: "history path exists but is not a file".to_string(),
+            })
        }
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
-        Err(e) => {
-            return Err(IoError::new_internal(
-                e.kind(),
-                "Could not get metadata",
-                nu_protocol::location!(),
-            )
-            .into())
-        }
+        Err(e) => return Err(e.into()),
    }
-    let bak_path = find_backup_path(path, span)?;
-    std::fs::copy(path, &bak_path).map_err(|err| {
-        IoError::new_internal(
-            err.kind(),
-            "Could not copy backup",
-            nu_protocol::location!(),
-        )
-    })?;
+    let bak_path = find_backup_path(path)?;
+    std::fs::copy(path, &bak_path)?;
    Ok(Some(bak_path))
 }

@ -413,7 +387,7 @@ mod tests {
        for name in existing {
            std::fs::File::create_new(dir.path().join(name)).unwrap();
        }
-        let got = find_backup_path(&dir.path().join("history.dat"), Span::test_data()).unwrap();
+        let got = find_backup_path(&dir.path().join("history.dat")).unwrap();
        assert_eq!(got, dir.path().join(want))
    }

@ -425,7 +399,7 @@ mod tests {
        write!(&mut history, "123").unwrap();
        let want_bak_path = dir.path().join("history.dat.bak");
        assert_eq!(
-            backup(&dir.path().join("history.dat"), Span::test_data()),
+            backup(&dir.path().join("history.dat")),
            Ok(Some(want_bak_path.clone()))
        );
        let got_data = String::from_utf8(std::fs::read(want_bak_path).unwrap()).unwrap();
@ -435,7 +409,7 @@ mod tests {
    #[test]
    fn test_backup_no_file() {
        let dir = tempfile::tempdir().unwrap();
-        let bak_path = backup(&dir.path().join("history.dat"), Span::test_data()).unwrap();
+        let bak_path = backup(&dir.path().join("history.dat")).unwrap();
        assert!(bak_path.is_none());
    }
 }
--- a/crates/nu-cli/src/commands/keybindings_listen.rs
+++ b/crates/nu-cli/src/commands/keybindings_listen.rs
@ -2,7 +2,6 @@ use crossterm::{
    event::Event, event::KeyCode, event::KeyEvent, execute, terminal, QueueableCommand,
 };
 use nu_engine::command_prelude::*;
-use nu_protocol::shell_error::io::IoError;
 use std::io::{stdout, Write};

 #[derive(Clone)]
@ -40,13 +39,7 @@ impl Command for KeybindingsListen {
        match print_events(engine_state) {
            Ok(v) => Ok(v.into_pipeline_data()),
            Err(e) => {
-                terminal::disable_raw_mode().map_err(|err| {
-                    IoError::new_internal(
-                        err.kind(),
-                        "Could not disable raw mode",
-                        nu_protocol::location!(),
-                    )
-                })?;
+                terminal::disable_raw_mode()?;
                Err(ShellError::GenericError {
                    error: "Error with input".into(),
                    msg: "".into(),
@ -70,20 +63,8 @@ impl Command for KeybindingsListen {
 pub fn print_events(engine_state: &EngineState) -> Result<Value, ShellError> {
    let config = engine_state.get_config();

-    stdout().flush().map_err(|err| {
-        IoError::new_internal(
-            err.kind(),
-            "Could not flush stdout",
-            nu_protocol::location!(),
-        )
-    })?;
-    terminal::enable_raw_mode().map_err(|err| {
-        IoError::new_internal(
-            err.kind(),
-            "Could not enable raw mode",
-            nu_protocol::location!(),
-        )
-    })?;
+    stdout().flush()?;
+    terminal::enable_raw_mode()?;

    if config.use_kitty_protocol {
        if let Ok(false) = crossterm::terminal::supports_keyboard_enhancement() {
@ -113,9 +94,7 @@ pub fn print_events(engine_state: &EngineState) -> Result<Value, ShellError> {
    let mut stdout = std::io::BufWriter::new(std::io::stderr());

    loop {
-        let event = crossterm::event::read().map_err(|err| {
-            IoError::new_internal(err.kind(), "Could not read event", nu_protocol::location!())
-        })?;
+        let event = crossterm::event::read()?;
        if event == Event::Key(KeyCode::Esc.into()) {
            break;
        }
@ -134,25 +113,9 @@ pub fn print_events(engine_state: &EngineState) -> Result<Value, ShellError> {

            _ => "".to_string(),
        };
-        stdout.queue(crossterm::style::Print(o)).map_err(|err| {
-            IoError::new_internal(
-                err.kind(),
-                "Could not print output record",
-                nu_protocol::location!(),
-            )
-        })?;
-        stdout
-            .queue(crossterm::style::Print("\r\n"))
-            .map_err(|err| {
-                IoError::new_internal(
-                    err.kind(),
-                    "Could not print linebreak",
-                    nu_protocol::location!(),
-                )
-            })?;
-        stdout.flush().map_err(|err| {
-            IoError::new_internal(err.kind(), "Could not flush", nu_protocol::location!())
-        })?;
+        stdout.queue(crossterm::style::Print(o))?;
+        stdout.queue(crossterm::style::Print("\r\n"))?;
+        stdout.flush()?;
    }

    if config.use_kitty_protocol {
@ -162,13 +125,7 @@ pub fn print_events(engine_state: &EngineState) -> Result<Value, ShellError> {
        );
    }

-    terminal::disable_raw_mode().map_err(|err| {
-        IoError::new_internal(
-            err.kind(),
-            "Could not disable raw mode",
-            nu_protocol::location!(),
-        )
-    })?;
+    terminal::disable_raw_mode()?;

    Ok(Value::nothing(Span::unknown()))
 }
--- a/crates/nu-cli/src/completions/attribute_completions.rs
+++ b/crates/nu-cli/src/completions/attribute_completions.rs
@ -1,87 +0,0 @@
-use super::{completion_options::NuMatcher, SemanticSuggestion};
-use crate::{
-    completions::{Completer, CompletionOptions},
-    SuggestionKind,
-};
-use nu_protocol::{
-    engine::{Stack, StateWorkingSet},
-    Span,
-};
-use reedline::Suggestion;
-
-pub struct AttributeCompletion;
-pub struct AttributableCompletion;
-
-impl Completer for AttributeCompletion {
-    fn fetch(
-        &mut self,
-        working_set: &StateWorkingSet,
-        _stack: &Stack,
-        prefix: impl AsRef<str>,
-        span: Span,
-        offset: usize,
-        options: &CompletionOptions,
-    ) -> Vec<SemanticSuggestion> {
-        let mut matcher = NuMatcher::new(prefix, options);
-
-        let attr_commands =
-            working_set.find_commands_by_predicate(|s| s.starts_with(b"attr "), true);
-
-        for (decl_id, name, desc, ty) in attr_commands {
-            let name = name.strip_prefix(b"attr ").unwrap_or(&name);
-            matcher.add_semantic_suggestion(SemanticSuggestion {
-                suggestion: Suggestion {
-                    value: String::from_utf8_lossy(name).into_owned(),
-                    description: desc,
-                    style: None,
-                    extra: None,
-                    span: reedline::Span {
-                        start: span.start - offset,
-                        end: span.end - offset,
-                    },
-                    append_whitespace: false,
-                },
-                kind: Some(SuggestionKind::Command(ty, Some(decl_id))),
-            });
-        }
-
-        matcher.results()
-    }
-}
-
-impl Completer for AttributableCompletion {
-    fn fetch(
-        &mut self,
-        working_set: &StateWorkingSet,
-        _stack: &Stack,
-        prefix: impl AsRef<str>,
-        span: Span,
-        offset: usize,
-        options: &CompletionOptions,
-    ) -> Vec<SemanticSuggestion> {
-        let mut matcher = NuMatcher::new(prefix, options);
-
-        for s in ["def", "extern", "export def", "export extern"] {
-            let decl_id = working_set
-                .find_decl(s.as_bytes())
-                .expect("internal error, builtin declaration not found");
-            let cmd = working_set.get_decl(decl_id);
-            matcher.add_semantic_suggestion(SemanticSuggestion {
-                suggestion: Suggestion {
-                    value: cmd.name().into(),
-                    description: Some(cmd.description().into()),
-                    style: None,
-                    extra: None,
-                    span: reedline::Span {
-                        start: span.start - offset,
-                        end: span.end - offset,
-                    },
-                    append_whitespace: false,
-                },
-                kind: Some(SuggestionKind::Command(cmd.command_type(), None)),
-            });
-        }
-
-        matcher.results()
-    }
-}
--- a/crates/nu-cli/src/completions/base.rs
+++ b/crates/nu-cli/src/completions/base.rs
@ -1,7 +1,7 @@
 use crate::completions::CompletionOptions;
 use nu_protocol::{
    engine::{Stack, StateWorkingSet},
-    DeclId, Span,
+    Span,
 };
 use reedline::Suggestion;

@ -12,9 +12,10 @@ pub trait Completer {
        &mut self,
        working_set: &StateWorkingSet,
        stack: &Stack,
-        prefix: impl AsRef<str>,
+        prefix: &[u8],
        span: Span,
        offset: usize,
+        pos: usize,
        options: &CompletionOptions,
    ) -> Vec<SemanticSuggestion>;
 }
@ -28,15 +29,8 @@ pub struct SemanticSuggestion {
 // TODO: think about name: maybe suggestion context?
 #[derive(Clone, Debug, PartialEq)]
 pub enum SuggestionKind {
-    Command(nu_protocol::engine::CommandType, Option<DeclId>),
-    Value(nu_protocol::Type),
-    CellPath,
-    Directory,
-    File,
-    Flag,
-    Module,
-    Operator,
-    Variable,
+    Command(nu_protocol::engine::CommandType),
+    Type(nu_protocol::Type),
 }

 impl From<Suggestion> for SemanticSuggestion {
--- a/crates/nu-cli/src/completions/cell_path_completions.rs
+++ b/crates/nu-cli/src/completions/cell_path_completions.rs
@ -1,153 +0,0 @@
-use std::borrow::Cow;
-
-use crate::completions::{Completer, CompletionOptions, SemanticSuggestion, SuggestionKind};
-use nu_engine::{column::get_columns, eval_variable};
-use nu_protocol::{
-    ast::{Expr, Expression, FullCellPath, PathMember},
-    engine::{Stack, StateWorkingSet},
-    eval_const::eval_constant,
-    ShellError, Span, Value,
-};
-use reedline::Suggestion;
-
-use super::completion_options::NuMatcher;
-
-pub struct CellPathCompletion<'a> {
-    pub full_cell_path: &'a FullCellPath,
-    pub position: usize,
-}
-
-fn prefix_from_path_member(member: &PathMember, pos: usize) -> (String, Span) {
-    let (prefix_str, start) = match member {
-        PathMember::String { val, span, .. } => (val, span.start),
-        PathMember::Int { val, span, .. } => (&val.to_string(), span.start),
-    };
-    let prefix_str = prefix_str.get(..pos + 1 - start).unwrap_or(prefix_str);
-    // strip wrapping quotes
-    let quotations = ['"', '\'', '`'];
-    let prefix_str = prefix_str.strip_prefix(quotations).unwrap_or(prefix_str);
-    (prefix_str.to_string(), Span::new(start, pos + 1))
-}
-
-impl Completer for CellPathCompletion<'_> {
-    fn fetch(
-        &mut self,
-        working_set: &StateWorkingSet,
-        stack: &Stack,
-        _prefix: impl AsRef<str>,
-        _span: Span,
-        offset: usize,
-        options: &CompletionOptions,
-    ) -> Vec<SemanticSuggestion> {
-        let mut prefix_str = String::new();
-        // position at dots, e.g. `$env.config.<TAB>`
-        let mut span = Span::new(self.position + 1, self.position + 1);
-        let mut path_member_num_before_pos = 0;
-        for member in self.full_cell_path.tail.iter() {
-            if member.span().end <= self.position {
-                path_member_num_before_pos += 1;
-            } else if member.span().contains(self.position) {
-                (prefix_str, span) = prefix_from_path_member(member, self.position);
-                break;
-            }
-        }
-
-        let current_span = reedline::Span {
-            start: span.start - offset,
-            end: span.end - offset,
-        };
-
-        let mut matcher = NuMatcher::new(prefix_str, options);
-        let path_members = self
-            .full_cell_path
-            .tail
-            .get(0..path_member_num_before_pos)
-            .unwrap_or_default();
-        let value = eval_cell_path(
-            working_set,
-            stack,
-            &self.full_cell_path.head,
-            path_members,
-            span,
-        )
-        .unwrap_or_default();
-
-        for suggestion in get_suggestions_by_value(&value, current_span) {
-            matcher.add_semantic_suggestion(suggestion);
-        }
-        matcher.results()
-    }
-}
-
-/// Follow cell path to get the value
-/// NOTE: This is a relatively lightweight implementation,
-/// so it may fail to get the exact value when the expression is complicated.
-/// One failing example would be `[$foo].0`
-pub(crate) fn eval_cell_path(
-    working_set: &StateWorkingSet,
-    stack: &Stack,
-    head: &Expression,
-    path_members: &[PathMember],
-    span: Span,
-) -> Result<Value, ShellError> {
-    // evaluate the head expression to get its value
-    let head_value = if let Expr::Var(var_id) = head.expr {
-        working_set
-            .get_variable(var_id)
-            .const_val
-            .to_owned()
-            .map_or_else(
-                || eval_variable(working_set.permanent_state, stack, var_id, span),
-                Ok,
-            )
-    } else {
-        eval_constant(working_set, head)
-    }?;
-    head_value
-        .follow_cell_path(path_members, false)
-        .map(Cow::into_owned)
-}
-
-fn get_suggestions_by_value(
-    value: &Value,
-    current_span: reedline::Span,
-) -> Vec<SemanticSuggestion> {
-    let to_suggestion = |s: String, v: Option<&Value>| {
-        // Check if the string needs quoting
-        let value = if s.is_empty()
-            || s.chars()
-                .any(|c: char| !(c.is_ascii_alphabetic() || ['_', '-'].contains(&c)))
-        {
-            format!("{:?}", s)
-        } else {
-            s
-        };
-
-        SemanticSuggestion {
-            suggestion: Suggestion {
-                value,
-                span: current_span,
-                description: v.map(|v| v.get_type().to_string()),
-                ..Suggestion::default()
-            },
-            kind: Some(SuggestionKind::CellPath),
-        }
-    };
-    match value {
-        Value::Record { val, .. } => val
-            .columns()
-            .map(|s| to_suggestion(s.to_string(), val.get(s)))
-            .collect(),
-        Value::List { vals, .. } => get_columns(vals.as_slice())
-            .into_iter()
-            .map(|s| {
-                let sub_val = vals
-                    .first()
-                    .and_then(|v| v.as_record().ok())
-                    .and_then(|rv| rv.get(&s));
-                to_suggestion(s, sub_val)
-            })
-            .collect(),
-        _ => vec![],
-    }
-}
--- a/crates/nu-cli/src/completions/command_completions.rs
+++ b/crates/nu-cli/src/completions/command_completions.rs
@ -1,37 +1,47 @@
-use std::collections::HashMap;
-
 use crate::{
-    completions::{Completer, CompletionOptions},
+    completions::{Completer, CompletionOptions, MatchAlgorithm},
    SuggestionKind,
 };
+use nu_parser::FlatShape;
 use nu_protocol::{
-    engine::{CommandType, Stack, StateWorkingSet},
+    engine::{CachedFile, Stack, StateWorkingSet},
    Span,
 };
 use reedline::Suggestion;

-use super::{completion_options::NuMatcher, SemanticSuggestion};
+use super::{completion_common::sort_suggestions, SemanticSuggestion};

 pub struct CommandCompletion {
-    /// Whether to include internal commands
-    pub internals: bool,
-    /// Whether to include external commands
-    pub externals: bool,
+    flattened: Vec<(Span, FlatShape)>,
+    flat_shape: FlatShape,
+    force_completion_after_space: bool,
 }

 impl CommandCompletion {
+    pub fn new(
+        flattened: Vec<(Span, FlatShape)>,
+        flat_shape: FlatShape,
+        force_completion_after_space: bool,
+    ) -> Self {
+        Self {
+            flattened,
+            flat_shape,
+            force_completion_after_space,
+        }
+    }
+
    fn external_command_completion(
        &self,
        working_set: &StateWorkingSet,
-        sugg_span: reedline::Span,
-        matched_internal: impl Fn(&str) -> bool,
-        matcher: &mut NuMatcher<String>,
-    ) -> HashMap<String, SemanticSuggestion> {
-        let mut suggs = HashMap::new();
+        prefix: &str,
+        match_algorithm: MatchAlgorithm,
+    ) -> Vec<String> {
+        let mut executables = vec![];

-        let paths = working_set.permanent_state.get_env_var_insensitive("path");
+        // os agnostic way to get the PATH env var
+        let paths = working_set.permanent_state.get_path_env_var();

-        if let Some((_, paths)) = paths {
+        if let Some(paths) = paths {
            if let Ok(paths) = paths.as_list() {
                for path in paths {
                    let path = path.coerce_str().unwrap_or_default();
@ -44,43 +54,24 @@ impl CommandCompletion {
                                .completions
                                .external
                                .max_results
-                                <= suggs.len() as i64
+                                > executables.len() as i64
+                                && !executables.contains(
+                                    &item
+                                        .path()
+                                        .file_name()
+                                        .map(|x| x.to_string_lossy().to_string())
+                                        .unwrap_or_default(),
+                                )
+                                && matches!(
+                                    item.path().file_name().map(|x| match_algorithm
+                                        .matches_str(&x.to_string_lossy(), prefix)),
+                                    Some(true)
+                                )
+                                && is_executable::is_executable(item.path())
                            {
-                                break;
-                            }
-                            let Ok(name) = item.file_name().into_string() else {
-                                continue;
-                            };
-                            let value = if matched_internal(&name) {
-                                format!("^{}", name)
-                            } else {
-                                name.clone()
-                            };
-                            if suggs.contains_key(&value) {
-                                continue;
-                            }
-                            // TODO: check name matching before a relative heavy IO involved
-                            // `is_executable` for performance consideration, should avoid
-                            // duplicated `match_aux` call for matched items in the future
-                            if matcher.matches(&name) && is_executable::is_executable(item.path()) {
-                                // If there's an internal command with the same name, adds ^cmd to the
-                                // matcher so that both the internal and external command are included
-                                matcher.add(&name, value.clone());
-                                suggs.insert(
-                                    value.clone(),
-                                    SemanticSuggestion {
-                                        suggestion: Suggestion {
-                                            value,
-                                            span: sugg_span,
-                                            append_whitespace: true,
-                                            ..Default::default()
-                                        },
-                                        kind: Some(SuggestionKind::Command(
-                                            CommandType::External,
-                                            None,
-                                        )),
-                                    },
-                                );
+                                if let Ok(name) = item.file_name().into_string() {
+                                    executables.push(name);
+                                }
                            }
                        }
                    }
@ -88,7 +79,77 @@ impl CommandCompletion {
            }
        }

-        suggs
+        executables
+    }
+
+    fn complete_commands(
+        &self,
+        working_set: &StateWorkingSet,
+        span: Span,
+        offset: usize,
+        find_externals: bool,
+        match_algorithm: MatchAlgorithm,
+    ) -> Vec<SemanticSuggestion> {
+        let partial = working_set.get_span_contents(span);
+
+        let filter_predicate = |command: &[u8]| match_algorithm.matches_u8(command, partial);
+
+        let mut results = working_set
+            .find_commands_by_predicate(filter_predicate, true)
+            .into_iter()
+            .map(move |x| SemanticSuggestion {
+                suggestion: Suggestion {
+                    value: String::from_utf8_lossy(&x.0).to_string(),
+                    description: x.1,
+                    span: reedline::Span::new(span.start - offset, span.end - offset),
+                    append_whitespace: true,
+                    ..Suggestion::default()
+                },
+                kind: Some(SuggestionKind::Command(x.2)),
+            })
+            .collect::<Vec<_>>();
+
+        let partial = working_set.get_span_contents(span);
+        let partial = String::from_utf8_lossy(partial).to_string();
+
+        if find_externals {
+            let results_external = self
+                .external_command_completion(working_set, &partial, match_algorithm)
+                .into_iter()
+                .map(move |x| SemanticSuggestion {
+                    suggestion: Suggestion {
+                        value: x,
+                        span: reedline::Span::new(span.start - offset, span.end - offset),
+                        append_whitespace: true,
+                        ..Suggestion::default()
+                    },
+                    // TODO: is there a way to create a test?
+                    kind: None,
+                });
+
+            let results_strings: Vec<String> =
+                results.iter().map(|x| x.suggestion.value.clone()).collect();
+
+            for external in results_external {
+                if results_strings.contains(&external.suggestion.value) {
+                    results.push(SemanticSuggestion {
+                        suggestion: Suggestion {
+                            value: format!("^{}", external.suggestion.value),
+                            span: external.suggestion.span,
+                            append_whitespace: true,
+                            ..Suggestion::default()
+                        },
+                        kind: external.kind,
+                    })
+                } else {
+                    results.push(external)
+                }
+            }
+
+            results
+        } else {
+            results
+        }
    }
 }

@ -97,62 +158,175 @@ impl Completer for CommandCompletion {
        &mut self,
        working_set: &StateWorkingSet,
        _stack: &Stack,
-        prefix: impl AsRef<str>,
+        prefix: &[u8],
        span: Span,
        offset: usize,
+        pos: usize,
        options: &CompletionOptions,
    ) -> Vec<SemanticSuggestion> {
-        let mut matcher = NuMatcher::new(prefix, options);
+        let last = self
+            .flattened
+            .iter()
+            .rev()
+            .skip_while(|x| x.0.end > pos)
+            .take_while(|x| {
+                matches!(
+                    x.1,
+                    FlatShape::InternalCall(_)
+                        | FlatShape::External
+                        | FlatShape::ExternalArg
+                        | FlatShape::Literal
+                        | FlatShape::String
+                )
+            })
+            .last();

-        let sugg_span = reedline::Span::new(span.start - offset, span.end - offset);
-
-        let mut internal_suggs = HashMap::new();
-        if self.internals {
-            let filtered_commands = working_set.find_commands_by_predicate(
-                |name| {
-                    let name = String::from_utf8_lossy(name);
-                    matcher.add(&name, name.to_string())
-                },
-                true,
-            );
-            for (decl_id, name, description, typ) in filtered_commands {
-                let name = String::from_utf8_lossy(&name);
-                internal_suggs.insert(
-                    name.to_string(),
-                    SemanticSuggestion {
-                        suggestion: Suggestion {
-                            value: name.to_string(),
-                            description,
-                            span: sugg_span,
-                            append_whitespace: true,
-                            ..Suggestion::default()
-                        },
-                        kind: Some(SuggestionKind::Command(typ, Some(decl_id))),
-                    },
-                );
-            }
-        }
-
-        let mut external_suggs = if self.externals {
-            self.external_command_completion(
+        // The last item here would be the earliest shape that could possible by part of this subcommand
+        let subcommands = if let Some(last) = last {
+            self.complete_commands(
                working_set,
-                sugg_span,
-                |name| internal_suggs.contains_key(name),
-                &mut matcher,
+                Span::new(last.0.start, pos),
+                offset,
+                false,
+                options.match_algorithm,
            )
        } else {
-            HashMap::new()
+            vec![]
        };

-        let mut res = Vec::new();
-        for cmd_name in matcher.results() {
-            if let Some(sugg) = internal_suggs
-                .remove(&cmd_name)
-                .or_else(|| external_suggs.remove(&cmd_name))
-            {
-                res.push(sugg);
-            }
+        if !subcommands.is_empty() {
+            return sort_suggestions(&String::from_utf8_lossy(prefix), subcommands, options);
+        }
+
+        let config = working_set.get_config();
+        let commands = if matches!(self.flat_shape, nu_parser::FlatShape::External)
+            || matches!(self.flat_shape, nu_parser::FlatShape::InternalCall(_))
+            || ((span.end - span.start) == 0)
+            || is_passthrough_command(working_set.delta.get_file_contents())
+        {
+            // we're in a gap or at a command
+            if working_set.get_span_contents(span).is_empty() && !self.force_completion_after_space
+            {
+                return vec![];
+            }
+            self.complete_commands(
+                working_set,
+                span,
+                offset,
+                config.completions.external.enable,
+                options.match_algorithm,
+            )
+        } else {
+            vec![]
+        };
+
+        sort_suggestions(&String::from_utf8_lossy(prefix), commands, options)
+    }
+}
+
+pub fn find_non_whitespace_index(contents: &[u8], start: usize) -> usize {
+    match contents.get(start..) {
+        Some(contents) => {
+            contents
+                .iter()
+                .take_while(|x| x.is_ascii_whitespace())
+                .count()
+                + start
+        }
+        None => start,
+    }
+}
+
+pub fn is_passthrough_command(working_set_file_contents: &[CachedFile]) -> bool {
+    for cached_file in working_set_file_contents {
+        let contents = &cached_file.content;
+        let last_pipe_pos_rev = contents.iter().rev().position(|x| x == &b'|');
+        let last_pipe_pos = last_pipe_pos_rev.map(|x| contents.len() - x).unwrap_or(0);
+
+        let cur_pos = find_non_whitespace_index(contents, last_pipe_pos);
+
+        let result = match contents.get(cur_pos..) {
+            Some(contents) => contents.starts_with(b"sudo ") || contents.starts_with(b"doas "),
+            None => false,
+        };
+        if result {
+            return true;
+        }
+    }
+    false
+}
+
+#[cfg(test)]
+mod command_completions_tests {
+    use super::*;
+    use nu_protocol::engine::EngineState;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_find_non_whitespace_index() {
+        let commands = [
+            ("    hello", 4),
+            ("sudo ", 0),
+            (" 	sudo ", 2),
+            ("	 sudo ", 2),
+            ("	hello ", 1),
+            ("	  hello ", 3),
+            ("    hello | sudo ", 4),
+            ("     sudo|sudo", 5),
+            ("sudo | sudo ", 0),
+            ("	hello sud", 1),
+        ];
+        for (idx, ele) in commands.iter().enumerate() {
+            let index = find_non_whitespace_index(ele.0.as_bytes(), 0);
+            assert_eq!(index, ele.1, "Failed on index {}", idx);
+        }
+    }
+
+    #[test]
+    fn test_is_last_command_passthrough() {
+        let commands = [
+            ("    hello", false),
+            ("    sudo ", true),
+            ("sudo ", true),
+            ("	hello", false),
+            ("	sudo", false),
+            ("	sudo ", true),
+            (" 	sudo ", true),
+            ("	 sudo ", true),
+            ("	hello ", false),
+            ("    hello | sudo ", true),
+            ("    sudo|sudo", false),
+            ("sudo | sudo ", true),
+            ("	hello sud", false),
+            ("	sudo | sud ", false),
+            ("	sudo|sudo ", true),
+            (" 	sudo | sudo ls | sudo ", true),
+        ];
+        for (idx, ele) in commands.iter().enumerate() {
+            let input = ele.0.as_bytes();
+
+            let mut engine_state = EngineState::new();
+            engine_state.add_file("test.nu".into(), Arc::new([]));
+
+            let delta = {
+                let mut working_set = StateWorkingSet::new(&engine_state);
+                let _ = working_set.add_file("child.nu".into(), input);
+                working_set.render()
+            };
+
+            let result = engine_state.merge_delta(delta);
+            assert!(
+                result.is_ok(),
+                "Merge delta has failed: {}",
+                result.err().unwrap()
+            );
+
+            let is_passthrough_command = is_passthrough_command(engine_state.get_file_contents());
+            assert_eq!(
+                is_passthrough_command, ele.1,
+                "index for '{}': {}",
+                ele.0, idx
+            );
        }
-        res
    }
 }
--- a/crates/nu-cli/src/completions/completer.rs
+++ b/crates/nu-cli/src/completions/completer.rs
--- a/crates/nu-cli/src/completions/completion_common.rs
+++ b/crates/nu-cli/src/completions/completion_common.rs
@ -1,20 +1,22 @@
-use super::{completion_options::NuMatcher, MatchAlgorithm};
-use crate::completions::CompletionOptions;
+use super::MatchAlgorithm;
+use crate::{
+    completions::{matches, CompletionOptions},
+    SemanticSuggestion,
+};
+use fuzzy_matcher::{skim::SkimMatcherV2, FuzzyMatcher};
 use nu_ansi_term::Style;
 use nu_engine::env_to_string;
 use nu_path::dots::expand_ndots;
 use nu_path::{expand_to_real_path, home_dir};
 use nu_protocol::{
    engine::{EngineState, Stack, StateWorkingSet},
-    Span,
+    CompletionSort, Span,
 };
 use nu_utils::get_ls_colors;
-use nu_utils::IgnoreCaseExt;
 use std::path::{is_separator, Component, Path, PathBuf, MAIN_SEPARATOR as SEP};

 #[derive(Clone, Default)]
 pub struct PathBuiltFromString {
-    cwd: PathBuf,
    parts: Vec<String>,
    isdir: bool,
 }
@ -22,101 +24,82 @@ pub struct PathBuiltFromString {
 /// Recursively goes through paths that match a given `partial`.
 /// built: State struct for a valid matching path built so far.
 ///
-/// `want_directory`: Whether we want only directories as completion matches.
-/// Some commands like `cd` can only be run on directories whereas others
-/// like `ls` can be run on regular files as well.
-///
 /// `isdir`: whether the current partial path has a trailing slash.
 /// Parsing a path string into a pathbuf loses that bit of information.
 ///
-/// `enable_exact_match`: Whether match algorithm is Prefix and all previous components
-/// of the path matched a directory exactly.
-fn complete_rec(
+/// want_directory: Whether we want only directories as completion matches.
+/// Some commands like `cd` can only be run on directories whereas others
+/// like `ls` can be run on regular files as well.
+pub fn complete_rec(
    partial: &[&str],
-    built_paths: &[PathBuiltFromString],
+    built: &PathBuiltFromString,
+    cwd: &Path,
    options: &CompletionOptions,
    want_directory: bool,
    isdir: bool,
-    enable_exact_match: bool,
 ) -> Vec<PathBuiltFromString> {
+    let mut completions = vec![];
+
    if let Some((&base, rest)) = partial.split_first() {
        if base.chars().all(|c| c == '.') && (isdir || !rest.is_empty()) {
-            let built_paths: Vec<_> = built_paths
-                .iter()
-                .map(|built| {
-                    let mut built = built.clone();
-                    built.parts.push(base.to_string());
-                    built.isdir = true;
-                    built
-                })
-                .collect();
-            return complete_rec(
-                rest,
-                &built_paths,
-                options,
-                want_directory,
-                isdir,
-                enable_exact_match,
-            );
+            let mut built = built.clone();
+            built.parts.push(base.to_string());
+            built.isdir = true;
+            return complete_rec(rest, &built, cwd, options, want_directory, isdir);
+        }
+    }
+
+    let mut built_path = cwd.to_path_buf();
+    for part in &built.parts {
+        built_path.push(part);
+    }
+
+    let Ok(result) = built_path.read_dir() else {
+        return completions;
+    };
+
+    let mut entries = Vec::new();
+    for entry in result.filter_map(|e| e.ok()) {
+        let entry_name = entry.file_name().to_string_lossy().into_owned();
+        let entry_isdir = entry.path().is_dir();
+        let mut built = built.clone();
+        built.parts.push(entry_name.clone());
+        built.isdir = entry_isdir;
+
+        if !want_directory || entry_isdir {
+            entries.push((entry_name, built));
        }
    }

    let prefix = partial.first().unwrap_or(&"");
-    let mut matcher = NuMatcher::new(prefix, options);
+    let sorted_entries = sort_completions(prefix, entries, options, |(entry, _)| entry);

-    for built in built_paths {
-        let mut path = built.cwd.clone();
-        for part in &built.parts {
-            path.push(part);
-        }
-
-        let Ok(result) = path.read_dir() else {
-            continue;
-        };
-
-        for entry in result.filter_map(|e| e.ok()) {
-            let entry_name = entry.file_name().to_string_lossy().into_owned();
-            let entry_isdir = entry.path().is_dir();
-            let mut built = built.clone();
-            built.parts.push(entry_name.clone());
-            // Symlinks to directories shouldn't have a trailing slash (#13275)
-            built.isdir = entry_isdir && !entry.path().is_symlink();
-
-            if !want_directory || entry_isdir {
-                matcher.add(entry_name.clone(), (entry_name, built));
-            }
-        }
-    }
-
-    let mut completions = vec![];
-    for (entry_name, built) in matcher.results() {
+    for (entry_name, built) in sorted_entries {
        match partial.split_first() {
            Some((base, rest)) => {
-                // We use `isdir` to confirm that the current component has
-                // at least one next component or a slash.
-                // Serves as confirmation to ignore longer completions for
-                // components in between.
-                if !rest.is_empty() || isdir {
-                    // Don't show longer completions if we have an exact match (#13204, #14794)
-                    let exact_match = enable_exact_match
-                        && (if options.case_sensitive {
-                            entry_name.eq(base)
-                        } else {
-                            entry_name.eq_ignore_case(base)
-                        });
-                    completions.extend(complete_rec(
-                        rest,
-                        &[built],
-                        options,
-                        want_directory,
-                        isdir,
-                        exact_match,
-                    ));
-                    if exact_match {
-                        break;
+                if matches(base, &entry_name, options) {
+                    // We use `isdir` to confirm that the current component has
+                    // at least one next component or a slash.
+                    // Serves as confirmation to ignore longer completions for
+                    // components in between.
+                    if !rest.is_empty() || isdir {
+                        completions.extend(complete_rec(
+                            rest,
+                            &built,
+                            cwd,
+                            options,
+                            want_directory,
+                            isdir,
+                        ));
+                    } else {
+                        completions.push(built);
                    }
-                } else {
-                    completions.push(built);
+                }
+                if entry_name.eq(base)
+                    && matches!(options.match_algorithm, MatchAlgorithm::Prefix)
+                    && isdir
+                {
+                    break;
                }
            }
            None => {
@ -150,7 +133,7 @@ impl OriginalCwd {
    }
 }

-pub fn surround_remove(partial: &str) -> String {
+fn surround_remove(partial: &str) -> String {
    for c in ['`', '"', '\''] {
        if partial.starts_with(c) {
            let ret = partial.strip_prefix(c).unwrap_or(partial);
@ -164,25 +147,15 @@ pub fn surround_remove(partial: &str) -> String {
    partial.to_string()
 }

-pub struct FileSuggestion {
-    pub span: nu_protocol::Span,
-    pub path: String,
-    pub style: Option<Style>,
-    pub is_dir: bool,
-}
-
-/// # Parameters
-/// * `cwds` - A list of directories in which to search. The only reason this isn't a single string
-///   is because dotnu_completions searches in multiple directories at once
 pub fn complete_item(
    want_directory: bool,
    span: nu_protocol::Span,
    partial: &str,
-    cwds: &[impl AsRef<str>],
+    cwd: &str,
    options: &CompletionOptions,
    engine_state: &EngineState,
    stack: &Stack,
-) -> Vec<FileSuggestion> {
+) -> Vec<(nu_protocol::Span, String, Option<Style>)> {
    let cleaned_partial = surround_remove(partial);
    let isdir = cleaned_partial.ends_with(is_separator);
    let expanded_partial = expand_ndots(Path::new(&cleaned_partial));
@ -202,20 +175,18 @@ pub fn complete_item(
        partial.push_str(&format!("{path_separator}."));
    }

-    let cwd_pathbufs: Vec<_> = cwds
-        .iter()
-        .map(|cwd| Path::new(cwd.as_ref()).to_path_buf())
-        .collect();
+    let cwd_pathbuf = Path::new(cwd).to_path_buf();
    let ls_colors = (engine_state.config.completions.use_ls_colors
-        && engine_state.config.use_ansi_coloring.get(engine_state))
-    .then(|| {
-        let ls_colors_env_str = stack
-            .get_env_var(engine_state, "LS_COLORS")
-            .and_then(|v| env_to_string("LS_COLORS", v, engine_state, stack).ok());
-        get_ls_colors(ls_colors_env_str)
-    });
+        && engine_state.config.use_ansi_coloring)
+        .then(|| {
+            let ls_colors_env_str = match stack.get_env_var(engine_state, "LS_COLORS") {
+                Some(v) => env_to_string("LS_COLORS", v, engine_state, stack).ok(),
+                None => None,
+            };
+            get_ls_colors(ls_colors_env_str)
+        });

-    let mut cwds = cwd_pathbufs.clone();
+    let mut cwd = cwd_pathbuf.clone();
    let mut prefix_len = 0;
    let mut original_cwd = OriginalCwd::None;

@ -223,21 +194,19 @@ pub fn complete_item(
    match components.peek().cloned() {
        Some(c @ Component::Prefix(..)) => {
            // windows only by definition
-            cwds = vec![[c, Component::RootDir].iter().collect()];
+            cwd = [c, Component::RootDir].iter().collect();
            prefix_len = c.as_os_str().len();
            original_cwd = OriginalCwd::Prefix(c.as_os_str().to_string_lossy().into_owned());
        }
        Some(c @ Component::RootDir) => {
            // This is kind of a hack. When joining an empty string with the rest,
            // we add the slash automagically
-            cwds = vec![PathBuf::from(c.as_os_str())];
+            cwd = PathBuf::from(c.as_os_str());
            prefix_len = 1;
            original_cwd = OriginalCwd::Prefix(String::new());
        }
        Some(Component::Normal(home)) if home.to_string_lossy() == "~" => {
-            cwds = home_dir()
-                .map(|dir| vec![dir.into()])
-                .unwrap_or(cwd_pathbufs);
+            cwd = home_dir().map(Into::into).unwrap_or(cwd_pathbuf);
            prefix_len = 1;
            original_cwd = OriginalCwd::Home;
        }
@ -254,68 +223,57 @@ pub fn complete_item(

    complete_rec(
        partial.as_slice(),
-        &cwds
-            .into_iter()
-            .map(|cwd| PathBuiltFromString {
-                cwd,
-                parts: Vec::new(),
-                isdir: false,
-            })
-            .collect::<Vec<_>>(),
+        &PathBuiltFromString::default(),
+        &cwd,
        options,
        want_directory,
        isdir,
-        options.match_algorithm == MatchAlgorithm::Prefix,
    )
    .into_iter()
    .map(|mut p| {
        if should_collapse_dots {
            p = collapse_ndots(p);
        }
-        let is_dir = p.isdir;
        let path = original_cwd.apply(p, path_separator);
-        let real_path = expand_to_real_path(&path);
-        let metadata = std::fs::symlink_metadata(&real_path).ok();
        let style = ls_colors.as_ref().map(|lsc| {
-            lsc.style_for_path_with_metadata(&real_path, metadata.as_ref())
-                .map(lscolors::Style::to_nu_ansi_term_style)
-                .unwrap_or_default()
+            lsc.style_for_path_with_metadata(
+                &path,
+                std::fs::symlink_metadata(expand_to_real_path(&path))
+                    .ok()
+                    .as_ref(),
+            )
+            .map(lscolors::Style::to_nu_ansi_term_style)
+            .unwrap_or_default()
        });
-        FileSuggestion {
-            span,
-            path: escape_path(path),
-            style,
-            is_dir,
-        }
+        (span, escape_path(path, want_directory), style)
    })
    .collect()
 }

 // Fix files or folders with quotes or hashes
-pub fn escape_path(path: String) -> String {
+pub fn escape_path(path: String, dir: bool) -> String {
    // make glob pattern have the highest priority.
-    if nu_glob::is_glob(path.as_str()) || path.contains('`') {
-        // expand home `~` for https://github.com/nushell/nushell/issues/13905
-        let pathbuf = nu_path::expand_tilde(path);
-        let path = pathbuf.to_string_lossy();
-        if path.contains('\'') {
-            // decide to use double quotes
-            // Path as Debug will do the escaping for `"`, `\`
-            format!("{:?}", path)
+    let glob_contaminated = path.contains(['[', '*', ']', '?']);
+    if glob_contaminated {
+        return if path.contains('\'') {
+            // decide to use double quote, also need to escape `"` in path
+            // or else users can't do anything with completed path either.
+            format!("\"{}\"", path.replace('"', r#"\""#))
        } else {
            format!("'{path}'")
-        }
+        };
+    }
+
+    let filename_contaminated = !dir && path.contains(['\'', '"', ' ', '#', '(', ')']);
+    let dirname_contaminated = dir && path.contains(['\'', '"', ' ', '#']);
+    let maybe_flag = path.starts_with('-');
+    let maybe_variable = path.starts_with('$');
+    let maybe_number = path.parse::<f64>().is_ok();
+    if filename_contaminated || dirname_contaminated || maybe_flag || maybe_variable || maybe_number
+    {
+        format!("`{path}`")
    } else {
-        let contaminated =
-            path.contains(['\'', '"', ' ', '#', '(', ')', '{', '}', '[', ']', '|', ';']);
-        let maybe_flag = path.starts_with('-');
-        let maybe_variable = path.starts_with('$');
-        let maybe_number = path.parse::<f64>().is_ok();
-        if contaminated || maybe_flag || maybe_variable || maybe_number {
-            format!("`{path}`")
-        } else {
-            path
-        }
+        path
    }
 }

@ -326,12 +284,12 @@ pub struct AdjustView {
 }

 pub fn adjust_if_intermediate(
-    prefix: &str,
+    prefix: &[u8],
    working_set: &StateWorkingSet,
    mut span: nu_protocol::Span,
 ) -> AdjustView {
    let span_contents = String::from_utf8_lossy(working_set.get_span_contents(span)).to_string();
-    let mut prefix = prefix.to_string();
+    let mut prefix = String::from_utf8_lossy(prefix).to_string();

    // A difference of 1 because of the cursor's unicode code point in between.
    // Using .chars().count() because unicode and Windows.
@ -352,6 +310,45 @@ pub fn adjust_if_intermediate(
    }
 }

+/// Convenience function to sort suggestions using [`sort_completions`]
+pub fn sort_suggestions(
+    prefix: &str,
+    items: Vec<SemanticSuggestion>,
+    options: &CompletionOptions,
+) -> Vec<SemanticSuggestion> {
+    sort_completions(prefix, items, options, |it| &it.suggestion.value)
+}
+
+/// # Arguments
+/// * `prefix` - What the user's typed, for sorting by fuzzy matcher score
+pub fn sort_completions<T>(
+    prefix: &str,
+    mut items: Vec<T>,
+    options: &CompletionOptions,
+    get_value: fn(&T) -> &str,
+) -> Vec<T> {
+    // Sort items
+    if options.sort == CompletionSort::Smart && options.match_algorithm == MatchAlgorithm::Fuzzy {
+        let mut matcher = SkimMatcherV2::default();
+        if options.case_sensitive {
+            matcher = matcher.respect_case();
+        } else {
+            matcher = matcher.ignore_case();
+        };
+        items.sort_unstable_by(|a, b| {
+            let a_str = get_value(a);
+            let b_str = get_value(b);
+            let a_score = matcher.fuzzy_match(a_str, prefix).unwrap_or_default();
+            let b_score = matcher.fuzzy_match(b_str, prefix).unwrap_or_default();
+            b_score.cmp(&a_score).then(a_str.cmp(b_str))
+        });
+    } else {
+        items.sort_unstable_by(|a, b| get_value(a).cmp(get_value(b)));
+    }
+
+    items
+}
+
 /// Collapse multiple ".." components into n-dots.
 ///
 /// It performs the reverse operation of `expand_ndots`, collapsing sequences of ".." into n-dots,
@ -362,7 +359,6 @@ fn collapse_ndots(path: PathBuiltFromString) -> PathBuiltFromString {
    let mut result = PathBuiltFromString {
        parts: Vec::with_capacity(path.parts.len()),
        isdir: path.isdir,
-        cwd: path.cwd,
    };

    let mut dot_count = 0;
--- a/crates/nu-cli/src/completions/completion_options.rs
+++ b/crates/nu-cli/src/completions/completion_options.rs
@ -1,13 +1,7 @@
+use fuzzy_matcher::{skim::SkimMatcherV2, FuzzyMatcher};
 use nu_parser::trim_quotes_str;
 use nu_protocol::{CompletionAlgorithm, CompletionSort};
-use nu_utils::IgnoreCaseExt;
-use nucleo_matcher::{
-    pattern::{Atom, AtomKind, CaseMatching, Normalization},
-    Config, Matcher, Utf32Str,
-};
-use std::{borrow::Cow, fmt::Display};
-
-use super::SemanticSuggestion;
+use std::fmt::Display;

 /// Describes how suggestions should be matched.
 #[derive(Copy, Clone, Debug, PartialEq)]
@ -18,12 +12,6 @@ pub enum MatchAlgorithm {
    /// "git switch" is matched by "git sw"
    Prefix,

-    /// Only show suggestions which have a substring matching with the given input
-    ///
-    /// Example:
-    /// "git checkout" is matched by "checkout"
-    Substring,
-
    /// Only show suggestions which contain the input chars at any place
    ///
    /// Example:
@ -31,203 +19,39 @@ pub enum MatchAlgorithm {
    Fuzzy,
 }

-pub struct NuMatcher<'a, T> {
-    options: &'a CompletionOptions,
-    needle: String,
-    state: State<T>,
-}
-
-enum State<T> {
-    Prefix {
-        /// Holds (haystack, item)
-        items: Vec<(String, T)>,
-    },
-    Substring {
-        /// Holds (haystack, item)
-        items: Vec<(String, T)>,
-    },
-    Fuzzy {
-        matcher: Matcher,
-        atom: Atom,
-        /// Holds (haystack, item, score)
-        items: Vec<(String, T, u16)>,
-    },
-}
-
-/// Filters and sorts suggestions
-impl<T> NuMatcher<'_, T> {
-    /// # Arguments
-    ///
-    /// * `needle` - The text to search for
-    pub fn new(needle: impl AsRef<str>, options: &CompletionOptions) -> NuMatcher<T> {
-        let needle = trim_quotes_str(needle.as_ref());
-        match options.match_algorithm {
-            MatchAlgorithm::Prefix => {
-                let lowercase_needle = if options.case_sensitive {
-                    needle.to_owned()
-                } else {
-                    needle.to_folded_case()
-                };
-                NuMatcher {
-                    options,
-                    needle: lowercase_needle,
-                    state: State::Prefix { items: Vec::new() },
-                }
-            }
-            MatchAlgorithm::Substring => {
-                let lowercase_needle = if options.case_sensitive {
-                    needle.to_owned()
-                } else {
-                    needle.to_folded_case()
-                };
-                NuMatcher {
-                    options,
-                    needle: lowercase_needle,
-                    state: State::Substring { items: Vec::new() },
-                }
-            }
-            MatchAlgorithm::Fuzzy => {
-                let atom = Atom::new(
-                    needle,
-                    if options.case_sensitive {
-                        CaseMatching::Respect
-                    } else {
-                        CaseMatching::Ignore
-                    },
-                    Normalization::Smart,
-                    AtomKind::Fuzzy,
-                    false,
-                );
-                NuMatcher {
-                    options,
-                    needle: needle.to_owned(),
-                    state: State::Fuzzy {
-                        matcher: Matcher::new(Config::DEFAULT),
-                        atom,
-                        items: Vec::new(),
-                    },
-                }
-            }
-        }
-    }
-
-    /// Returns whether or not the haystack matches the needle. If it does, `item` is added
-    /// to the list of matches (if given).
-    ///
-    /// Helper to avoid code duplication between [NuMatcher::add] and [NuMatcher::matches].
-    fn matches_aux(&mut self, haystack: &str, item: Option<T>) -> bool {
+impl MatchAlgorithm {
+    /// Returns whether the `needle` search text matches the given `haystack`.
+    pub fn matches_str(&self, haystack: &str, needle: &str) -> bool {
        let haystack = trim_quotes_str(haystack);
-        match &mut self.state {
-            State::Prefix { items } => {
-                let haystack_folded = if self.options.case_sensitive {
-                    Cow::Borrowed(haystack)
-                } else {
-                    Cow::Owned(haystack.to_folded_case())
-                };
-                let matches = haystack_folded.starts_with(self.needle.as_str());
-                if matches {
-                    if let Some(item) = item {
-                        items.push((haystack.to_string(), item));
-                    }
-                }
-                matches
-            }
-            State::Substring { items } => {
-                let haystack_folded = if self.options.case_sensitive {
-                    Cow::Borrowed(haystack)
-                } else {
-                    Cow::Owned(haystack.to_folded_case())
-                };
-                let matches = haystack_folded.contains(self.needle.as_str());
-                if matches {
-                    if let Some(item) = item {
-                        items.push((haystack.to_string(), item));
-                    }
-                }
-                matches
-            }
-            State::Fuzzy {
-                matcher,
-                atom,
-                items,
-            } => {
-                let mut haystack_buf = Vec::new();
-                let haystack_utf32 = Utf32Str::new(trim_quotes_str(haystack), &mut haystack_buf);
-                let mut indices = Vec::new();
-                let Some(score) = atom.indices(haystack_utf32, matcher, &mut indices) else {
-                    return false;
-                };
-                if let Some(item) = item {
-                    items.push((haystack.to_string(), item, score));
-                }
-                true
+        let needle = trim_quotes_str(needle);
+        match *self {
+            MatchAlgorithm::Prefix => haystack.starts_with(needle),
+            MatchAlgorithm::Fuzzy => {
+                let matcher = SkimMatcherV2::default();
+                matcher.fuzzy_match(haystack, needle).is_some()
            }
        }
    }

-    /// Add the given item if the given haystack matches the needle.
-    ///
-    /// Returns whether the item was added.
-    pub fn add(&mut self, haystack: impl AsRef<str>, item: T) -> bool {
-        self.matches_aux(haystack.as_ref(), Some(item))
-    }
+    /// Returns whether the `needle` search text matches the given `haystack`.
+    pub fn matches_u8(&self, haystack: &[u8], needle: &[u8]) -> bool {
+        match *self {
+            MatchAlgorithm::Prefix => haystack.starts_with(needle),
+            MatchAlgorithm::Fuzzy => {
+                let haystack_str = String::from_utf8_lossy(haystack);
+                let needle_str = String::from_utf8_lossy(needle);

-    /// Returns whether the haystack matches the needle.
-    pub fn matches(&mut self, haystack: &str) -> bool {
-        self.matches_aux(haystack, None)
-    }
-
-    /// Get all the items that matched (sorted)
-    pub fn results(self) -> Vec<T> {
-        match self.state {
-            State::Prefix { mut items, .. } | State::Substring { mut items, .. } => {
-                items.sort_by(|(haystack1, _), (haystack2, _)| {
-                    let cmp_sensitive = haystack1.cmp(haystack2);
-                    if self.options.case_sensitive {
-                        cmp_sensitive
-                    } else {
-                        haystack1
-                            .to_folded_case()
-                            .cmp(&haystack2.to_folded_case())
-                            .then(cmp_sensitive)
-                    }
-                });
-                items.into_iter().map(|(_, item)| item).collect::<Vec<_>>()
-            }
-            State::Fuzzy { mut items, .. } => {
-                match self.options.sort {
-                    CompletionSort::Alphabetical => {
-                        items.sort_by(|(haystack1, _, _), (haystack2, _, _)| {
-                            haystack1.cmp(haystack2)
-                        });
-                    }
-                    CompletionSort::Smart => {
-                        items.sort_by(|(haystack1, _, score1), (haystack2, _, score2)| {
-                            score2.cmp(score1).then(haystack1.cmp(haystack2))
-                        });
-                    }
-                }
-                items
-                    .into_iter()
-                    .map(|(_, item, _)| item)
-                    .collect::<Vec<_>>()
+                let matcher = SkimMatcherV2::default();
+                matcher.fuzzy_match(&haystack_str, &needle_str).is_some()
            }
        }
    }
 }

-impl NuMatcher<'_, SemanticSuggestion> {
-    pub fn add_semantic_suggestion(&mut self, sugg: SemanticSuggestion) -> bool {
-        let value = sugg.suggestion.value.to_string();
-        self.add(value, sugg)
-    }
-}
-
 impl From<CompletionAlgorithm> for MatchAlgorithm {
    fn from(value: CompletionAlgorithm) -> Self {
        match value {
            CompletionAlgorithm::Prefix => MatchAlgorithm::Prefix,
-            CompletionAlgorithm::Substring => MatchAlgorithm::Substring,
            CompletionAlgorithm::Fuzzy => MatchAlgorithm::Fuzzy,
        }
    }
@ -239,7 +63,6 @@ impl TryFrom<String> for MatchAlgorithm {
    fn try_from(value: String) -> Result<Self, Self::Error> {
        match value.as_str() {
            "prefix" => Ok(Self::Prefix),
-            "substring" => Ok(Self::Substring),
            "fuzzy" => Ok(Self::Fuzzy),
            _ => Err(InvalidMatchAlgorithm::Unknown),
        }
@ -264,6 +87,7 @@ impl std::error::Error for InvalidMatchAlgorithm {}
 #[derive(Clone)]
 pub struct CompletionOptions {
    pub case_sensitive: bool,
+    pub positional: bool,
    pub match_algorithm: MatchAlgorithm,
    pub sort: CompletionSort,
 }
@ -272,6 +96,7 @@ impl Default for CompletionOptions {
    fn default() -> Self {
        Self {
            case_sensitive: true,
+            positional: true,
            match_algorithm: MatchAlgorithm::Prefix,
            sort: Default::default(),
        }
@ -280,70 +105,35 @@ impl Default for CompletionOptions {

 #[cfg(test)]
 mod test {
-    use rstest::rstest;
+    use super::MatchAlgorithm;

-    use super::{CompletionOptions, MatchAlgorithm, NuMatcher};
+    #[test]
+    fn match_algorithm_prefix() {
+        let algorithm = MatchAlgorithm::Prefix;

-    #[rstest]
-    #[case(MatchAlgorithm::Prefix, "example text", "", true)]
-    #[case(MatchAlgorithm::Prefix, "example text", "examp", true)]
-    #[case(MatchAlgorithm::Prefix, "example text", "text", false)]
-    #[case(MatchAlgorithm::Substring, "example text", "", true)]
-    #[case(MatchAlgorithm::Substring, "example text", "text", true)]
-    #[case(MatchAlgorithm::Substring, "example text", "mplxt", false)]
-    #[case(MatchAlgorithm::Fuzzy, "example text", "", true)]
-    #[case(MatchAlgorithm::Fuzzy, "example text", "examp", true)]
-    #[case(MatchAlgorithm::Fuzzy, "example text", "ext", true)]
-    #[case(MatchAlgorithm::Fuzzy, "example text", "mplxt", true)]
-    #[case(MatchAlgorithm::Fuzzy, "example text", "mpp", false)]
-    fn match_algorithm_simple(
-        #[case] match_algorithm: MatchAlgorithm,
-        #[case] haystack: &str,
-        #[case] needle: &str,
-        #[case] should_match: bool,
-    ) {
-        let options = CompletionOptions {
-            match_algorithm,
-            ..Default::default()
-        };
-        let mut matcher = NuMatcher::new(needle, &options);
-        matcher.add(haystack, haystack);
-        if should_match {
-            assert_eq!(vec![haystack], matcher.results());
-        } else {
-            assert_ne!(vec![haystack], matcher.results());
-        }
+        assert!(algorithm.matches_str("example text", ""));
+        assert!(algorithm.matches_str("example text", "examp"));
+        assert!(!algorithm.matches_str("example text", "text"));
+
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[1, 2]));
+        assert!(!algorithm.matches_u8(&[1, 2, 3], &[2, 3]));
    }

    #[test]
-    fn match_algorithm_fuzzy_sort_score() {
-        let options = CompletionOptions {
-            match_algorithm: MatchAlgorithm::Fuzzy,
-            ..Default::default()
-        };
-        let mut matcher = NuMatcher::new("fob", &options);
-        for item in ["foo/bar", "fob", "foo bar"] {
-            matcher.add(item, item);
-        }
-        // Sort by score, then in alphabetical order
-        assert_eq!(vec!["fob", "foo bar", "foo/bar"], matcher.results());
-    }
+    fn match_algorithm_fuzzy() {
+        let algorithm = MatchAlgorithm::Fuzzy;

-    #[test]
-    fn match_algorithm_fuzzy_sort_strip() {
-        let options = CompletionOptions {
-            match_algorithm: MatchAlgorithm::Fuzzy,
-            ..Default::default()
-        };
-        let mut matcher = NuMatcher::new("'love spaces' ", &options);
-        for item in [
-            "'i love spaces'",
-            "'i love spaces' so much",
-            "'lovespaces' ",
-        ] {
-            matcher.add(item, item);
-        }
-        // Make sure the spaces are respected
-        assert_eq!(vec!["'i love spaces' so much"], matcher.results());
+        assert!(algorithm.matches_str("example text", ""));
+        assert!(algorithm.matches_str("example text", "examp"));
+        assert!(algorithm.matches_str("example text", "ext"));
+        assert!(algorithm.matches_str("example text", "mplxt"));
+        assert!(!algorithm.matches_str("example text", "mpp"));
+
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[1, 2]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[2, 3]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[1, 3]));
+        assert!(!algorithm.matches_u8(&[1, 2, 3], &[2, 2]));
    }
 }
--- a/crates/nu-cli/src/completions/custom_completions.rs
+++ b/crates/nu-cli/src/completions/custom_completions.rs
@ -6,81 +6,74 @@ use nu_engine::eval_call;
 use nu_protocol::{
    ast::{Argument, Call, Expr, Expression},
    debugger::WithoutDebug,
-    engine::{EngineState, Stack, StateWorkingSet},
-    DeclId, PipelineData, Span, Type, Value,
+    engine::{Stack, StateWorkingSet},
+    CompletionSort, DeclId, PipelineData, Span, Type, Value,
 };
+use nu_utils::IgnoreCaseExt;
 use std::collections::HashMap;

-use super::completion_options::NuMatcher;
+use super::completion_common::sort_suggestions;

-pub struct CustomCompletion<T: Completer> {
+pub struct CustomCompletion {
+    stack: Stack,
    decl_id: DeclId,
    line: String,
-    line_pos: usize,
-    fallback: T,
 }

-impl<T: Completer> CustomCompletion<T> {
-    pub fn new(decl_id: DeclId, line: String, line_pos: usize, fallback: T) -> Self {
+impl CustomCompletion {
+    pub fn new(stack: Stack, decl_id: DeclId, line: String) -> Self {
        Self {
+            stack,
            decl_id,
            line,
-            line_pos,
-            fallback,
        }
    }
 }

-impl<T: Completer> Completer for CustomCompletion<T> {
+impl Completer for CustomCompletion {
    fn fetch(
        &mut self,
        working_set: &StateWorkingSet,
-        stack: &Stack,
-        prefix: impl AsRef<str>,
+        _stack: &Stack,
+        prefix: &[u8],
        span: Span,
        offset: usize,
-        orig_options: &CompletionOptions,
+        pos: usize,
+        completion_options: &CompletionOptions,
    ) -> Vec<SemanticSuggestion> {
-        // Call custom declaration
-        let mut stack_mut = stack.clone();
-        let mut eval = |engine_state: &EngineState| {
-            eval_call::<WithoutDebug>(
-                engine_state,
-                &mut stack_mut,
-                &Call {
-                    decl_id: self.decl_id,
-                    head: span,
-                    arguments: vec![
-                        Argument::Positional(Expression::new_unknown(
-                            Expr::String(self.line.clone()),
-                            Span::unknown(),
-                            Type::String,
-                        )),
-                        Argument::Positional(Expression::new_unknown(
-                            Expr::Int(self.line_pos as i64),
-                            Span::unknown(),
-                            Type::Int,
-                        )),
-                    ],
-                    parser_info: HashMap::new(),
-                },
-                PipelineData::empty(),
-            )
-        };
-        let result = if self.decl_id.get() < working_set.permanent_state.num_decls() {
-            eval(working_set.permanent_state)
-        } else {
-            let mut engine_state = working_set.permanent_state.clone();
-            let _ = engine_state.merge_delta(working_set.delta.clone());
-            eval(&engine_state)
-        };
+        // Line position
+        let line_pos = pos - offset;

-        let mut completion_options = orig_options.clone();
-        let mut should_sort = true;
+        // Call custom declaration
+        let result = eval_call::<WithoutDebug>(
+            working_set.permanent_state,
+            &mut self.stack,
+            &Call {
+                decl_id: self.decl_id,
+                head: span,
+                arguments: vec![
+                    Argument::Positional(Expression::new_unknown(
+                        Expr::String(self.line.clone()),
+                        Span::unknown(),
+                        Type::String,
+                    )),
+                    Argument::Positional(Expression::new_unknown(
+                        Expr::Int(line_pos as i64),
+                        Span::unknown(),
+                        Type::Int,
+                    )),
+                ],
+                parser_info: HashMap::new(),
+            },
+            PipelineData::empty(),
+        );
+
+        let mut custom_completion_options = None;

        // Parse result
-        let suggestions = match result.and_then(|data| data.into_value(span)) {
-            Ok(value) => match &value {
+        let suggestions = result
+            .and_then(|data| data.into_value(span))
+            .map(|value| match &value {
                Value::Record { val, .. } => {
                    let completions = val
                        .get("completions")
@ -93,74 +86,78 @@ impl<T: Completer> Completer for CustomCompletion<T> {
                    let options = val.get("options");

                    if let Some(Value::Record { val: options, .. }) = &options {
-                        if let Some(sort) = options.get("sort").and_then(|val| val.as_bool().ok()) {
-                            should_sort = sort;
-                        }
-
-                        if let Some(case_sensitive) = options
-                            .get("case_sensitive")
+                        let should_sort = options
+                            .get("sort")
                            .and_then(|val| val.as_bool().ok())
-                        {
-                            completion_options.case_sensitive = case_sensitive;
-                        }
-                        let positional =
-                            options.get("positional").and_then(|val| val.as_bool().ok());
-                        if positional.is_some() {
-                            log::warn!("Use of the positional option is deprecated. Use the substring match algorithm instead.");
-                        }
-                        if let Some(algorithm) = options
-                            .get("completion_algorithm")
-                            .and_then(|option| option.coerce_string().ok())
-                            .and_then(|option| option.try_into().ok())
-                        {
-                            completion_options.match_algorithm = algorithm;
-                            if let Some(false) = positional {
-                                if completion_options.match_algorithm == MatchAlgorithm::Prefix {
-                                    completion_options.match_algorithm = MatchAlgorithm::Substring
-                                }
-                            }
-                        }
+                            .unwrap_or(false);
+
+                        custom_completion_options = Some(CompletionOptions {
+                            case_sensitive: options
+                                .get("case_sensitive")
+                                .and_then(|val| val.as_bool().ok())
+                                .unwrap_or(true),
+                            positional: options
+                                .get("positional")
+                                .and_then(|val| val.as_bool().ok())
+                                .unwrap_or(true),
+                            match_algorithm: match options.get("completion_algorithm") {
+                                Some(option) => option
+                                    .coerce_string()
+                                    .ok()
+                                    .and_then(|option| option.try_into().ok())
+                                    .unwrap_or(MatchAlgorithm::Prefix),
+                                None => completion_options.match_algorithm,
+                            },
+                            sort: if should_sort {
+                                CompletionSort::Alphabetical
+                            } else {
+                                CompletionSort::Smart
+                            },
+                        });
                    }

                    completions
                }
                Value::List { vals, .. } => map_value_completions(vals.iter(), span, offset),
-                Value::Nothing { .. } => {
-                    return self.fallback.fetch(
-                        working_set,
-                        stack,
-                        prefix,
-                        span,
-                        offset,
-                        orig_options,
-                    );
-                }
-                _ => {
-                    log::error!(
-                        "Custom completer returned invalid value of type {}",
-                        value.get_type().to_string()
-                    );
-                    return vec![];
-                }
-            },
-            Err(e) => {
-                log::error!("Error getting custom completions: {e}");
-                return vec![];
-            }
-        };
+                _ => vec![],
+            })
+            .unwrap_or_default();

-        let mut matcher = NuMatcher::new(prefix, &completion_options);
-
-        if should_sort {
-            for sugg in suggestions {
-                matcher.add_semantic_suggestion(sugg);
-            }
-            matcher.results()
-        } else {
-            suggestions
-                .into_iter()
-                .filter(|sugg| matcher.matches(&sugg.suggestion.value))
-                .collect()
-        }
+        let options = custom_completion_options
+            .as_ref()
+            .unwrap_or(completion_options);
+        let suggestions = filter(prefix, suggestions, options);
+        sort_suggestions(&String::from_utf8_lossy(prefix), suggestions, options)
    }
 }
+
+fn filter(
+    prefix: &[u8],
+    items: Vec<SemanticSuggestion>,
+    options: &CompletionOptions,
+) -> Vec<SemanticSuggestion> {
+    items
+        .into_iter()
+        .filter(|it| match options.match_algorithm {
+            MatchAlgorithm::Prefix => match (options.case_sensitive, options.positional) {
+                (true, true) => it.suggestion.value.as_bytes().starts_with(prefix),
+                (true, false) => it
+                    .suggestion
+                    .value
+                    .contains(std::str::from_utf8(prefix).unwrap_or("")),
+                (false, positional) => {
+                    let value = it.suggestion.value.to_folded_case();
+                    let prefix = std::str::from_utf8(prefix).unwrap_or("").to_folded_case();
+                    if positional {
+                        value.starts_with(&prefix)
+                    } else {
+                        value.contains(&prefix)
+                    }
+                }
+            },
+            MatchAlgorithm::Fuzzy => options
+                .match_algorithm
+                .matches_u8(it.suggestion.value.as_bytes(), prefix),
+        })
+        .collect()
+}
--- a/crates/nu-cli/src/completions/directory_completions.rs
+++ b/crates/nu-cli/src/completions/directory_completions.rs
@ -2,6 +2,7 @@ use crate::completions::{
    completion_common::{adjust_if_intermediate, complete_item, AdjustView},
    Completer, CompletionOptions,
 };
+use nu_ansi_term::Style;
 use nu_protocol::{
    engine::{EngineState, Stack, StateWorkingSet},
    Span,
@ -9,22 +10,29 @@ use nu_protocol::{
 use reedline::Suggestion;
 use std::path::Path;

-use super::{completion_common::FileSuggestion, SemanticSuggestion, SuggestionKind};
+use super::SemanticSuggestion;

-pub struct DirectoryCompletion;
+#[derive(Clone, Default)]
+pub struct DirectoryCompletion {}
+
+impl DirectoryCompletion {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}

 impl Completer for DirectoryCompletion {
    fn fetch(
        &mut self,
        working_set: &StateWorkingSet,
        stack: &Stack,
-        prefix: impl AsRef<str>,
+        prefix: &[u8],
        span: Span,
        offset: usize,
+        _pos: usize,
        options: &CompletionOptions,
    ) -> Vec<SemanticSuggestion> {
-        let AdjustView { prefix, span, .. } =
-            adjust_if_intermediate(prefix.as_ref(), working_set, span);
+        let AdjustView { prefix, span, .. } = adjust_if_intermediate(prefix, working_set, span);

        // Filter only the folders
        #[allow(deprecated)]
@ -39,15 +47,16 @@ impl Completer for DirectoryCompletion {
        .into_iter()
        .map(move |x| SemanticSuggestion {
            suggestion: Suggestion {
-                value: x.path,
-                style: x.style,
+                value: x.1,
+                style: x.2,
                span: reedline::Span {
-                    start: x.span.start - offset,
-                    end: x.span.end - offset,
+                    start: x.0.start - offset,
+                    end: x.0.end - offset,
                },
                ..Suggestion::default()
            },
-            kind: Some(SuggestionKind::Directory),
+            // TODO????
+            kind: None,
        })
        .collect();

@ -83,6 +92,6 @@ pub fn directory_completion(
    options: &CompletionOptions,
    engine_state: &EngineState,
    stack: &Stack,
-) -> Vec<FileSuggestion> {
-    complete_item(true, span, partial, &[cwd], options, engine_state, stack)
+) -> Vec<(nu_protocol::Span, String, Option<Style>)> {
+    complete_item(true, span, partial, cwd, options, engine_state, stack)
 }
--- a/crates/nu-cli/src/completions/dotnu_completions.rs
+++ b/crates/nu-cli/src/completions/dotnu_completions.rs
@ -1,22 +1,20 @@
-use crate::completions::{
-    completion_common::{surround_remove, FileSuggestion},
-    completion_options::NuMatcher,
-    file_path_completion, Completer, CompletionOptions, SemanticSuggestion, SuggestionKind,
-};
-use nu_path::expand_tilde;
+use crate::completions::{file_path_completion, Completer, CompletionOptions};
 use nu_protocol::{
-    engine::{Stack, StateWorkingSet, VirtualPath},
+    engine::{Stack, StateWorkingSet},
    Span,
 };
 use reedline::Suggestion;
-use std::{
-    collections::HashSet,
-    path::{is_separator, PathBuf, MAIN_SEPARATOR_STR},
-};
+use std::path::{is_separator, Path, MAIN_SEPARATOR as SEP, MAIN_SEPARATOR_STR};

-pub struct DotNuCompletion {
-    /// e.g. use std/a<tab>
-    pub std_virtual_path: bool,
+use super::{completion_common::sort_suggestions, SemanticSuggestion};
+
+#[derive(Clone, Default)]
+pub struct DotNuCompletion {}
+
+impl DotNuCompletion {
+    pub fn new() -> Self {
+        Self::default()
+    }
 }

 impl Completer for DotNuCompletion {
@ -24,185 +22,114 @@ impl Completer for DotNuCompletion {
        &mut self,
        working_set: &StateWorkingSet,
        stack: &Stack,
-        prefix: impl AsRef<str>,
+        prefix: &[u8],
        span: Span,
        offset: usize,
+        _pos: usize,
        options: &CompletionOptions,
    ) -> Vec<SemanticSuggestion> {
-        let prefix_str = prefix.as_ref();
-        let start_with_backquote = prefix_str.starts_with('`');
-        let end_with_backquote = prefix_str.ends_with('`');
-        let prefix_str = prefix_str.replace('`', "");
-        // e.g. `./`, `..\`, `/`
-        let not_lib_dirs = prefix_str
-            .chars()
-            .find(|c| *c != '.')
-            .is_some_and(is_separator);
-        let mut search_dirs: Vec<PathBuf> = vec![];
+        let prefix_str = String::from_utf8_lossy(prefix).replace('`', "");
+        let mut search_dirs: Vec<String> = vec![];

-        let (base, partial) = if let Some((parent, remain)) = prefix_str.rsplit_once(is_separator) {
-            // If prefix_str is only a word we want to search in the current dir.
-            // "/xx" should be split to "/" and "xx".
-            if parent.is_empty() {
-                (MAIN_SEPARATOR_STR, remain)
-            } else {
-                (parent, remain)
-            }
-        } else {
-            (".", prefix_str.as_str())
-        };
+        // If prefix_str is only a word we want to search in the current dir
+        let (base, partial) = prefix_str
+            .rsplit_once(is_separator)
+            .unwrap_or((".", &prefix_str));
        let base_dir = base.replace(is_separator, MAIN_SEPARATOR_STR);
+        let mut partial = partial.to_string();
+        // On windows, this standardizes paths to use \
+        let mut is_current_folder = false;

        // Fetch the lib dirs
-        // NOTE: 2 ways to setup `NU_LIB_DIRS`
-        // 1. `const NU_LIB_DIRS = [paths]`, equal to `nu -I paths`
-        // 2. `$env.NU_LIB_DIRS = [paths]`
-        let const_lib_dirs = working_set
-            .find_variable(b"$NU_LIB_DIRS")
-            .and_then(|vid| working_set.get_variable(vid).const_val.as_ref());
-        let env_lib_dirs = working_set.get_env_var("NU_LIB_DIRS");
-        let lib_dirs: HashSet<PathBuf> = [const_lib_dirs, env_lib_dirs]
-            .into_iter()
-            .flatten()
-            .flat_map(|lib_dirs| {
-                lib_dirs
-                    .as_list()
-                    .into_iter()
-                    .flat_map(|it| it.iter().filter_map(|x| x.to_path().ok()))
-                    .map(expand_tilde)
-            })
-            .collect();
+        let lib_dirs: Vec<String> = if let Some(lib_dirs) = working_set.get_env_var("NU_LIB_DIRS") {
+            lib_dirs
+                .as_list()
+                .into_iter()
+                .flat_map(|it| {
+                    it.iter().map(|x| {
+                        x.to_path()
+                            .expect("internal error: failed to convert lib path")
+                    })
+                })
+                .map(|it| {
+                    it.into_os_string()
+                        .into_string()
+                        .expect("internal error: failed to convert OS path")
+                })
+                .collect()
+        } else {
+            vec![]
+        };

        // Check if the base_dir is a folder
-        let cwd = working_set.permanent_state.cwd(None);
+        // rsplit_once removes the separator
        if base_dir != "." {
-            let expanded_base_dir = expand_tilde(&base_dir);
-            let is_base_dir_relative = expanded_base_dir.is_relative();
-            // Search in base_dir as well as lib_dirs.
-            // After expanded, base_dir can be a relative path or absolute path.
-            // If relative, we join "current working dir" with it to get subdirectory and add to search_dirs.
-            // If absolute, we add it to search_dirs.
-            if let Ok(mut cwd) = cwd {
-                if is_base_dir_relative {
-                    cwd.push(&base_dir);
-                    search_dirs.push(cwd.into_std_path_buf());
-                } else {
-                    search_dirs.push(expanded_base_dir);
-                }
-            }
-            if !not_lib_dirs {
-                search_dirs.extend(lib_dirs.into_iter().map(|mut dir| {
-                    dir.push(&base_dir);
-                    dir
-                }));
-            }
+            // Add the base dir into the directories to be searched
+            search_dirs.push(base_dir.clone());
+
+            // Reset the partial adding the basic dir back
+            // in order to make the span replace work properly
+            let mut base_dir_partial = base_dir;
+            base_dir_partial.push_str(&partial);
+
+            partial = base_dir_partial;
        } else {
-            if let Ok(cwd) = cwd {
-                search_dirs.push(cwd.into_std_path_buf());
-            }
-            if !not_lib_dirs {
-                search_dirs.extend(lib_dirs);
-            }
+            // Fetch the current folder
+            #[allow(deprecated)]
+            let current_folder = working_set.permanent_state.current_work_dir();
+            is_current_folder = true;
+
+            // Add the current folder and the lib dirs into the
+            // directories to be searched
+            search_dirs.push(current_folder);
+            search_dirs.extend(lib_dirs);
        }

        // Fetch the files filtering the ones that ends with .nu
        // and transform them into suggestions
-        let mut completions = file_path_completion(
-            span,
-            partial,
-            &search_dirs
-                .iter()
-                .filter_map(|d| d.to_str())
-                .collect::<Vec<_>>(),
-            options,
-            working_set.permanent_state,
-            stack,
-        );
-
-        if self.std_virtual_path {
-            let mut matcher = NuMatcher::new(partial, options);
-            let base_dir = surround_remove(&base_dir);
-            if base_dir == "." {
-                let surround_prefix = partial
-                    .chars()
-                    .take_while(|c| "`'\"".contains(*c))
-                    .collect::<String>();
-                for path in ["std", "std-rfc"] {
-                    let path = format!("{}{}", surround_prefix, path);
-                    matcher.add(
-                        path.clone(),
-                        FileSuggestion {
-                            span,
-                            path,
-                            style: None,
-                            is_dir: true,
-                        },
-                    );
-                }
-            } else if let Some(VirtualPath::Dir(sub_paths)) =
-                working_set.find_virtual_path(&base_dir)
-            {
-                for sub_vp_id in sub_paths {
-                    let (path, sub_vp) = working_set.get_virtual_path(*sub_vp_id);
-                    let path = path
-                        .strip_prefix(&format!("{}/", base_dir))
-                        .unwrap_or(path)
-                        .to_string();
-                    matcher.add(
-                        path.clone(),
-                        FileSuggestion {
-                            path,
-                            span,
-                            style: None,
-                            is_dir: matches!(sub_vp, VirtualPath::Dir(_)),
-                        },
-                    );
-                }
-            }
-            completions.extend(matcher.results());
-        }
-
-        completions
+        let output: Vec<SemanticSuggestion> = search_dirs
            .into_iter()
-            // Different base dir, so we list the .nu files or folders
-            .filter(|it| {
-                // for paths with spaces in them
-                let path = it.path.trim_end_matches('`');
-                path.ends_with(".nu") || it.is_dir
+            .flat_map(|search_dir| {
+                let completions = file_path_completion(
+                    span,
+                    &partial,
+                    &search_dir,
+                    options,
+                    working_set.permanent_state,
+                    stack,
+                );
+                completions
+                    .into_iter()
+                    .filter(move |it| {
+                        // Different base dir, so we list the .nu files or folders
+                        if !is_current_folder {
+                            it.1.ends_with(".nu") || it.1.ends_with(SEP)
+                        } else {
+                            // Lib dirs, so we filter only the .nu files or directory modules
+                            if it.1.ends_with(SEP) {
+                                Path::new(&search_dir).join(&it.1).join("mod.nu").exists()
+                            } else {
+                                it.1.ends_with(".nu")
+                            }
+                        }
+                    })
+                    .map(move |x| SemanticSuggestion {
+                        suggestion: Suggestion {
+                            value: x.1,
+                            style: x.2,
+                            span: reedline::Span {
+                                start: x.0.start - offset,
+                                end: x.0.end - offset,
+                            },
+                            append_whitespace: true,
+                            ..Suggestion::default()
+                        },
+                        // TODO????
+                        kind: None,
+                    })
            })
-            .map(|x| {
-                let append_whitespace = !x.is_dir && (!start_with_backquote || end_with_backquote);
-                // Re-calculate the span to replace
-                let mut span_offset = 0;
-                let mut value = x.path.to_string();
-                // Complete only the last path component
-                if base_dir == MAIN_SEPARATOR_STR {
-                    span_offset = base_dir.len()
-                } else if base_dir != "." {
-                    span_offset = base_dir.len() + 1
-                }
-                // Retain only one '`'
-                if start_with_backquote {
-                    value = value.trim_start_matches('`').to_string();
-                    span_offset += 1;
-                }
-                // Add the backquote back
-                if end_with_backquote && !value.ends_with('`') {
-                    value.push('`');
-                }
-                let end = x.span.end - offset;
-                let start = std::cmp::min(end, x.span.start - offset + span_offset);
-                SemanticSuggestion {
-                    suggestion: Suggestion {
-                        value,
-                        style: x.style,
-                        span: reedline::Span { start, end },
-                        append_whitespace,
-                        ..Suggestion::default()
-                    },
-                    kind: Some(SuggestionKind::Module),
-                }
-            })
-            .collect::<Vec<_>>()
+            .collect();
+
+        sort_suggestions(&prefix_str, output, options)
    }
 }
--- a/crates/nu-cli/src/completions/exportable_completions.rs
+++ b/crates/nu-cli/src/completions/exportable_completions.rs
@ -1,112 +0,0 @@
-use crate::completions::{
-    completion_common::surround_remove, completion_options::NuMatcher, Completer,
-    CompletionOptions, SemanticSuggestion, SuggestionKind,
-};
-use nu_protocol::{
-    engine::{Stack, StateWorkingSet},
-    ModuleId, Span,
-};
-use reedline::Suggestion;
-
-pub struct ExportableCompletion<'a> {
-    pub module_id: ModuleId,
-    pub temp_working_set: Option<StateWorkingSet<'a>>,
-}
-
-/// If name contains space, wrap it in quotes
-fn wrapped_name(name: String) -> String {
-    if !name.contains(' ') {
-        return name;
-    }
-    if name.contains('\'') {
-        format!("\"{}\"", name.replace('"', r#"\""#))
-    } else {
-        format!("'{name}'")
-    }
-}
-
-impl Completer for ExportableCompletion<'_> {
-    fn fetch(
-        &mut self,
-        working_set: &StateWorkingSet,
-        _stack: &Stack,
-        prefix: impl AsRef<str>,
-        span: Span,
-        offset: usize,
-        options: &CompletionOptions,
-    ) -> Vec<SemanticSuggestion> {
-        let mut matcher = NuMatcher::<()>::new(surround_remove(prefix.as_ref()), options);
-        let mut results = Vec::new();
-        let span = reedline::Span {
-            start: span.start - offset,
-            end: span.end - offset,
-        };
-        // TODO: use matcher.add_lazy to lazy evaluate an item if it matches the prefix
-        let mut add_suggestion = |value: String,
-                                  description: Option<String>,
-                                  extra: Option<Vec<String>>,
-                                  kind: SuggestionKind| {
-            results.push(SemanticSuggestion {
-                suggestion: Suggestion {
-                    value,
-                    span,
-                    description,
-                    extra,
-                    ..Suggestion::default()
-                },
-                kind: Some(kind),
-            });
-        };
-
-        let working_set = self.temp_working_set.as_ref().unwrap_or(working_set);
-        let module = working_set.get_module(self.module_id);
-
-        for (name, decl_id) in &module.decls {
-            let name = String::from_utf8_lossy(name).to_string();
-            if matcher.matches(&name) {
-                let cmd = working_set.get_decl(*decl_id);
-                add_suggestion(
-                    wrapped_name(name),
-                    Some(cmd.description().to_string()),
-                    None,
-                    // `None` here avoids arguments being expanded by snippet edit style for lsp
-                    SuggestionKind::Command(cmd.command_type(), None),
-                );
-            }
-        }
-        for (name, module_id) in &module.submodules {
-            let name = String::from_utf8_lossy(name).to_string();
-            if matcher.matches(&name) {
-                let comments = working_set.get_module_comments(*module_id).map(|spans| {
-                    spans
-                        .iter()
-                        .map(|sp| {
-                            String::from_utf8_lossy(working_set.get_span_contents(*sp)).into()
-                        })
-                        .collect::<Vec<String>>()
-                });
-                add_suggestion(
-                    wrapped_name(name),
-                    Some("Submodule".into()),
-                    comments,
-                    SuggestionKind::Module,
-                );
-            }
-        }
-        for (name, var_id) in &module.constants {
-            let name = String::from_utf8_lossy(name).to_string();
-            if matcher.matches(&name) {
-                let var = working_set.get_variable(*var_id);
-                add_suggestion(
-                    wrapped_name(name),
-                    var.const_val
-                        .as_ref()
-                        .and_then(|v| v.clone().coerce_into_string().ok()),
-                    None,
-                    SuggestionKind::Variable,
-                );
-            }
-        }
-        results
-    }
-}
--- a/crates/nu-cli/src/completions/file_completions.rs
+++ b/crates/nu-cli/src/completions/file_completions.rs
@ -2,39 +2,49 @@ use crate::completions::{
    completion_common::{adjust_if_intermediate, complete_item, AdjustView},
    Completer, CompletionOptions,
 };
+use nu_ansi_term::Style;
 use nu_protocol::{
    engine::{EngineState, Stack, StateWorkingSet},
    Span,
 };
+use nu_utils::IgnoreCaseExt;
 use reedline::Suggestion;
 use std::path::Path;

-use super::{completion_common::FileSuggestion, SemanticSuggestion, SuggestionKind};
+use super::SemanticSuggestion;

-pub struct FileCompletion;
+#[derive(Clone, Default)]
+pub struct FileCompletion {}
+
+impl FileCompletion {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}

 impl Completer for FileCompletion {
    fn fetch(
        &mut self,
        working_set: &StateWorkingSet,
        stack: &Stack,
-        prefix: impl AsRef<str>,
+        prefix: &[u8],
        span: Span,
        offset: usize,
+        _pos: usize,
        options: &CompletionOptions,
    ) -> Vec<SemanticSuggestion> {
        let AdjustView {
            prefix,
            span,
            readjusted,
-        } = adjust_if_intermediate(prefix.as_ref(), working_set, span);
+        } = adjust_if_intermediate(prefix, working_set, span);

        #[allow(deprecated)]
        let items: Vec<_> = complete_item(
            readjusted,
            span,
            &prefix,
-            &[&working_set.permanent_state.current_work_dir()],
+            &working_set.permanent_state.current_work_dir(),
            options,
            working_set.permanent_state,
            stack,
@ -42,19 +52,16 @@ impl Completer for FileCompletion {
        .into_iter()
        .map(move |x| SemanticSuggestion {
            suggestion: Suggestion {
-                value: x.path,
-                style: x.style,
+                value: x.1,
+                style: x.2,
                span: reedline::Span {
-                    start: x.span.start - offset,
-                    end: x.span.end - offset,
+                    start: x.0.start - offset,
+                    end: x.0.end - offset,
                },
                ..Suggestion::default()
            },
-            kind: Some(if x.is_dir {
-                SuggestionKind::Directory
-            } else {
-                SuggestionKind::File
-            }),
+            // TODO????
+            kind: None,
        })
        .collect();

@ -88,10 +95,21 @@ impl Completer for FileCompletion {
 pub fn file_path_completion(
    span: nu_protocol::Span,
    partial: &str,
-    cwds: &[impl AsRef<str>],
+    cwd: &str,
    options: &CompletionOptions,
    engine_state: &EngineState,
    stack: &Stack,
-) -> Vec<FileSuggestion> {
-    complete_item(false, span, partial, cwds, options, engine_state, stack)
+) -> Vec<(nu_protocol::Span, String, Option<Style>)> {
+    complete_item(false, span, partial, cwd, options, engine_state, stack)
+}
+
+pub fn matches(partial: &str, from: &str, options: &CompletionOptions) -> bool {
+    // Check for case sensitive
+    if !options.case_sensitive {
+        return options
+            .match_algorithm
+            .matches_str(&from.to_folded_case(), &partial.to_folded_case());
+    }
+
+    options.match_algorithm.matches_str(from, partial)
 }
--- a/crates/nu-cli/src/completions/flag_completions.rs
+++ b/crates/nu-cli/src/completions/flag_completions.rs
@ -1,15 +1,22 @@
-use crate::completions::{
-    completion_options::NuMatcher, Completer, CompletionOptions, SemanticSuggestion, SuggestionKind,
-};
+use crate::completions::{completion_common::sort_suggestions, Completer, CompletionOptions};
 use nu_protocol::{
+    ast::{Expr, Expression},
    engine::{Stack, StateWorkingSet},
-    DeclId, Span,
+    Span,
 };
 use reedline::Suggestion;

+use super::SemanticSuggestion;
+
 #[derive(Clone)]
 pub struct FlagCompletion {
-    pub decl_id: DeclId,
+    expression: Expression,
+}
+
+impl FlagCompletion {
+    pub fn new(expression: Expression) -> Self {
+        Self { expression }
+    }
 }

 impl Completer for FlagCompletion {
@ -17,42 +24,73 @@ impl Completer for FlagCompletion {
        &mut self,
        working_set: &StateWorkingSet,
        _stack: &Stack,
-        prefix: impl AsRef<str>,
+        prefix: &[u8],
        span: Span,
        offset: usize,
+        _pos: usize,
        options: &CompletionOptions,
    ) -> Vec<SemanticSuggestion> {
-        let mut matcher = NuMatcher::new(prefix, options);
-        let mut add_suggestion = |value: String, description: String| {
-            matcher.add_semantic_suggestion(SemanticSuggestion {
-                suggestion: Suggestion {
-                    value,
-                    description: Some(description),
-                    span: reedline::Span {
-                        start: span.start - offset,
-                        end: span.end - offset,
-                    },
-                    append_whitespace: true,
-                    ..Suggestion::default()
-                },
-                kind: Some(SuggestionKind::Flag),
-            });
-        };
+        // Check if it's a flag
+        if let Expr::Call(call) = &self.expression.expr {
+            let decl = working_set.get_decl(call.decl_id);
+            let sig = decl.signature();

-        let decl = working_set.get_decl(self.decl_id);
-        let sig = decl.signature();
-        for named in &sig.named {
-            if let Some(short) = named.short {
-                let mut name = String::from("-");
-                name.push(short);
-                add_suggestion(name, named.desc.clone());
+            let mut output = vec![];
+
+            for named in &sig.named {
+                let flag_desc = &named.desc;
+                if let Some(short) = named.short {
+                    let mut named = vec![0; short.len_utf8()];
+                    short.encode_utf8(&mut named);
+                    named.insert(0, b'-');
+
+                    if options.match_algorithm.matches_u8(&named, prefix) {
+                        output.push(SemanticSuggestion {
+                            suggestion: Suggestion {
+                                value: String::from_utf8_lossy(&named).to_string(),
+                                description: Some(flag_desc.to_string()),
+                                span: reedline::Span {
+                                    start: span.start - offset,
+                                    end: span.end - offset,
+                                },
+                                append_whitespace: true,
+                                ..Suggestion::default()
+                            },
+                            // TODO????
+                            kind: None,
+                        });
+                    }
+                }
+
+                if named.long.is_empty() {
+                    continue;
+                }
+
+                let mut named = named.long.as_bytes().to_vec();
+                named.insert(0, b'-');
+                named.insert(0, b'-');
+
+                if options.match_algorithm.matches_u8(&named, prefix) {
+                    output.push(SemanticSuggestion {
+                        suggestion: Suggestion {
+                            value: String::from_utf8_lossy(&named).to_string(),
+                            description: Some(flag_desc.to_string()),
+                            span: reedline::Span {
+                                start: span.start - offset,
+                                end: span.end - offset,
+                            },
+                            append_whitespace: true,
+                            ..Suggestion::default()
+                        },
+                        // TODO????
+                        kind: None,
+                    });
+                }
            }

-            if named.long.is_empty() {
-                continue;
-            }
-            add_suggestion(format!("--{}", named.long), named.desc.clone());
+            return sort_suggestions(&String::from_utf8_lossy(prefix), output, options);
        }
-        matcher.results()
+
+        vec![]
    }
 }
--- a/crates/nu-cli/src/completions/mod.rs
+++ b/crates/nu-cli/src/completions/mod.rs
@ -1,6 +1,4 @@
-mod attribute_completions;
 mod base;
-mod cell_path_completions;
 mod command_completions;
 mod completer;
 mod completion_common;
@ -8,23 +6,19 @@ mod completion_options;
 mod custom_completions;
 mod directory_completions;
 mod dotnu_completions;
-mod exportable_completions;
 mod file_completions;
 mod flag_completions;
 mod operator_completions;
 mod variable_completions;

-pub use attribute_completions::{AttributableCompletion, AttributeCompletion};
 pub use base::{Completer, SemanticSuggestion, SuggestionKind};
-pub use cell_path_completions::CellPathCompletion;
 pub use command_completions::CommandCompletion;
 pub use completer::NuCompleter;
 pub use completion_options::{CompletionOptions, MatchAlgorithm};
 pub use custom_completions::CustomCompletion;
 pub use directory_completions::DirectoryCompletion;
 pub use dotnu_completions::DotNuCompletion;
-pub use exportable_completions::ExportableCompletion;
-pub use file_completions::{file_path_completion, FileCompletion};
+pub use file_completions::{file_path_completion, matches, FileCompletion};
 pub use flag_completions::FlagCompletion;
 pub use operator_completions::OperatorCompletion;
 pub use variable_completions::VariableCompletion;
--- a/crates/nu-cli/src/completions/operator_completions.rs
+++ b/crates/nu-cli/src/completions/operator_completions.rs
@ -1,277 +1,182 @@
 use crate::completions::{
-    completion_options::NuMatcher, Completer, CompletionOptions, SemanticSuggestion, SuggestionKind,
+    Completer, CompletionOptions, MatchAlgorithm, SemanticSuggestion, SuggestionKind,
 };
 use nu_protocol::{
-    ast::{self, Comparison, Expr, Expression},
+    ast::{Expr, Expression},
    engine::{Stack, StateWorkingSet},
-    Span, Type, Value, ENV_VARIABLE_ID,
+    Span, Type,
 };
 use reedline::Suggestion;
-use strum::{EnumMessage, IntoEnumIterator};
-
-use super::cell_path_completions::eval_cell_path;

 #[derive(Clone)]
-pub struct OperatorCompletion<'a> {
-    pub left_hand_side: &'a Expression,
+pub struct OperatorCompletion {
+    previous_expr: Expression,
 }

-struct OperatorItem {
-    pub symbols: String,
-    pub description: String,
-}
-
-fn operator_to_item<T: EnumMessage + AsRef<str>>(op: T) -> OperatorItem {
-    OperatorItem {
-        symbols: op.as_ref().into(),
-        description: op.get_message().unwrap_or_default().into(),
+impl OperatorCompletion {
+    pub fn new(previous_expr: Expression) -> Self {
+        OperatorCompletion { previous_expr }
    }
 }

-fn common_comparison_ops() -> Vec<OperatorItem> {
-    vec![
-        operator_to_item(Comparison::In),
-        operator_to_item(Comparison::NotIn),
-        operator_to_item(Comparison::Equal),
-        operator_to_item(Comparison::NotEqual),
-    ]
-}
-
-fn all_ops_for_immutable() -> Vec<OperatorItem> {
-    ast::Comparison::iter()
-        .map(operator_to_item)
-        .chain(ast::Math::iter().map(operator_to_item))
-        .chain(ast::Boolean::iter().map(operator_to_item))
-        .chain(ast::Bits::iter().map(operator_to_item))
-        .collect()
-}
-
-fn collection_comparison_ops() -> Vec<OperatorItem> {
-    let mut ops = common_comparison_ops();
-    ops.push(operator_to_item(Comparison::Has));
-    ops.push(operator_to_item(Comparison::NotHas));
-    ops
-}
-
-fn number_comparison_ops() -> Vec<OperatorItem> {
-    Comparison::iter()
-        .filter(|op| {
-            !matches!(
-                op,
-                Comparison::RegexMatch
-                    | Comparison::NotRegexMatch
-                    | Comparison::StartsWith
-                    | Comparison::EndsWith
-                    | Comparison::Has
-                    | Comparison::NotHas
-            )
-        })
-        .map(operator_to_item)
-        .collect()
-}
-
-fn math_ops() -> Vec<OperatorItem> {
-    ast::Math::iter()
-        .filter(|op| !matches!(op, ast::Math::Concatenate | ast::Math::Pow))
-        .map(operator_to_item)
-        .collect()
-}
-
-fn bit_ops() -> Vec<OperatorItem> {
-    ast::Bits::iter().map(operator_to_item).collect()
-}
-
-fn all_assignment_ops() -> Vec<OperatorItem> {
-    ast::Assignment::iter().map(operator_to_item).collect()
-}
-
-fn numeric_assignment_ops() -> Vec<OperatorItem> {
-    ast::Assignment::iter()
-        .filter(|op| !matches!(op, ast::Assignment::ConcatenateAssign))
-        .map(operator_to_item)
-        .collect()
-}
-
-fn concat_assignment_ops() -> Vec<OperatorItem> {
-    vec![
-        operator_to_item(ast::Assignment::Assign),
-        operator_to_item(ast::Assignment::ConcatenateAssign),
-    ]
-}
-
-fn valid_int_ops() -> Vec<OperatorItem> {
-    let mut ops = valid_float_ops();
-    ops.extend(bit_ops());
-    ops
-}
-
-fn valid_float_ops() -> Vec<OperatorItem> {
-    let mut ops = valid_value_with_unit_ops();
-    ops.push(operator_to_item(ast::Math::Pow));
-    ops
-}
-
-fn valid_string_ops() -> Vec<OperatorItem> {
-    let mut ops: Vec<OperatorItem> = Comparison::iter().map(operator_to_item).collect();
-    ops.push(operator_to_item(ast::Math::Concatenate));
-    ops.push(OperatorItem {
-        symbols: "like".into(),
-        description: Comparison::RegexMatch
-            .get_message()
-            .unwrap_or_default()
-            .into(),
-    });
-    ops.push(OperatorItem {
-        symbols: "not-like".into(),
-        description: Comparison::NotRegexMatch
-            .get_message()
-            .unwrap_or_default()
-            .into(),
-    });
-    ops
-}
-
-fn valid_list_ops() -> Vec<OperatorItem> {
-    let mut ops = collection_comparison_ops();
-    ops.push(operator_to_item(ast::Math::Concatenate));
-    ops
-}
-
-fn valid_binary_ops() -> Vec<OperatorItem> {
-    let mut ops = number_comparison_ops();
-    ops.extend(bit_ops());
-    ops.push(operator_to_item(ast::Math::Concatenate));
-    ops
-}
-
-fn valid_bool_ops() -> Vec<OperatorItem> {
-    let mut ops: Vec<OperatorItem> = ast::Boolean::iter().map(operator_to_item).collect();
-    ops.extend(common_comparison_ops());
-    ops
-}
-
-fn valid_value_with_unit_ops() -> Vec<OperatorItem> {
-    let mut ops = number_comparison_ops();
-    ops.extend(math_ops());
-    ops
-}
-
-fn ops_by_value(value: &Value, mutable: bool) -> Vec<OperatorItem> {
-    let mut ops = match value {
-        Value::Int { .. } => valid_int_ops(),
-        Value::Float { .. } => valid_float_ops(),
-        Value::String { .. } => valid_string_ops(),
-        Value::Binary { .. } => valid_binary_ops(),
-        Value::Bool { .. } => valid_bool_ops(),
-        Value::Date { .. } => number_comparison_ops(),
-        Value::Filesize { .. } | Value::Duration { .. } => valid_value_with_unit_ops(),
-        Value::Range { .. } | Value::Record { .. } => collection_comparison_ops(),
-        Value::List { .. } => valid_list_ops(),
-        _ => all_ops_for_immutable(),
-    };
-    if mutable {
-        ops.extend(match value {
-            Value::Int { .. }
-            | Value::Float { .. }
-            | Value::Filesize { .. }
-            | Value::Duration { .. } => numeric_assignment_ops(),
-            Value::String { .. } | Value::Binary { .. } | Value::List { .. } => {
-                concat_assignment_ops()
-            }
-            Value::Bool { .. }
-            | Value::Date { .. }
-            | Value::Range { .. }
-            | Value::Record { .. } => vec![operator_to_item(ast::Assignment::Assign)],
-            _ => all_assignment_ops(),
-        })
-    }
-    ops
-}
-
-fn is_expression_mutable(expr: &Expr, working_set: &StateWorkingSet) -> bool {
-    let Expr::FullCellPath(path) = expr else {
-        return false;
-    };
-    let Expr::Var(id) = path.head.expr else {
-        return false;
-    };
-    if id == ENV_VARIABLE_ID {
-        return true;
-    }
-    let var = working_set.get_variable(id);
-    var.mutable
-}
-
-impl Completer for OperatorCompletion<'_> {
+impl Completer for OperatorCompletion {
    fn fetch(
        &mut self,
        working_set: &StateWorkingSet,
-        stack: &Stack,
-        prefix: impl AsRef<str>,
+        _stack: &Stack,
+        _prefix: &[u8],
        span: Span,
        offset: usize,
-        options: &CompletionOptions,
+        _pos: usize,
+        _options: &CompletionOptions,
    ) -> Vec<SemanticSuggestion> {
-        let mut needs_assignment_ops = true;
-        // Complete according expression type
-        // TODO: type inference on self.left_hand_side to get more accurate completions
-        let mut possible_operations: Vec<OperatorItem> = match &self.left_hand_side.ty {
-            Type::Int | Type::Number => valid_int_ops(),
-            Type::Float => valid_float_ops(),
-            Type::String => valid_string_ops(),
-            Type::Binary => valid_binary_ops(),
-            Type::Bool => valid_bool_ops(),
-            Type::Date => number_comparison_ops(),
-            Type::Filesize | Type::Duration => valid_value_with_unit_ops(),
-            Type::Record(_) | Type::Range => collection_comparison_ops(),
-            Type::List(_) | Type::Table(_) => valid_list_ops(),
-            // Unknown type, resort to evaluated values
-            Type::Any => match &self.left_hand_side.expr {
-                Expr::FullCellPath(path) => {
-                    // for `$ <tab>`
-                    if matches!(path.head.expr, Expr::Garbage) {
-                        return vec![];
-                    }
-                    let value =
-                        eval_cell_path(working_set, stack, &path.head, &path.tail, path.head.span)
-                            .unwrap_or_default();
-                    let mutable = is_expression_mutable(&self.left_hand_side.expr, working_set);
-                    // to avoid duplication
-                    needs_assignment_ops = false;
-                    ops_by_value(&value, mutable)
-                }
-                _ => all_ops_for_immutable(),
-            },
-            _ => common_comparison_ops(),
+        //Check if int, float, or string
+        let partial = std::str::from_utf8(working_set.get_span_contents(span)).unwrap_or("");
+        let op = match &self.previous_expr.expr {
+            Expr::BinaryOp(x, _, _) => &x.expr,
+            _ => {
+                return vec![];
+            }
+        };
+        let possible_operations = match op {
+            Expr::Int(_) => vec![
+                ("+", "Add (Plus)"),
+                ("-", "Subtract (Minus)"),
+                ("*", "Multiply"),
+                ("/", "Divide"),
+                ("==", "Equal to"),
+                ("!=", "Not equal to"),
+                ("//", "Floor division"),
+                ("<", "Less than"),
+                (">", "Greater than"),
+                ("<=", "Less than or equal to"),
+                (">=", "Greater than or equal to"),
+                ("mod", "Floor division remainder (Modulo)"),
+                ("**", "Power of"),
+                ("bit-or", "Bitwise OR"),
+                ("bit-xor", "Bitwise exclusive OR"),
+                ("bit-and", "Bitwise AND"),
+                ("bit-shl", "Bitwise shift left"),
+                ("bit-shr", "Bitwise shift right"),
+                ("in", "Is a member of (doesn't use regex)"),
+                ("not-in", "Is not a member of (doesn't use regex)"),
+                (
+                    "++",
+                    "Appends two lists, a list and a value, two strings, or two binary values",
+                ),
+            ],
+            Expr::String(_) => vec![
+                ("=~", "Contains regex match"),
+                ("like", "Contains regex match"),
+                ("!~", "Does not contain regex match"),
+                ("not-like", "Does not contain regex match"),
+                (
+                    "++",
+                    "Appends two lists, a list and a value, two strings, or two binary values",
+                ),
+                ("in", "Is a member of (doesn't use regex)"),
+                ("not-in", "Is not a member of (doesn't use regex)"),
+                ("starts-with", "Starts with"),
+                ("ends-with", "Ends with"),
+            ],
+            Expr::Float(_) => vec![
+                ("+", "Add (Plus)"),
+                ("-", "Subtract (Minus)"),
+                ("*", "Multiply"),
+                ("/", "Divide"),
+                ("==", "Equal to"),
+                ("!=", "Not equal to"),
+                ("//", "Floor division"),
+                ("<", "Less than"),
+                (">", "Greater than"),
+                ("<=", "Less than or equal to"),
+                (">=", "Greater than or equal to"),
+                ("mod", "Floor division remainder (Modulo)"),
+                ("**", "Power of"),
+                ("in", "Is a member of (doesn't use regex)"),
+                ("not-in", "Is not a member of (doesn't use regex)"),
+                (
+                    "++",
+                    "Appends two lists, a list and a value, two strings, or two binary values",
+                ),
+            ],
+            Expr::Bool(_) => vec![
+                (
+                    "and",
+                    "Both values are true (short-circuits when first value is false)",
+                ),
+                (
+                    "or",
+                    "Either value is true (short-circuits when first value is true)",
+                ),
+                ("xor", "One value is true and the other is false"),
+                ("not", "Negates a value or expression"),
+                ("in", "Is a member of (doesn't use regex)"),
+                ("not-in", "Is not a member of (doesn't use regex)"),
+                (
+                    "++",
+                    "Appends two lists, a list and a value, two strings, or two binary values",
+                ),
+            ],
+            Expr::FullCellPath(path) => match path.head.expr {
+                Expr::List(_) => vec![(
+                    "++",
+                    "Appends two lists, a list and a value, two strings, or two binary values",
+                )],
+                Expr::Var(id) => get_variable_completions(id, working_set),
+                _ => vec![],
+            },
+            _ => vec![],
        };
-        // If the left hand side is a variable, add assignment operators if mutable
-        if needs_assignment_ops && is_expression_mutable(&self.left_hand_side.expr, working_set) {
-            possible_operations.extend(match &self.left_hand_side.ty {
-                Type::Int | Type::Float | Type::Number => numeric_assignment_ops(),
-                Type::Filesize | Type::Duration => numeric_assignment_ops(),
-                Type::String | Type::Binary | Type::List(_) => concat_assignment_ops(),
-                Type::Any => all_assignment_ops(),
-                _ => vec![operator_to_item(ast::Assignment::Assign)],
-            });
-        }

-        let mut matcher = NuMatcher::new(prefix, options);
-        for OperatorItem {
-            symbols,
-            description,
-        } in possible_operations
-        {
-            matcher.add_semantic_suggestion(SemanticSuggestion {
+        let match_algorithm = MatchAlgorithm::Prefix;
+        let input_fuzzy_search =
+            |(operator, _): &(&str, &str)| match_algorithm.matches_str(operator, partial);
+
+        possible_operations
+            .into_iter()
+            .filter(input_fuzzy_search)
+            .map(move |x| SemanticSuggestion {
                suggestion: Suggestion {
-                    value: symbols.to_owned(),
-                    description: Some(description.to_owned()),
+                    value: x.0.to_string(),
+                    description: Some(x.1.to_string()),
                    span: reedline::Span::new(span.start - offset, span.end - offset),
                    append_whitespace: true,
                    ..Suggestion::default()
                },
-                kind: Some(SuggestionKind::Operator),
-            });
-        }
-        matcher.results()
+                kind: Some(SuggestionKind::Command(
+                    nu_protocol::engine::CommandType::Builtin,
+                )),
+            })
+            .collect()
+    }
+}
+
+pub fn get_variable_completions<'a>(
+    id: nu_protocol::Id<nu_protocol::marker::Var>,
+    working_set: &StateWorkingSet,
+) -> Vec<(&'a str, &'a str)> {
+    let var = working_set.get_variable(id);
+    if !var.mutable {
+        return vec![];
+    }
+
+    match var.ty {
+        Type::List(_) | Type::String | Type::Binary => vec![
+            (
+                "++=",
+                "Appends a list, a value, a string, or a binary value to a variable.",
+            ),
+            ("=", "Assigns a value to a variable."),
+        ],
+
+        Type::Int | Type::Float => vec![
+            ("=", "Assigns a value to a variable."),
+            ("+=", "Adds a value to a variable."),
+            ("-=", "Subtracts a value from a variable."),
+            ("*=", "Multiplies a variable by a value"),
+            ("/=", "Divides a variable by a value."),
+        ],
+        _ => vec![],
    }
 }
--- a/crates/nu-cli/src/completions/variable_completions.rs
+++ b/crates/nu-cli/src/completions/variable_completions.rs
@ -1,55 +1,167 @@
-use crate::completions::{Completer, CompletionOptions, SemanticSuggestion, SuggestionKind};
+use crate::completions::{
+    Completer, CompletionOptions, MatchAlgorithm, SemanticSuggestion, SuggestionKind,
+};
+use nu_engine::{column::get_columns, eval_variable};
 use nu_protocol::{
    engine::{Stack, StateWorkingSet},
-    Span, VarId,
+    Span, Value,
 };
 use reedline::Suggestion;
+use std::str;

-use super::completion_options::NuMatcher;
+use super::completion_common::sort_suggestions;

-pub struct VariableCompletion;
+#[derive(Clone)]
+pub struct VariableCompletion {
+    var_context: (Vec<u8>, Vec<Vec<u8>>), // tuple with $var and the sublevels (.b.c.d)
+}
+
+impl VariableCompletion {
+    pub fn new(var_context: (Vec<u8>, Vec<Vec<u8>>)) -> Self {
+        Self { var_context }
+    }
+}

 impl Completer for VariableCompletion {
    fn fetch(
        &mut self,
        working_set: &StateWorkingSet,
-        _stack: &Stack,
-        prefix: impl AsRef<str>,
+        stack: &Stack,
+        prefix: &[u8],
        span: Span,
        offset: usize,
+        _pos: usize,
        options: &CompletionOptions,
    ) -> Vec<SemanticSuggestion> {
-        let mut matcher = NuMatcher::new(prefix, options);
+        let mut output = vec![];
+        let builtins = ["$nu", "$in", "$env"];
+        let var_str = std::str::from_utf8(&self.var_context.0).unwrap_or("");
+        let var_id = working_set.find_variable(&self.var_context.0);
        let current_span = reedline::Span {
            start: span.start - offset,
            end: span.end - offset,
        };
+        let sublevels_count = self.var_context.1.len();
+        let prefix_str = String::from_utf8_lossy(prefix);

-        // Variable completion (e.g: $en<tab> to complete $env)
-        let builtins = ["$nu", "$in", "$env"];
-        for builtin in builtins {
-            matcher.add_semantic_suggestion(SemanticSuggestion {
-                suggestion: Suggestion {
-                    value: builtin.to_string(),
-                    span: current_span,
-                    description: Some("reserved".into()),
-                    ..Suggestion::default()
-                },
-                kind: Some(SuggestionKind::Variable),
-            });
+        // Completions for the given variable
+        if !var_str.is_empty() {
+            // Completion for $env.<tab>
+            if var_str == "$env" {
+                let env_vars = stack.get_env_vars(working_set.permanent_state);
+
+                // Return nested values
+                if sublevels_count > 0 {
+                    // Extract the target var ($env.<target-var>)
+                    let target_var = self.var_context.1[0].clone();
+                    let target_var_str =
+                        str::from_utf8(&target_var).unwrap_or_default().to_string();
+
+                    // Everything after the target var is the nested level ($env.<target-var>.<nested_levels>...)
+                    let nested_levels: Vec<Vec<u8>> =
+                        self.var_context.1.clone().into_iter().skip(1).collect();
+
+                    if let Some(val) = env_vars.get(&target_var_str) {
+                        for suggestion in nested_suggestions(val, &nested_levels, current_span) {
+                            if options.match_algorithm.matches_u8_insensitive(
+                                options.case_sensitive,
+                                suggestion.suggestion.value.as_bytes(),
+                                prefix,
+                            ) {
+                                output.push(suggestion);
+                            }
+                        }
+
+                        return sort_suggestions(&prefix_str, output, options);
+                    }
+                } else {
+                    // No nesting provided, return all env vars
+                    for env_var in env_vars {
+                        if options.match_algorithm.matches_u8_insensitive(
+                            options.case_sensitive,
+                            env_var.0.as_bytes(),
+                            prefix,
+                        ) {
+                            output.push(SemanticSuggestion {
+                                suggestion: Suggestion {
+                                    value: env_var.0,
+                                    span: current_span,
+                                    ..Suggestion::default()
+                                },
+                                kind: Some(SuggestionKind::Type(env_var.1.get_type())),
+                            });
+                        }
+                    }
+
+                    return sort_suggestions(&prefix_str, output, options);
+                }
+            }
+
+            // Completions for $nu.<tab>
+            if var_str == "$nu" {
+                // Eval nu var
+                if let Ok(nuval) = eval_variable(
+                    working_set.permanent_state,
+                    stack,
+                    nu_protocol::NU_VARIABLE_ID,
+                    nu_protocol::Span::new(current_span.start, current_span.end),
+                ) {
+                    for suggestion in nested_suggestions(&nuval, &self.var_context.1, current_span)
+                    {
+                        if options.match_algorithm.matches_u8_insensitive(
+                            options.case_sensitive,
+                            suggestion.suggestion.value.as_bytes(),
+                            prefix,
+                        ) {
+                            output.push(suggestion);
+                        }
+                    }
+
+                    return sort_suggestions(&prefix_str, output, options);
+                }
+            }
+
+            // Completion other variable types
+            if let Some(var_id) = var_id {
+                // Extract the variable value from the stack
+                let var = stack.get_var(var_id, Span::new(span.start, span.end));
+
+                // If the value exists and it's of type Record
+                if let Ok(value) = var {
+                    for suggestion in nested_suggestions(&value, &self.var_context.1, current_span)
+                    {
+                        if options.match_algorithm.matches_u8_insensitive(
+                            options.case_sensitive,
+                            suggestion.suggestion.value.as_bytes(),
+                            prefix,
+                        ) {
+                            output.push(suggestion);
+                        }
+                    }
+
+                    return sort_suggestions(&prefix_str, output, options);
+                }
+            }
        }

-        let mut add_candidate = |name, var_id: &VarId| {
-            matcher.add_semantic_suggestion(SemanticSuggestion {
-                suggestion: Suggestion {
-                    value: String::from_utf8_lossy(name).to_string(),
-                    span: current_span,
-                    description: Some(working_set.get_variable(*var_id).ty.to_string()),
-                    ..Suggestion::default()
-                },
-                kind: Some(SuggestionKind::Variable),
-            })
-        };
+        // Variable completion (e.g: $en<tab> to complete $env)
+        for builtin in builtins {
+            if options.match_algorithm.matches_u8_insensitive(
+                options.case_sensitive,
+                builtin.as_bytes(),
+                prefix,
+            ) {
+                output.push(SemanticSuggestion {
+                    suggestion: Suggestion {
+                        value: builtin.to_string(),
+                        span: current_span,
+                        ..Suggestion::default()
+                    },
+                    // TODO is there a way to get the VarId to get the type???
+                    kind: None,
+                });
+            }
+        }

        // TODO: The following can be refactored (see find_commands_by_predicate() used in
        // command_completions).
@ -57,11 +169,27 @@ impl Completer for VariableCompletion {
        // Working set scope vars
        for scope_frame in working_set.delta.scope.iter().rev() {
            for overlay_frame in scope_frame.active_overlays(&mut removed_overlays).rev() {
-                for (name, var_id) in &overlay_frame.vars {
-                    add_candidate(name, var_id);
+                for v in &overlay_frame.vars {
+                    if options.match_algorithm.matches_u8_insensitive(
+                        options.case_sensitive,
+                        v.0,
+                        prefix,
+                    ) {
+                        output.push(SemanticSuggestion {
+                            suggestion: Suggestion {
+                                value: String::from_utf8_lossy(v.0).to_string(),
+                                span: current_span,
+                                ..Suggestion::default()
+                            },
+                            kind: Some(SuggestionKind::Type(
+                                working_set.get_variable(*v.1).ty.clone(),
+                            )),
+                        });
+                    }
                }
            }
        }
+
        // Permanent state vars
        // for scope in &self.engine_state.scope {
        for overlay_frame in working_set
@ -69,11 +197,118 @@ impl Completer for VariableCompletion {
            .active_overlays(&removed_overlays)
            .rev()
        {
-            for (name, var_id) in &overlay_frame.vars {
-                add_candidate(name, var_id);
+            for v in &overlay_frame.vars {
+                if options.match_algorithm.matches_u8_insensitive(
+                    options.case_sensitive,
+                    v.0,
+                    prefix,
+                ) {
+                    output.push(SemanticSuggestion {
+                        suggestion: Suggestion {
+                            value: String::from_utf8_lossy(v.0).to_string(),
+                            span: current_span,
+                            ..Suggestion::default()
+                        },
+                        kind: Some(SuggestionKind::Type(
+                            working_set.get_variable(*v.1).ty.clone(),
+                        )),
+                    });
+                }
            }
        }

-        matcher.results()
+        output = sort_suggestions(&prefix_str, output, options);
+
+        output.dedup(); // TODO: Removes only consecutive duplicates, is it intended?
+
+        output
+    }
+}
+
+// Find recursively the values for sublevels
+// if no sublevels are set it returns the current value
+fn nested_suggestions(
+    val: &Value,
+    sublevels: &[Vec<u8>],
+    current_span: reedline::Span,
+) -> Vec<SemanticSuggestion> {
+    let mut output: Vec<SemanticSuggestion> = vec![];
+    let value = recursive_value(val, sublevels).unwrap_or_else(Value::nothing);
+
+    let kind = SuggestionKind::Type(value.get_type());
+    match value {
+        Value::Record { val, .. } => {
+            // Add all the columns as completion
+            for col in val.columns() {
+                output.push(SemanticSuggestion {
+                    suggestion: Suggestion {
+                        value: col.clone(),
+                        span: current_span,
+                        ..Suggestion::default()
+                    },
+                    kind: Some(kind.clone()),
+                });
+            }
+
+            output
+        }
+        Value::List { vals, .. } => {
+            for column_name in get_columns(vals.as_slice()) {
+                output.push(SemanticSuggestion {
+                    suggestion: Suggestion {
+                        value: column_name,
+                        span: current_span,
+                        ..Suggestion::default()
+                    },
+                    kind: Some(kind.clone()),
+                });
+            }
+
+            output
+        }
+        _ => output,
+    }
+}
+
+// Extracts the recursive value (e.g: $var.a.b.c)
+fn recursive_value(val: &Value, sublevels: &[Vec<u8>]) -> Result<Value, Span> {
+    // Go to next sublevel
+    if let Some((sublevel, next_sublevels)) = sublevels.split_first() {
+        let span = val.span();
+        match val {
+            Value::Record { val, .. } => {
+                if let Some((_, value)) = val.iter().find(|(key, _)| key.as_bytes() == sublevel) {
+                    // If matches try to fetch recursively the next
+                    recursive_value(value, next_sublevels)
+                } else {
+                    // Current sublevel value not found
+                    Err(span)
+                }
+            }
+            Value::List { vals, .. } => {
+                for col in get_columns(vals.as_slice()) {
+                    if col.as_bytes() == *sublevel {
+                        let val = val.get_data_by_key(&col).ok_or(span)?;
+                        return recursive_value(&val, next_sublevels);
+                    }
+                }
+
+                // Current sublevel value not found
+                Err(span)
+            }
+            _ => Ok(val.clone()),
+        }
+    } else {
+        Ok(val.clone())
+    }
+}
+
+impl MatchAlgorithm {
+    pub fn matches_u8_insensitive(&self, sensitive: bool, haystack: &[u8], needle: &[u8]) -> bool {
+        if sensitive {
+            self.matches_u8(haystack, needle)
+        } else {
+            self.matches_u8(&haystack.to_ascii_lowercase(), &needle.to_ascii_lowercase())
+        }
    }
 }
--- a/crates/nu-cli/src/config_files.rs
+++ b/crates/nu-cli/src/config_files.rs
@ -18,7 +18,7 @@ const OLD_PLUGIN_FILE: &str = "plugin.nu";

 #[cfg(feature = "plugin")]
 pub fn read_plugin_file(engine_state: &mut EngineState, plugin_file: Option<Spanned<String>>) {
-    use nu_protocol::{shell_error::io::IoError, ShellError};
+    use nu_protocol::ShellError;
    use std::path::Path;

    let span = plugin_file.as_ref().map(|s| s.span);
@ -49,10 +49,7 @@ pub fn read_plugin_file(engine_state: &mut EngineState, plugin_file: Option<Span
    perf!(
        "add plugin file to engine_state",
        start_time,
-        engine_state
-            .get_config()
-            .use_ansi_coloring
-            .get(engine_state)
+        engine_state.get_config().use_ansi_coloring
    );

    start_time = std::time::Instant::now();
@ -78,12 +75,16 @@ pub fn read_plugin_file(engine_state: &mut EngineState, plugin_file: Option<Span
                } else {
                    report_shell_error(
                        engine_state,
-                        &ShellError::Io(IoError::new_internal_with_path(
-                            err.kind(),
-                            "Could not open plugin registry file",
-                            nu_protocol::location!(),
-                            plugin_path,
-                        )),
+                        &ShellError::GenericError {
+                            error: format!(
+                                "Error while opening plugin registry file: {}",
+                                plugin_path.display()
+                            ),
+                            msg: "plugin path defined here".into(),
+                            span,
+                            help: None,
+                            inner: vec![err.into()],
+                        },
                    );
                    return;
                }
@ -128,10 +129,7 @@ pub fn read_plugin_file(engine_state: &mut EngineState, plugin_file: Option<Span
        perf!(
            &format!("read plugin file {}", plugin_path.display()),
            start_time,
-            engine_state
-                .get_config()
-                .use_ansi_coloring
-                .get(engine_state)
+            engine_state.get_config().use_ansi_coloring
        );
        start_time = std::time::Instant::now();

@ -147,10 +145,7 @@ pub fn read_plugin_file(engine_state: &mut EngineState, plugin_file: Option<Span
        perf!(
            &format!("load plugin file {}", plugin_path.display()),
            start_time,
-            engine_state
-                .get_config()
-                .use_ansi_coloring
-                .get(engine_state)
+            engine_state.get_config().use_ansi_coloring
        );
    }
 }
@ -230,8 +225,8 @@ pub fn eval_config_contents(
 #[cfg(feature = "plugin")]
 pub fn migrate_old_plugin_file(engine_state: &EngineState) -> bool {
    use nu_protocol::{
-        shell_error::io::IoError, PluginExample, PluginIdentity, PluginRegistryItem,
-        PluginRegistryItemData, PluginSignature, ShellError,
+        PluginExample, PluginIdentity, PluginRegistryItem, PluginRegistryItemData, PluginSignature,
+        ShellError,
    };
    use std::collections::BTreeMap;

@ -320,15 +315,7 @@ pub fn migrate_old_plugin_file(engine_state: &EngineState) -> bool {
    // Write the new file
    let new_plugin_file_path = config_dir.join(PLUGIN_FILE);
    if let Err(err) = std::fs::File::create(&new_plugin_file_path)
-        .map_err(|err| {
-            IoError::new_internal_with_path(
-                err.kind(),
-                "Could not create new plugin file",
-                nu_protocol::location!(),
-                new_plugin_file_path.clone(),
-            )
-        })
-        .map_err(ShellError::from)
+        .map_err(|e| e.into())
        .and_then(|file| contents.write_to(file, None))
    {
        report_shell_error(
@ -358,10 +345,7 @@ pub fn migrate_old_plugin_file(engine_state: &EngineState) -> bool {
    perf!(
        "migrate old plugin file",
        start_time,
-        engine_state
-            .get_config()
-            .use_ansi_coloring
-            .get(&engine_state)
+        engine_state.get_config().use_ansi_coloring
    );
    true
 }
--- a/crates/nu-cli/src/eval_cmds.rs
+++ b/crates/nu-cli/src/eval_cmds.rs
@ -1,5 +1,5 @@
 use log::info;
-use nu_engine::eval_block;
+use nu_engine::{convert_env_values, eval_block};
 use nu_parser::parse;
 use nu_protocol::{
    cli_error::report_compile_error,
@ -9,8 +9,6 @@ use nu_protocol::{
 };
 use std::sync::Arc;

-use crate::util::print_pipeline;
-
 #[derive(Default)]
 pub struct EvaluateCommandsOpts {
    pub table_mode: Option<Value>,
@ -50,6 +48,9 @@ pub fn evaluate_commands(
        }
    }

+    // Translate environment variables from Strings to Values
+    convert_env_values(engine_state, stack)?;
+
    // Parse the source code
    let (block, delta) = {
        if let Some(ref t_mode) = table_mode {
@ -71,7 +72,7 @@ pub fn evaluate_commands(

        if let Some(err) = working_set.compile_errors.first() {
            report_compile_error(&working_set, err);
-            std::process::exit(1);
+            // Not a fatal error, for now
        }

        (output, working_set.render())
@ -92,7 +93,7 @@ pub fn evaluate_commands(
            t_mode.coerce_str()?.parse().unwrap_or_default();
    }

-    print_pipeline(engine_state, stack, pipeline, no_newline)?;
+    pipeline.print(engine_state, stack, no_newline, false)?;

    info!("evaluate {}:{}:{}", file!(), line!(), column!());

--- a/crates/nu-cli/src/eval_file.rs
+++ b/crates/nu-cli/src/eval_file.rs
@ -1,17 +1,15 @@
-use crate::util::{eval_source, print_pipeline};
+use crate::util::eval_source;
 use log::{info, trace};
-use nu_engine::eval_block;
+use nu_engine::{convert_env_values, eval_block};
 use nu_parser::parse;
 use nu_path::canonicalize_with;
 use nu_protocol::{
    cli_error::report_compile_error,
    debugger::WithoutDebug,
    engine::{EngineState, Stack, StateWorkingSet},
-    report_parse_error, report_parse_warning,
-    shell_error::io::*,
-    PipelineData, ShellError, Span, Value,
+    report_parse_error, report_parse_warning, PipelineData, ShellError, Span, Value,
 };
-use std::{path::PathBuf, sync::Arc};
+use std::sync::Arc;

 /// Entry point for evaluating a file.
 ///
@ -24,16 +22,16 @@ pub fn evaluate_file(
    stack: &mut Stack,
    input: PipelineData,
 ) -> Result<(), ShellError> {
+    // Convert environment variables from Strings to Values and store them in the engine state.
+    convert_env_values(engine_state, stack)?;
+
    let cwd = engine_state.cwd_as_string(Some(stack))?;

-    let file_path = canonicalize_with(&path, cwd).map_err(|err| {
-        IoError::new_internal_with_path(
-            err.kind().not_found_as(NotFound::File),
-            "Could not access file",
-            nu_protocol::location!(),
-            PathBuf::from(&path),
-        )
-    })?;
+    let file_path =
+        canonicalize_with(&path, cwd).map_err(|err| ShellError::FileNotFoundCustom {
+            msg: format!("Could not access file '{path}': {err}"),
+            span: Span::unknown(),
+        })?;

    let file_path_str = file_path
        .to_str()
@ -45,24 +43,18 @@ pub fn evaluate_file(
            span: Span::unknown(),
        })?;

-    let file = std::fs::read(&file_path).map_err(|err| {
-        IoError::new_internal_with_path(
-            err.kind().not_found_as(NotFound::File),
-            "Could not read file",
-            nu_protocol::location!(),
-            file_path.clone(),
-        )
+    let file = std::fs::read(&file_path).map_err(|err| ShellError::FileNotFoundCustom {
+        msg: format!("Could not read file '{file_path_str}': {err}"),
+        span: Span::unknown(),
    })?;
    engine_state.file = Some(file_path.clone());

-    let parent = file_path.parent().ok_or_else(|| {
-        IoError::new_internal_with_path(
-            ErrorKind::DirectoryNotFound,
-            "The file path does not have a parent",
-            nu_protocol::location!(),
-            file_path.clone(),
-        )
-    })?;
+    let parent = file_path
+        .parent()
+        .ok_or_else(|| ShellError::FileNotFoundCustom {
+            msg: format!("The file path '{file_path_str}' does not have a parent"),
+            span: Span::unknown(),
+        })?;

    stack.add_env_var(
        "FILE_PWD".to_string(),
@ -97,7 +89,7 @@ pub fn evaluate_file(

    if let Some(err) = working_set.compile_errors.first() {
        report_compile_error(&working_set, err);
-        std::process::exit(1);
+        // Not a fatal error, for now
    }

    // Look for blocks whose name starts with "main" and replace it with the filename.
@ -127,7 +119,7 @@ pub fn evaluate_file(
            };

        // Print the pipeline output of the last command of the file.
-        print_pipeline(engine_state, stack, pipeline, true)?;
+        pipeline.print(engine_state, stack, true, false)?;

        // Invoke the main command with arguments.
        // Arguments with whitespaces are quoted, thus can be safely concatenated by whitespace.
--- a/crates/nu-cli/src/print.rs
+++ b/crates/nu-cli/src/print.rs
@ -65,12 +65,8 @@ Since this command has no output, there is no point in piping it with other comm
                    arg.into_pipeline_data()
                        .print_raw(engine_state, no_newline, to_stderr)?;
                } else {
-                    arg.into_pipeline_data().print_table(
-                        engine_state,
-                        stack,
-                        no_newline,
-                        to_stderr,
-                    )?;
+                    arg.into_pipeline_data()
+                        .print(engine_state, stack, no_newline, to_stderr)?;
                }
            }
        } else if !input.is_nothing() {
@ -82,7 +78,7 @@ Since this command has no output, there is no point in piping it with other comm
            if raw {
                input.print_raw(engine_state, no_newline, to_stderr)?;
            } else {
-                input.print_table(engine_state, stack, no_newline, to_stderr)?;
+                input.print(engine_state, stack, no_newline, to_stderr)?;
            }
        }

--- a/crates/nu-cli/src/prompt_update.rs
+++ b/crates/nu-cli/src/prompt_update.rs
@ -1,5 +1,5 @@
 use crate::NushellPrompt;
-use log::{trace, warn};
+use log::trace;
 use nu_engine::ClosureEvalOnce;
 use nu_protocol::{
    engine::{EngineState, Stack},
@ -30,21 +30,30 @@ pub(crate) const TRANSIENT_PROMPT_MULTILINE_INDICATOR: &str =
 pub(crate) const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
 pub(crate) const POST_PROMPT_MARKER: &str = "\x1b]133;B\x1b\\";
 pub(crate) const PRE_EXECUTION_MARKER: &str = "\x1b]133;C\x1b\\";
+#[allow(dead_code)]
 pub(crate) const POST_EXECUTION_MARKER_PREFIX: &str = "\x1b]133;D;";
+#[allow(dead_code)]
 pub(crate) const POST_EXECUTION_MARKER_SUFFIX: &str = "\x1b\\";

 // OSC633 is the same as OSC133 but specifically for VSCode
 pub(crate) const VSCODE_PRE_PROMPT_MARKER: &str = "\x1b]633;A\x1b\\";
 pub(crate) const VSCODE_POST_PROMPT_MARKER: &str = "\x1b]633;B\x1b\\";
+#[allow(dead_code)]
 pub(crate) const VSCODE_PRE_EXECUTION_MARKER: &str = "\x1b]633;C\x1b\\";
+#[allow(dead_code)]
 //"\x1b]633;D;{}\x1b\\"
 pub(crate) const VSCODE_POST_EXECUTION_MARKER_PREFIX: &str = "\x1b]633;D;";
+#[allow(dead_code)]
 pub(crate) const VSCODE_POST_EXECUTION_MARKER_SUFFIX: &str = "\x1b\\";
+#[allow(dead_code)]
 //"\x1b]633;E;{}\x1b\\"
 pub(crate) const VSCODE_COMMANDLINE_MARKER_PREFIX: &str = "\x1b]633;E;";
+#[allow(dead_code)]
 pub(crate) const VSCODE_COMMANDLINE_MARKER_SUFFIX: &str = "\x1b\\";
+#[allow(dead_code)]
 // "\x1b]633;P;Cwd={}\x1b\\"
 pub(crate) const VSCODE_CWD_PROPERTY_MARKER_PREFIX: &str = "\x1b]633;P;Cwd=";
+#[allow(dead_code)]
 pub(crate) const VSCODE_CWD_PROPERTY_MARKER_SUFFIX: &str = "\x1b\\";

 pub(crate) const RESET_APPLICATION_MODE: &str = "\x1b[?1l";
@ -80,19 +89,18 @@ fn get_prompt_string(
        })
        .and_then(|pipeline_data| {
            let output = pipeline_data.collect_string("", config).ok();
-            let ansi_output = output.map(|mut x| {
-                // Always reset the color at the start of the right prompt
-                // to ensure there is no ansi bleed over
-                if x.is_empty() && prompt == PROMPT_COMMAND_RIGHT {
-                    x.insert_str(0, "\x1b[0m")
-                };

+            output.map(|mut x| {
+                // Just remove the very last newline.
+                if x.ends_with('\n') {
+                    x.pop();
+                }
+
+                if x.ends_with('\r') {
+                    x.pop();
+                }
                x
-            });
-            // Let's keep this for debugging purposes with nu --log-level warn
-            warn!("{}:{}:{} {:?}", file!(), line!(), column!(), ansi_output);
-
-            ansi_output
+            })
        })
 }

--- a/crates/nu-cli/src/reedline_config.rs
+++ b/crates/nu-cli/src/reedline_config.rs
@ -711,6 +711,7 @@ pub(crate) fn create_keybindings(config: &Config) -> Result<KeybindingsMode, She
    }
    for keybinding in parsed_keybindings {
        add_keybinding(
+            &keybinding.name,
            &keybinding.mode,
            keybinding,
            config,
@ -729,7 +730,9 @@ pub(crate) fn create_keybindings(config: &Config) -> Result<KeybindingsMode, She
    }
 }

+#[allow(clippy::only_used_in_recursion)]
 fn add_keybinding(
+    name: &Option<Value>,
    mode: &Value,
    keybinding: &ParsedKeybinding,
    config: &Config,
@ -740,15 +743,9 @@ fn add_keybinding(
    let span = mode.span();
    match &mode {
        Value::String { val, .. } => match val.as_str() {
-            str if str.eq_ignore_ascii_case("emacs") => {
-                add_parsed_keybinding(emacs_keybindings, keybinding, config)
-            }
-            str if str.eq_ignore_ascii_case("vi_insert") => {
-                add_parsed_keybinding(insert_keybindings, keybinding, config)
-            }
-            str if str.eq_ignore_ascii_case("vi_normal") => {
-                add_parsed_keybinding(normal_keybindings, keybinding, config)
-            }
+            "emacs" => add_parsed_keybinding(emacs_keybindings, keybinding, config),
+            "vi_insert" => add_parsed_keybinding(insert_keybindings, keybinding, config),
+            "vi_normal" => add_parsed_keybinding(normal_keybindings, keybinding, config),
            str => Err(ShellError::InvalidValue {
                valid: "'emacs', 'vi_insert', or 'vi_normal'".into(),
                actual: format!("'{str}'"),
@ -758,6 +755,7 @@ fn add_keybinding(
        Value::List { vals, .. } => {
            for inner_mode in vals {
                add_keybinding(
+                    name,
                    inner_mode,
                    keybinding,
                    config,
@ -998,54 +996,41 @@ fn event_from_record(
 ) -> Result<ReedlineEvent, ShellError> {
    let event = match name {
        "none" => ReedlineEvent::None,
+        "clearscreen" => ReedlineEvent::ClearScreen,
+        "clearscrollback" => ReedlineEvent::ClearScrollback,
        "historyhintcomplete" => ReedlineEvent::HistoryHintComplete,
        "historyhintwordcomplete" => ReedlineEvent::HistoryHintWordComplete,
        "ctrld" => ReedlineEvent::CtrlD,
        "ctrlc" => ReedlineEvent::CtrlC,
-        "clearscreen" => ReedlineEvent::ClearScreen,
-        "clearscrollback" => ReedlineEvent::ClearScrollback,
        "enter" => ReedlineEvent::Enter,
        "submit" => ReedlineEvent::Submit,
        "submitornewline" => ReedlineEvent::SubmitOrNewline,
        "esc" | "escape" => ReedlineEvent::Esc,
-        // Non-sensical for user configuration:
-        //
-        // `ReedlineEvent::Mouse` - itself a no-op
-        // `ReedlineEvent::Resize` - requires size info specifically from the ANSI resize
-        // event
-        //
-        // Handled above in `parse_event`:
-        //
-        // `ReedlineEvent::Edit`
-        "repaint" => ReedlineEvent::Repaint,
-        "previoushistory" => ReedlineEvent::PreviousHistory,
        "up" => ReedlineEvent::Up,
        "down" => ReedlineEvent::Down,
        "right" => ReedlineEvent::Right,
        "left" => ReedlineEvent::Left,
-        "nexthistory" => ReedlineEvent::NextHistory,
        "searchhistory" => ReedlineEvent::SearchHistory,
-        // Handled above in `parse_event`:
-        //
-        // `ReedlineEvent::Multiple`
-        // `ReedlineEvent::UntilFound`
+        "nexthistory" => ReedlineEvent::NextHistory,
+        "previoushistory" => ReedlineEvent::PreviousHistory,
+        "repaint" => ReedlineEvent::Repaint,
+        "menudown" => ReedlineEvent::MenuDown,
+        "menuup" => ReedlineEvent::MenuUp,
+        "menuleft" => ReedlineEvent::MenuLeft,
+        "menuright" => ReedlineEvent::MenuRight,
+        "menunext" => ReedlineEvent::MenuNext,
+        "menuprevious" => ReedlineEvent::MenuPrevious,
+        "menupagenext" => ReedlineEvent::MenuPageNext,
+        "menupageprevious" => ReedlineEvent::MenuPagePrevious,
+        "openeditor" => ReedlineEvent::OpenEditor,
        "menu" => {
            let menu = extract_value("name", record, span)?;
            ReedlineEvent::Menu(menu.to_expanded_string("", config))
        }
-        "menunext" => ReedlineEvent::MenuNext,
-        "menuprevious" => ReedlineEvent::MenuPrevious,
-        "menuup" => ReedlineEvent::MenuUp,
-        "menudown" => ReedlineEvent::MenuDown,
-        "menuleft" => ReedlineEvent::MenuLeft,
-        "menuright" => ReedlineEvent::MenuRight,
-        "menupagenext" => ReedlineEvent::MenuPageNext,
-        "menupageprevious" => ReedlineEvent::MenuPagePrevious,
        "executehostcommand" => {
            let cmd = extract_value("cmd", record, span)?;
            ReedlineEvent::ExecuteHostCommand(cmd.to_expanded_string("", config))
        }
-        "openeditor" => ReedlineEvent::OpenEditor,
        str => {
            return Err(ShellError::InvalidValue {
                valid: "a reedline event".into(),
@ -1075,6 +1060,7 @@ fn edit_from_record(
                .and_then(|value| value.as_bool())
                .unwrap_or(false),
        },
+
        "movetoend" => EditCommand::MoveToEnd {
            select: extract_value("select", record, span)
                .and_then(|value| value.as_bool())
@ -1110,16 +1096,6 @@ fn edit_from_record(
                .and_then(|value| value.as_bool())
                .unwrap_or(false),
        },
-        "movewordrightstart" => EditCommand::MoveWordRightStart {
-            select: extract_value("select", record, span)
-                .and_then(|value| value.as_bool())
-                .unwrap_or(false),
-        },
-        "movebigwordrightstart" => EditCommand::MoveBigWordRightStart {
-            select: extract_value("select", record, span)
-                .and_then(|value| value.as_bool())
-                .unwrap_or(false),
-        },
        "movewordrightend" => EditCommand::MoveWordRightEnd {
            select: extract_value("select", record, span)
                .and_then(|value| value.as_bool())
@ -1130,6 +1106,16 @@ fn edit_from_record(
                .and_then(|value| value.as_bool())
                .unwrap_or(false),
        },
+        "movewordrightstart" => EditCommand::MoveWordRightStart {
+            select: extract_value("select", record, span)
+                .and_then(|value| value.as_bool())
+                .unwrap_or(false),
+        },
+        "movebigwordrightstart" => EditCommand::MoveBigWordRightStart {
+            select: extract_value("select", record, span)
+                .and_then(|value| value.as_bool())
+                .unwrap_or(false),
+        },
        "movetoposition" => {
            let value = extract_value("value", record, span)?;
            let select = extract_value("select", record, span)
@ -1151,13 +1137,6 @@ fn edit_from_record(
            EditCommand::InsertString(value.to_expanded_string("", config))
        }
        "insertnewline" => EditCommand::InsertNewline,
-        "replacechar" => {
-            let value = extract_value("value", record, span)?;
-            let char = extract_char(value)?;
-            EditCommand::ReplaceChar(char)
-        }
-        // `EditCommand::ReplaceChars` - Internal hack not sanely implementable as a
-        // standalone binding
        "backspace" => EditCommand::Backspace,
        "delete" => EditCommand::Delete,
        "cutchar" => EditCommand::CutChar,
@ -1165,7 +1144,6 @@ fn edit_from_record(
        "deleteword" => EditCommand::DeleteWord,
        "clear" => EditCommand::Clear,
        "cleartolineend" => EditCommand::ClearToLineEnd,
-        "complete" => EditCommand::Complete,
        "cutcurrentline" => EditCommand::CutCurrentLine,
        "cutfromstart" => EditCommand::CutFromStart,
        "cutfromlinestart" => EditCommand::CutFromLineStart,
@ -1182,7 +1160,6 @@ fn edit_from_record(
        "uppercaseword" => EditCommand::UppercaseWord,
        "lowercaseword" => EditCommand::LowercaseWord,
        "capitalizechar" => EditCommand::CapitalizeChar,
-        "switchcasechar" => EditCommand::SwitchcaseChar,
        "swapwords" => EditCommand::SwapWords,
        "swapgraphemes" => EditCommand::SwapGraphemes,
        "undo" => EditCommand::Undo,
@ -1239,64 +1216,17 @@ fn edit_from_record(
                .unwrap_or(false);
            EditCommand::MoveLeftBefore { c: char, select }
        }
-        "selectall" => EditCommand::SelectAll,
+        "complete" => EditCommand::Complete,
        "cutselection" => EditCommand::CutSelection,
-        "copyselection" => EditCommand::CopySelection,
-        "paste" => EditCommand::Paste,
-        "copyfromstart" => EditCommand::CopyFromStart,
-        "copyfromlinestart" => EditCommand::CopyFromLineStart,
-        "copytoend" => EditCommand::CopyToEnd,
-        "copytolineend" => EditCommand::CopyToLineEnd,
-        "copycurrentline" => EditCommand::CopyCurrentLine,
-        "copywordleft" => EditCommand::CopyWordLeft,
-        "copybigwordleft" => EditCommand::CopyBigWordLeft,
-        "copywordright" => EditCommand::CopyWordRight,
-        "copybigwordright" => EditCommand::CopyBigWordRight,
-        "copywordrighttonext" => EditCommand::CopyWordRightToNext,
-        "copybigwordrighttonext" => EditCommand::CopyBigWordRightToNext,
-        "copyleft" => EditCommand::CopyLeft,
-        "copyright" => EditCommand::CopyRight,
-        "copyrightuntil" => {
-            let value = extract_value("value", record, span)?;
-            let char = extract_char(value)?;
-            EditCommand::CopyRightUntil(char)
-        }
-        "copyrightbefore" => {
-            let value = extract_value("value", record, span)?;
-            let char = extract_char(value)?;
-            EditCommand::CopyRightBefore(char)
-        }
-        "copyleftuntil" => {
-            let value = extract_value("value", record, span)?;
-            let char = extract_char(value)?;
-            EditCommand::CopyLeftUntil(char)
-        }
-        "copyleftbefore" => {
-            let value = extract_value("value", record, span)?;
-            let char = extract_char(value)?;
-            EditCommand::CopyLeftBefore(char)
-        }
-        "swapcursorandanchor" => EditCommand::SwapCursorAndAnchor,
        #[cfg(feature = "system-clipboard")]
        "cutselectionsystem" => EditCommand::CutSelectionSystem,
+        "copyselection" => EditCommand::CopySelection,
        #[cfg(feature = "system-clipboard")]
        "copyselectionsystem" => EditCommand::CopySelectionSystem,
+        "paste" => EditCommand::Paste,
        #[cfg(feature = "system-clipboard")]
        "pastesystem" => EditCommand::PasteSystem,
-        "cutinside" => {
-            let value = extract_value("left", record, span)?;
-            let left = extract_char(value)?;
-            let value = extract_value("right", record, span)?;
-            let right = extract_char(value)?;
-            EditCommand::CutInside { left, right }
-        }
-        "yankinside" => {
-            let value = extract_value("left", record, span)?;
-            let left = extract_char(value)?;
-            let value = extract_value("right", record, span)?;
-            let right = extract_char(value)?;
-            EditCommand::YankInside { left, right }
-        }
+        "selectall" => EditCommand::SelectAll,
        str => {
            return Err(ShellError::InvalidValue {
                valid: "a reedline EditCommand".into(),
--- a/crates/nu-cli/src/repl.rs
+++ b/crates/nu-cli/src/repl.rs
@ -16,13 +16,11 @@ use crate::{
 use crossterm::cursor::SetCursorStyle;
 use log::{error, trace, warn};
 use miette::{ErrReport, IntoDiagnostic, Result};
-use nu_cmd_base::util::get_editor;
+use nu_cmd_base::{hook::eval_hook, util::get_editor};
 use nu_color_config::StyleComputer;
 #[allow(deprecated)]
-use nu_engine::env_to_strings;
-use nu_engine::exit::cleanup_exit;
+use nu_engine::{convert_env_values, current_dir_str, env_to_strings};
 use nu_parser::{lex, parse, trim_quotes_str};
-use nu_protocol::shell_error::io::IoError;
 use nu_protocol::{
    config::NuCursorShape,
    engine::{EngineState, Stack, StateWorkingSet},
@ -37,7 +35,6 @@ use reedline::{
    CursorConfig, CwdAwareHinter, DefaultCompleter, EditCommand, Emacs, FileBackedHistory,
    HistorySessionId, Reedline, SqliteBackedHistory, Vi,
 };
-use std::sync::atomic::Ordering;
 use std::{
    collections::HashMap,
    env::temp_dir,
@ -64,7 +61,9 @@ pub fn evaluate_repl(
    // from the Arc. This lets us avoid copying stack variables needlessly
    let mut unique_stack = stack.clone();
    let config = engine_state.get_config();
-    let use_color = config.use_ansi_coloring.get(engine_state);
+    let use_color = config.use_ansi_coloring;
+
+    confirm_stdin_is_terminal()?;

    let mut entry_num = 0;

@ -82,6 +81,13 @@ pub fn evaluate_repl(
        stack.clone(),
    );

+    let start_time = std::time::Instant::now();
+    // Translate environment variables from Strings to Values
+    if let Err(e) = convert_env_values(engine_state, &unique_stack) {
+        report_shell_error(engine_state, &e);
+    }
+    perf!("translate env vars", start_time, use_color);
+
    // seed env vars
    unique_stack.add_env_var(
        "CMD_DURATION_MS".into(),
@ -105,8 +111,6 @@ pub fn evaluate_repl(
        engine_state.merge_env(&mut unique_stack)?;
    }

-    confirm_stdin_is_terminal()?;
-
    let hostname = System::host_name();
    if shell_integration_osc2 {
        run_shell_integration_osc2(None, engine_state, &mut unique_stack, use_color);
@ -142,30 +146,15 @@ pub fn evaluate_repl(
    // Regenerate the $nu constant to contain the startup time and any other potential updates
    engine_state.generate_nu_constant();

-    if load_std_lib.is_none() {
-        match engine_state.get_config().show_banner {
-            Value::Bool { val: false, .. } => {}
-            Value::String { ref val, .. } if val == "short" => {
-                eval_source(
-                    engine_state,
-                    &mut unique_stack,
-                    r#"banner --short"#.as_bytes(),
-                    "show short banner",
-                    PipelineData::empty(),
-                    false,
-                );
-            }
-            _ => {
-                eval_source(
-                    engine_state,
-                    &mut unique_stack,
-                    r#"banner"#.as_bytes(),
-                    "show_banner",
-                    PipelineData::empty(),
-                    false,
-                );
-            }
-        }
+    if load_std_lib.is_none() && engine_state.get_config().show_banner {
+        eval_source(
+            engine_state,
+            &mut unique_stack,
+            r#"banner"#.as_bytes(),
+            "show_banner",
+            PipelineData::empty(),
+            false,
+        );
    }

    kitty_protocol_healthcheck(engine_state);
@ -317,6 +306,9 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
    if let Err(err) = engine_state.merge_env(&mut stack) {
        report_shell_error(engine_state, &err);
    }
+    // Check whether $env.NU_DISABLE_IR is set, so that the user can change it in the REPL
+    // Temporary while IR eval is optional
+    stack.use_ir = !stack.has_env_var(engine_state, "NU_DISABLE_IR");
    perf!("merge env", start_time, use_color);

    start_time = std::time::Instant::now();
@ -324,26 +316,20 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
    perf!("reset signals", start_time, use_color);

    start_time = std::time::Instant::now();
-    // Right before we start our prompt and take input from the user, fire the "pre_prompt" hook
-    if let Err(err) = hook::eval_hooks(
-        engine_state,
-        &mut stack,
-        vec![],
-        &engine_state.get_config().hooks.pre_prompt.clone(),
-        "pre_prompt",
-    ) {
-        report_shell_error(engine_state, &err);
+    // Right before we start our prompt and take input from the user,
+    // fire the "pre_prompt" hook
+    if let Some(hook) = engine_state.get_config().hooks.pre_prompt.clone() {
+        if let Err(err) = eval_hook(engine_state, &mut stack, None, vec![], &hook, "pre_prompt") {
+            report_shell_error(engine_state, &err);
+        }
    }
    perf!("pre-prompt hook", start_time, use_color);

    start_time = std::time::Instant::now();
    // Next, check all the environment variables they ask for
    // fire the "env_change" hook
-    if let Err(error) = hook::eval_env_change_hook(
-        &engine_state.get_config().hooks.env_change.clone(),
-        engine_state,
-        &mut stack,
-    ) {
+    let env_change = engine_state.get_config().hooks.env_change.clone();
+    if let Err(error) = hook::eval_env_change_hook(env_change, engine_state, &mut stack) {
        report_shell_error(engine_state, &error)
    }
    perf!("env-change hook", start_time, use_color);
@ -386,7 +372,7 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
        )))
        .with_quick_completions(config.completions.quick)
        .with_partial_completions(config.completions.partial)
-        .with_ansi_colors(config.use_ansi_coloring.get(engine_state))
+        .with_ansi_colors(config.use_ansi_coloring)
        .with_cwd(Some(
            engine_state
                .cwd(None)
@ -406,7 +392,7 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
    let style_computer = StyleComputer::from_config(engine_state, &stack_arc);

    start_time = std::time::Instant::now();
-    line_editor = if config.use_ansi_coloring.get(engine_state) {
+    line_editor = if config.use_ansi_coloring {
        line_editor.with_hinter(Box::new({
            // As of Nov 2022, "hints" color_config closures only get `null` passed in.
            let style = style_computer.compute("hints", &Value::nothing(Span::unknown()));
@ -528,17 +514,18 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {

            // Right before we start running the code the user gave us, fire the `pre_execution`
            // hook
-            {
+            if let Some(hook) = config.hooks.pre_execution.clone() {
                // Set the REPL buffer to the current command for the "pre_execution" hook
                let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
                repl.buffer = repl_cmd_line_text.to_string();
                drop(repl);

-                if let Err(err) = hook::eval_hooks(
+                if let Err(err) = eval_hook(
                    engine_state,
                    &mut stack,
+                    None,
                    vec![],
-                    &engine_state.get_config().hooks.pre_execution.clone(),
+                    &hook,
                    "pre_execution",
                ) {
                    report_shell_error(engine_state, &err);
@ -694,11 +681,7 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
            );

            println!();
-
-            cleanup_exit((), engine_state, 0);
-
-            // if cleanup_exit didn't exit, we should keep running
-            return (true, stack, line_editor);
+            return (false, stack, line_editor);
        }
        Err(err) => {
            let message = err.to_string();
@ -816,10 +799,8 @@ fn parse_operation(
 ) -> Result<ReplOperation, ErrReport> {
    let tokens = lex(s.as_bytes(), 0, &[], &[], false);
    // Check if this is a single call to a directory, if so auto-cd
-    let cwd = engine_state
-        .cwd(Some(stack))
-        .map(|p| p.to_string_lossy().to_string())
-        .unwrap_or_default();
+    #[allow(deprecated)]
+    let cwd = nu_engine::env::current_dir_str(engine_state, stack).unwrap_or_default();
    let mut orig = s.clone();
    if orig.starts_with('`') {
        orig = trim_quotes_str(&orig).to_string()
@ -853,26 +834,21 @@ fn do_auto_cd(
        if !path.exists() {
            report_shell_error(
                engine_state,
-                &ShellError::Io(IoError::new_with_additional_context(
-                    std::io::ErrorKind::NotFound,
+                &ShellError::DirectoryNotFound {
+                    dir: path.to_string_lossy().to_string(),
                    span,
-                    PathBuf::from(&path),
-                    "Cannot change directory",
-                )),
+                },
            );
        }
        path.to_string_lossy().to_string()
    };

-    if let PermissionResult::PermissionDenied = have_permission(path.clone()) {
+    if let PermissionResult::PermissionDenied(reason) = have_permission(path.clone()) {
        report_shell_error(
            engine_state,
-            &ShellError::Io(IoError::new_with_additional_context(
-                std::io::ErrorKind::PermissionDenied,
-                span,
-                PathBuf::from(path),
-                "Cannot change directory",
-            )),
+            &ShellError::IOError {
+                msg: format!("Cannot change directory to {path}: {reason}"),
+            },
        );
        return;
    }
@ -936,9 +912,6 @@ fn do_run_cmd(
    trace!("eval source: {}", s);

    let mut cmds = s.split_whitespace();
-
-    let had_warning_before = engine_state.exit_warning_given.load(Ordering::SeqCst);
-
    if let Some("exit") = cmds.next() {
        let mut working_set = StateWorkingSet::new(engine_state);
        let _ = parse(&mut working_set, None, s.as_bytes(), false);
@ -947,11 +920,13 @@ fn do_run_cmd(
            match cmds.next() {
                Some(s) => {
                    if let Ok(n) = s.parse::<i32>() {
-                        return cleanup_exit(line_editor, engine_state, n);
+                        drop(line_editor);
+                        std::process::exit(n);
                    }
                }
                None => {
-                    return cleanup_exit(line_editor, engine_state, 0);
+                    drop(line_editor);
+                    std::process::exit(0);
                }
            }
        }
@ -970,14 +945,6 @@ fn do_run_cmd(
        false,
    );

-    // if there was a warning before, and we got to this point, it means
-    // the possible call to cleanup_exit did not occur.
-    if had_warning_before && engine_state.is_interactive {
-        engine_state
-            .exit_warning_given
-            .store(false, Ordering::SeqCst);
-    }
-
    line_editor
 }

@ -992,7 +959,8 @@ fn run_shell_integration_osc2(
    stack: &mut Stack,
    use_color: bool,
 ) {
-    if let Ok(path) = engine_state.cwd_as_string(Some(stack)) {
+    #[allow(deprecated)]
+    if let Ok(path) = current_dir_str(engine_state, stack) {
        let start_time = Instant::now();

        // Try to abbreviate string for windows title
@ -1036,7 +1004,8 @@ fn run_shell_integration_osc7(
    stack: &mut Stack,
    use_color: bool,
 ) {
-    if let Ok(path) = engine_state.cwd_as_string(Some(stack)) {
+    #[allow(deprecated)]
+    if let Ok(path) = current_dir_str(engine_state, stack) {
        let start_time = Instant::now();

        // Otherwise, communicate the path as OSC 7 (often used for spawning new tabs in the same dir)
@ -1059,7 +1028,8 @@ fn run_shell_integration_osc7(
 }

 fn run_shell_integration_osc9_9(engine_state: &EngineState, stack: &mut Stack, use_color: bool) {
-    if let Ok(path) = engine_state.cwd_as_string(Some(stack)) {
+    #[allow(deprecated)]
+    if let Ok(path) = current_dir_str(engine_state, stack) {
        let start_time = Instant::now();

        // Otherwise, communicate the path as OSC 9;9 from ConEmu (often used for spawning new tabs in the same dir)
@ -1083,7 +1053,8 @@ fn run_shell_integration_osc633(
    use_color: bool,
    repl_cmd_line_text: String,
 ) {
-    if let Ok(path) = engine_state.cwd_as_string(Some(stack)) {
+    #[allow(deprecated)]
+    if let Ok(path) = current_dir_str(engine_state, stack) {
        // Supported escape sequences of Microsoft's Visual Studio Code (vscode)
        // https://code.visualstudio.com/docs/terminal/shell-integration#_supported-escape-sequences
        if stack
@ -1174,7 +1145,7 @@ fn setup_history(
 /// Setup Reedline keybindingds based on the provided config
 ///
 fn setup_keybindings(engine_state: &EngineState, line_editor: Reedline) -> Reedline {
-    match create_keybindings(engine_state.get_config()) {
+    return match create_keybindings(engine_state.get_config()) {
        Ok(keybindings) => match keybindings {
            KeybindingsMode::Emacs(keybindings) => {
                let edit_mode = Box::new(Emacs::new(keybindings));
@ -1192,7 +1163,7 @@ fn setup_keybindings(engine_state: &EngineState, line_editor: Reedline) -> Reedl
            report_shell_error(engine_state, &e);
            line_editor
        }
-    }
+    };
 }

 ///
@ -1589,13 +1560,6 @@ mod test_auto_cd {
        symlink(&dir, &link).unwrap();
        let input = if cfg!(windows) { r".\link" } else { "./link" };
        check(tempdir, input, link);
-
-        let dir = tempdir.join("foo").join("bar");
-        std::fs::create_dir_all(&dir).unwrap();
-        let link = tempdir.join("link2");
-        symlink(&dir, &link).unwrap();
-        let input = "..";
-        check(link, input, tempdir);
    }

    #[test]
--- a/crates/nu-cli/src/syntax_highlight.rs
+++ b/crates/nu-cli/src/syntax_highlight.rs
@ -144,6 +144,8 @@ impl Highlighter for NuHighlighter {
                }
                FlatShape::Flag => add_colored_token(&shape.1, next_token),
                FlatShape::Pipe => add_colored_token(&shape.1, next_token),
+                FlatShape::And => add_colored_token(&shape.1, next_token),
+                FlatShape::Or => add_colored_token(&shape.1, next_token),
                FlatShape::Redirection => add_colored_token(&shape.1, next_token),
                FlatShape::Custom(..) => add_colored_token(&shape.1, next_token),
                FlatShape::MatchPattern => add_colored_token(&shape.1, next_token),
@ -309,7 +311,6 @@ fn find_matching_block_end_in_expr(
            .unwrap_or(expression.span.start);

        return match &expression.expr {
-            // TODO: Can't these be handled with an `_ => None` branch? Refactor
            Expr::Bool(_) => None,
            Expr::Int(_) => None,
            Expr::Float(_) => None,
@ -336,28 +337,6 @@ fn find_matching_block_end_in_expr(
            Expr::Nothing => None,
            Expr::Garbage => None,

-            Expr::AttributeBlock(ab) => ab
-                .attributes
-                .iter()
-                .find_map(|attr| {
-                    find_matching_block_end_in_expr(
-                        line,
-                        working_set,
-                        &attr.expr,
-                        global_span_offset,
-                        global_cursor_offset,
-                    )
-                })
-                .or_else(|| {
-                    find_matching_block_end_in_expr(
-                        line,
-                        working_set,
-                        &ab.item,
-                        global_span_offset,
-                        global_cursor_offset,
-                    )
-                }),
-
            Expr::Table(table) => {
                if expr_last == global_cursor_offset {
                    // cursor is at table end
--- a/crates/nu-cli/src/util.rs
+++ b/crates/nu-cli/src/util.rs
@ -1,5 +1,3 @@
-#![allow(clippy::byte_char_slices)]
-
 use nu_cmd_base::hook::eval_hook;
 use nu_engine::{eval_block, eval_block_with_early_return};
 use nu_parser::{lex, parse, unescape_unquote_string, Token, TokenContents};
@ -132,7 +130,7 @@ fn gather_env_vars(
                    working_set.error(err);
                }

-                if !working_set.parse_errors.is_empty() {
+                if working_set.parse_errors.first().is_some() {
                    report_capture_error(
                        engine_state,
                        &String::from_utf8_lossy(contents),
@ -176,7 +174,7 @@ fn gather_env_vars(
                    working_set.error(err);
                }

-                if !working_set.parse_errors.is_empty() {
+                if working_set.parse_errors.first().is_some() {
                    report_capture_error(
                        engine_state,
                        &String::from_utf8_lossy(contents),
@ -203,35 +201,6 @@ fn gather_env_vars(
    }
 }

-/// Print a pipeline with formatting applied based on display_output hook.
-///
-/// This function should be preferred when printing values resulting from a completed evaluation.
-/// For values printed as part of a command's execution, such as values printed by the `print` command,
-/// the `PipelineData::print_table` function should be preferred instead as it is not config-dependent.
-///
-/// `no_newline` controls if we need to attach newline character to output.
-pub fn print_pipeline(
-    engine_state: &mut EngineState,
-    stack: &mut Stack,
-    pipeline: PipelineData,
-    no_newline: bool,
-) -> Result<(), ShellError> {
-    if let Some(hook) = engine_state.get_config().hooks.display_output.clone() {
-        let pipeline = eval_hook(
-            engine_state,
-            stack,
-            Some(pipeline),
-            vec![],
-            &hook,
-            "display_output",
-        )?;
-        pipeline.print_raw(engine_state, no_newline, false)
-    } else {
-        // if display_output isn't set, we should still prefer to print with some formatting
-        pipeline.print_table(engine_state, stack, no_newline, false)
-    }
-}
-
 pub fn eval_source(
    engine_state: &mut EngineState,
    stack: &mut Stack,
@ -265,10 +234,7 @@ pub fn eval_source(
    perf!(
        &format!("eval_source {}", &fname),
        start_time,
-        engine_state
-            .get_config()
-            .use_ansi_coloring
-            .get(engine_state)
+        engine_state.get_config().use_ansi_coloring
    );

    exit_code
@ -301,7 +267,7 @@ fn evaluate_source(

        if let Some(err) = working_set.compile_errors.first() {
            report_compile_error(&working_set, err);
-            return Ok(true);
+            // Not a fatal error, for now
        }

        (output, working_set.render())
@ -315,12 +281,36 @@ fn evaluate_source(
        eval_block::<WithoutDebug>(engine_state, stack, &block, input)
    }?;

-    let no_newline = matches!(&pipeline, &PipelineData::ByteStream(..));
-    print_pipeline(engine_state, stack, pipeline, no_newline)?;
+    if let PipelineData::ByteStream(..) = pipeline {
+        // run the display hook on bytestreams too
+        run_display_hook(engine_state, stack, pipeline, false)
+    } else {
+        run_display_hook(engine_state, stack, pipeline, true)
+    }?;

    Ok(false)
 }

+fn run_display_hook(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    pipeline: PipelineData,
+    no_newline: bool,
+) -> Result<(), ShellError> {
+    if let Some(hook) = engine_state.get_config().hooks.display_output.clone() {
+        let pipeline = eval_hook(
+            engine_state,
+            stack,
+            Some(pipeline),
+            vec![],
+            &hook,
+            "display_output",
+        )?;
+        pipeline.print(engine_state, stack, no_newline, false)
+    } else {
+        pipeline.print(engine_state, stack, no_newline, false)
+    }
+}
 #[cfg(test)]
 mod test {
    use super::*;
--- a/crates/nu-cli/tests/completions/mod.rs
+++ b/crates/nu-cli/tests/completions/mod.rs
--- a/crates/nu-cli/tests/completions/support/completions_helpers.rs
+++ b/crates/nu-cli/tests/completions/support/completions_helpers.rs
@ -14,7 +14,7 @@ fn create_default_context() -> EngineState {
    nu_command::add_shell_command_context(nu_cmd_lang::create_default_context())
 }

-/// creates a new engine with the current path into the completions fixtures folder
+// creates a new engine with the current path into the completions fixtures folder
 pub fn new_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
    // Target folder inside assets
    let dir = fs::fixtures().join("completions");
@ -69,26 +69,7 @@ pub fn new_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
    (dir, dir_str, engine_state, stack)
 }

-/// Adds pseudo PATH env for external completion tests
-pub fn new_external_engine() -> EngineState {
-    let mut engine = create_default_context();
-    let dir = fs::fixtures().join("external_completions").join("path");
-    let dir_str = dir.to_string_lossy().to_string();
-    let internal_span = nu_protocol::Span::new(0, dir_str.len());
-    engine.add_env_var(
-        "PATH".to_string(),
-        Value::List {
-            vals: vec![Value::String {
-                val: dir_str,
-                internal_span,
-            }],
-            internal_span,
-        },
-    );
-    engine
-}
-
-/// creates a new engine with the current path into the completions fixtures folder
+// creates a new engine with the current path into the completions fixtures folder
 pub fn new_dotnu_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
    // Target folder inside assets
    let dir = fs::fixtures().join("dotnu_completions");
@ -105,23 +86,6 @@ pub fn new_dotnu_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
    // Add $nu
    engine_state.generate_nu_constant();

-    // const $NU_LIB_DIRS
-    let mut working_set = StateWorkingSet::new(&engine_state);
-    let var_id = working_set.add_variable(
-        b"$NU_LIB_DIRS".into(),
-        Span::unknown(),
-        nu_protocol::Type::List(Box::new(nu_protocol::Type::String)),
-        false,
-    );
-    working_set.set_variable_const_val(
-        var_id,
-        Value::test_list(vec![
-            Value::string(file(dir.join("lib-dir1")), dir_span),
-            Value::string(file(dir.join("lib-dir3")), dir_span),
-        ]),
-    );
-    let _ = engine_state.merge_delta(working_set.render());
-
    // New stack
    let mut stack = Stack::new();

@ -131,12 +95,17 @@ pub fn new_dotnu_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
        "TEST".to_string(),
        Value::string("NUSHELL".to_string(), dir_span),
    );
+
    stack.add_env_var(
-        "NU_LIB_DIRS".into(),
-        Value::test_list(vec![
-            Value::string(file(dir.join("lib-dir2")), dir_span),
-            Value::string(file(dir.join("lib-dir3")), dir_span),
-        ]),
+        "NU_LIB_DIRS".to_string(),
+        Value::List {
+            vals: vec![
+                Value::string(file(dir.join("lib-dir1")), dir_span),
+                Value::string(file(dir.join("lib-dir2")), dir_span),
+                Value::string(file(dir.join("lib-dir3")), dir_span),
+            ],
+            internal_span: dir_span,
+        },
    );

    // Merge environment into the permanent state
@ -216,8 +185,8 @@ pub fn new_partial_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
    (dir, dir_str, engine_state, stack)
 }

-/// match a list of suggestions with the expected values
-pub fn match_suggestions(expected: &Vec<&str>, suggestions: &Vec<Suggestion>) {
+// match a list of suggestions with the expected values
+pub fn match_suggestions(expected: &Vec<String>, suggestions: &Vec<Suggestion>) {
    let expected_len = expected.len();
    let suggestions_len = suggestions.len();
    if expected_len != suggestions_len {
@ -228,34 +197,28 @@ pub fn match_suggestions(expected: &Vec<&str>, suggestions: &Vec<Suggestion>) {
        )
    }

-    let suggestions_str = suggestions
+    let suggestoins_str = suggestions
        .iter()
-        .map(|it| it.value.as_str())
+        .map(|it| it.value.clone())
        .collect::<Vec<_>>();

-    assert_eq!(expected, &suggestions_str);
+    assert_eq!(expected, &suggestoins_str);
 }

-/// match a list of suggestions with the expected values
-pub fn match_suggestions_by_string(expected: &[String], suggestions: &Vec<Suggestion>) {
-    let expected = expected.iter().map(|it| it.as_str()).collect::<Vec<_>>();
-    match_suggestions(&expected, suggestions);
-}
-
-/// append the separator to the converted path
+// append the separator to the converted path
 pub fn folder(path: impl Into<PathBuf>) -> String {
    let mut converted_path = file(path);
    converted_path.push(MAIN_SEPARATOR);
    converted_path
 }

-/// convert a given path to string
+// convert a given path to string
 pub fn file(path: impl Into<PathBuf>) -> String {
    path.into().into_os_string().into_string().unwrap()
 }

-/// merge_input executes the given input into the engine
-/// and merges the state
+// merge_input executes the given input into the engine
+// and merges the state
 pub fn merge_input(
    input: &[u8],
    engine_state: &mut EngineState,
--- a/crates/nu-cli/tests/completions/support/mod.rs
+++ b/crates/nu-cli/tests/completions/support/mod.rs
@ -1,5 +1,3 @@
 pub mod completions_helpers;

-pub use completions_helpers::{
-    file, folder, match_suggestions, match_suggestions_by_string, merge_input, new_engine,
-};
+pub use completions_helpers::{file, folder, match_suggestions, merge_input, new_engine};
--- a/crates/nu-cmd-base/Cargo.toml
+++ b/crates/nu-cmd-base/Cargo.toml
@ -5,7 +5,7 @@ edition = "2021"
 license = "MIT"
 name = "nu-cmd-base"
 repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cmd-base"
-version = "0.104.1"
+version = "0.100.0"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@ -13,10 +13,10 @@ version = "0.104.1"
 workspace = true

 [dependencies]
-nu-engine = { path = "../nu-engine", version = "0.104.1", default-features = false }
-nu-parser = { path = "../nu-parser", version = "0.104.1" }
-nu-path = { path = "../nu-path", version = "0.104.1" }
-nu-protocol = { path = "../nu-protocol", version = "0.104.1", default-features = false }
+nu-engine = { path = "../nu-engine", version = "0.100.0" }
+nu-parser = { path = "../nu-parser", version = "0.100.0" }
+nu-path = { path = "../nu-path", version = "0.100.0" }
+nu-protocol = { path = "../nu-protocol", version = "0.100.0" }

 indexmap = { workspace = true }
 miette = { workspace = true }
--- a/crates/nu-cmd-base/src/hook.rs
+++ b/crates/nu-cmd-base/src/hook.rs
@ -7,55 +7,49 @@ use nu_protocol::{
    engine::{Closure, EngineState, Stack, StateWorkingSet},
    PipelineData, PositionalArg, ShellError, Span, Type, Value, VarId,
 };
-use std::{collections::HashMap, sync::Arc};
+use std::sync::Arc;

 pub fn eval_env_change_hook(
-    env_change_hook: &HashMap<String, Vec<Value>>,
+    env_change_hook: Option<Value>,
    engine_state: &mut EngineState,
    stack: &mut Stack,
 ) -> Result<(), ShellError> {
-    for (env, hooks) in env_change_hook {
-        let before = engine_state.previous_env_vars.get(env);
-        let after = stack.get_env_var(engine_state, env);
-        if before != after {
-            let before = before.cloned().unwrap_or_default();
-            let after = after.cloned().unwrap_or_default();
+    if let Some(hook) = env_change_hook {
+        match hook {
+            Value::Record { val, .. } => {
+                for (env_name, hook_value) in &*val {
+                    let before = engine_state.previous_env_vars.get(env_name);
+                    let after = stack.get_env_var(engine_state, env_name);
+                    if before != after {
+                        let before = before.cloned().unwrap_or_default();
+                        let after = after.cloned().unwrap_or_default();

-            eval_hooks(
-                engine_state,
-                stack,
-                vec![("$before".into(), before), ("$after".into(), after.clone())],
-                hooks,
-                "env_change",
-            )?;
+                        eval_hook(
+                            engine_state,
+                            stack,
+                            None,
+                            vec![("$before".into(), before), ("$after".into(), after.clone())],
+                            hook_value,
+                            "env_change",
+                        )?;

-            Arc::make_mut(&mut engine_state.previous_env_vars).insert(env.clone(), after);
+                        Arc::make_mut(&mut engine_state.previous_env_vars)
+                            .insert(env_name.clone(), after);
+                    }
+                }
+            }
+            x => {
+                return Err(ShellError::TypeMismatch {
+                    err_message: "record for the 'env_change' hook".to_string(),
+                    span: x.span(),
+                });
+            }
        }
    }

    Ok(())
 }

-pub fn eval_hooks(
-    engine_state: &mut EngineState,
-    stack: &mut Stack,
-    arguments: Vec<(String, Value)>,
-    hooks: &[Value],
-    hook_name: &str,
-) -> Result<(), ShellError> {
-    for hook in hooks {
-        eval_hook(
-            engine_state,
-            stack,
-            None,
-            arguments.clone(),
-            hook,
-            &format!("{hook_name} list, recursive"),
-        )?;
-    }
-    Ok(())
-}
-
 pub fn eval_hook(
    engine_state: &mut EngineState,
    stack: &mut Stack,
@ -133,7 +127,16 @@ pub fn eval_hook(
            }
        }
        Value::List { vals, .. } => {
-            eval_hooks(engine_state, stack, arguments, vals, hook_name)?;
+            for val in vals {
+                eval_hook(
+                    engine_state,
+                    stack,
+                    None,
+                    arguments.clone(),
+                    val,
+                    &format!("{hook_name} list, recursive"),
+                )?;
+            }
        }
        Value::Record { val, .. } => {
            // Hooks can optionally be a record in this form:
--- a/crates/nu-cmd-extra/Cargo.toml
+++ b/crates/nu-cmd-extra/Cargo.toml
@ -5,7 +5,7 @@ edition = "2021"
 license = "MIT"
 name = "nu-cmd-extra"
 repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cmd-extra"
-version = "0.104.1"
+version = "0.100.0"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@ -16,13 +16,13 @@ bench = false
 workspace = true

 [dependencies]
-nu-cmd-base = { path = "../nu-cmd-base", version = "0.104.1" }
-nu-engine = { path = "../nu-engine", version = "0.104.1", default-features = false }
-nu-json = { version = "0.104.1", path = "../nu-json" }
-nu-parser = { path = "../nu-parser", version = "0.104.1" }
-nu-pretty-hex = { version = "0.104.1", path = "../nu-pretty-hex" }
-nu-protocol = { path = "../nu-protocol", version = "0.104.1", default-features = false }
-nu-utils = { path = "../nu-utils", version = "0.104.1", default-features = false }
+nu-cmd-base = { path = "../nu-cmd-base", version = "0.100.0" }
+nu-engine = { path = "../nu-engine", version = "0.100.0" }
+nu-json = { version = "0.100.0", path = "../nu-json" }
+nu-parser = { path = "../nu-parser", version = "0.100.0" }
+nu-pretty-hex = { version = "0.100.0", path = "../nu-pretty-hex" }
+nu-protocol = { path = "../nu-protocol", version = "0.100.0" }
+nu-utils = { path = "../nu-utils", version = "0.100.0" }

 # Potential dependencies for extras
 heck = { workspace = true }
@ -34,9 +34,8 @@ serde = { workspace = true }
 serde_urlencoded = { workspace = true }
 v_htmlescape = { workspace = true }
 itertools = { workspace = true }
-mime = { workspace = true }

 [dev-dependencies]
-nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.104.1" }
-nu-command = { path = "../nu-command", version = "0.104.1" }
-nu-test-support = { path = "../nu-test-support", version = "0.104.1" }
+nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.100.0" }
+nu-command = { path = "../nu-command", version = "0.100.0" }
+nu-test-support = { path = "../nu-test-support", version = "0.100.0" }
--- a/crates/nu-cmd-extra/src/example_test.rs
+++ b/crates/nu-cmd-extra/src/example_test.rs
@ -43,12 +43,7 @@ mod test_examples {
                    signature.operates_on_cell_paths(),
                ),
            );
-            check_example_evaluates_to_expected_output(
-                cmd.name(),
-                &example,
-                cwd.as_path(),
-                &mut engine_state,
-            );
+            check_example_evaluates_to_expected_output(&example, cwd.as_path(), &mut engine_state);
        }

        check_all_signature_input_output_types_entries_have_examples(
--- a/crates/nu-cmd-extra/src/extra/bits/and.rs
+++ b/crates/nu-cmd-extra/src/extra/bits/and.rs
@ -26,7 +26,7 @@ impl Command for BitsAnd {
            .required(
                "target",
                SyntaxShape::OneOf(vec![SyntaxShape::Binary, SyntaxShape::Int]),
-                "Right-hand side of the operation.",
+                "right-hand side of the operation",
            )
            .named(
                "endian",
--- a/crates/nu-cmd-extra/src/extra/strings/format/bits.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/format/bits.rs
@ -3,10 +3,10 @@ use std::io::{self, Read, Write};
 use nu_cmd_base::input_handler::{operate, CmdArgument};
 use nu_engine::command_prelude::*;

-use nu_protocol::{shell_error::io::IoError, Signals};
+use nu_protocol::Signals;
 use num_traits::ToPrimitive;

-struct Arguments {
+pub struct Arguments {
    cell_paths: Option<Vec<CellPath>>,
 }

@ -17,15 +17,15 @@ impl CmdArgument for Arguments {
 }

 #[derive(Clone)]
-pub struct FormatBits;
+pub struct BitsInto;

-impl Command for FormatBits {
+impl Command for BitsInto {
    fn name(&self) -> &str {
-        "format bits"
+        "into bits"
    }

    fn signature(&self) -> Signature {
-        Signature::build("format bits")
+        Signature::build("into bits")
            .input_output_types(vec![
                (Type::Binary, Type::String),
                (Type::Int, Type::String),
@ -40,17 +40,17 @@ impl Command for FormatBits {
            .rest(
                "rest",
                SyntaxShape::CellPath,
-                "For a data structure input, convert data at the given cell paths.",
+                "for a data structure input, convert data at the given cell paths",
            )
            .category(Category::Conversions)
    }

    fn description(&self) -> &str {
-        "Convert value to a string of binary data represented by 0 and 1."
+        "Convert value to a binary primitive."
    }

    fn search_terms(&self) -> Vec<&str> {
-        vec!["convert", "cast", "binary"]
+        vec!["convert", "cast"]
    }

    fn run(
@ -60,49 +60,49 @@ impl Command for FormatBits {
        call: &Call,
        input: PipelineData,
    ) -> Result<PipelineData, ShellError> {
-        format_bits(engine_state, stack, call, input)
+        into_bits(engine_state, stack, call, input)
    }

    fn examples(&self) -> Vec<Example> {
        vec![
            Example {
                description: "convert a binary value into a string, padded to 8 places with 0s",
-                example: "0x[1] | format bits",
+                example: "0x[1] | into bits",
                result: Some(Value::string("00000001",
                    Span::test_data(),
                )),
            },
            Example {
                description: "convert an int into a string, padded to 8 places with 0s",
-                example: "1 | format bits",
+                example: "1 | into bits",
                result: Some(Value::string("00000001",
                    Span::test_data(),
                )),
            },
            Example {
                description: "convert a filesize value into a string, padded to 8 places with 0s",
-                example: "1b | format bits",
+                example: "1b | into bits",
                result: Some(Value::string("00000001",
                    Span::test_data(),
                )),
            },
            Example {
                description: "convert a duration value into a string, padded to 8 places with 0s",
-                example: "1ns | format bits",
+                example: "1ns | into bits",
                result: Some(Value::string("00000001",
                    Span::test_data(),
                )),
            },
            Example {
                description: "convert a boolean value into a string, padded to 8 places with 0s",
-                example: "true | format bits",
+                example: "true | into bits",
                result: Some(Value::string("00000001",
                    Span::test_data(),
                )),
            },
            Example {
                description: "convert a string into a raw binary string, padded with 0s to 8 places",
-                example: "'nushell.sh' | format bits",
+                example: "'nushell.sh' | into bits",
                result: Some(Value::string("01101110 01110101 01110011 01101000 01100101 01101100 01101100 00101110 01110011 01101000",
                    Span::test_data(),
                )),
@ -111,7 +111,7 @@ impl Command for FormatBits {
    }
 }

-fn format_bits(
+fn into_bits(
    engine_state: &EngineState,
    stack: &mut Stack,
    call: &Call,
@ -141,11 +141,7 @@ fn byte_stream_to_bits(stream: ByteStream, head: Span) -> ByteStream {
            ByteStreamType::String,
            move |buffer| {
                let mut byte = [0];
-                if reader
-                    .read(&mut byte[..])
-                    .map_err(|err| IoError::new(err.kind(), head, None))?
-                    > 0
-                {
+                if reader.read(&mut byte[..]).err_span(head)? > 0 {
                    // Format the byte as bits
                    if is_first {
                        is_first = false;
@ -197,7 +193,7 @@ fn convert_to_smallest_number_type(num: i64, span: Span) -> Value {
    }
 }

-fn action(input: &Value, _args: &Arguments, span: Span) -> Value {
+pub fn action(input: &Value, _args: &Arguments, span: Span) -> Value {
    match input {
        Value::Binary { val, .. } => {
            let mut raw_string = "".to_string();
@ -207,7 +203,7 @@ fn action(input: &Value, _args: &Arguments, span: Span) -> Value {
            Value::string(raw_string.trim(), span)
        }
        Value::Int { val, .. } => convert_to_smallest_number_type(*val, span),
-        Value::Filesize { val, .. } => convert_to_smallest_number_type(val.get(), span),
+        Value::Filesize { val, .. } => convert_to_smallest_number_type(*val, span),
        Value::Duration { val, .. } => convert_to_smallest_number_type(*val, span),
        Value::String { val, .. } => {
            let raw_bytes = val.as_bytes();
@ -243,6 +239,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(FormatBits {})
+        test_examples(BitsInto {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/bits/mod.rs
+++ b/crates/nu-cmd-extra/src/extra/bits/mod.rs
@ -1,5 +1,6 @@
 mod and;
 mod bits_;
+mod into;
 mod not;
 mod or;
 mod rotate_left;
@ -10,6 +11,7 @@ mod xor;

 pub use and::BitsAnd;
 pub use bits_::Bits;
+pub use into::BitsInto;
 pub use not::BitsNot;
 pub use or::BitsOr;
 pub use rotate_left::BitsRol;
@ -135,7 +137,7 @@ where
                (min, max) => (rhs, lhs, max, min),
            };

-            let pad = iter::repeat_n(0, max_len - min_len);
+            let pad = iter::repeat(0).take(max_len - min_len);

            let mut a;
            let mut b;
@ -159,10 +161,9 @@ where
        }
        (Value::Binary { .. }, Value::Int { .. }) | (Value::Int { .. }, Value::Binary { .. }) => {
            Value::error(
-                ShellError::OnlySupportsThisInputType {
+                ShellError::PipelineMismatch {
                    exp_input_type: "input, and argument, to be both int or both binary"
                        .to_string(),
-                    wrong_type: "int and binary".to_string(),
                    dst_span: rhs.span(),
                    src_span: span,
                },
--- a/crates/nu-cmd-extra/src/extra/bits/or.rs
+++ b/crates/nu-cmd-extra/src/extra/bits/or.rs
@ -27,7 +27,7 @@ impl Command for BitsOr {
            .required(
                "target",
                SyntaxShape::OneOf(vec![SyntaxShape::Binary, SyntaxShape::Int]),
-                "Right-hand side of the operation.",
+                "right-hand side of the operation",
            )
            .named(
                "endian",
--- a/crates/nu-cmd-extra/src/extra/bits/rotate_left.rs
+++ b/crates/nu-cmd-extra/src/extra/bits/rotate_left.rs
@ -37,7 +37,7 @@ impl Command for BitsRol {
                ),
            ])
            .allow_variants_without_examples(true)
-            .required("bits", SyntaxShape::Int, "Number of bits to rotate left.")
+            .required("bits", SyntaxShape::Int, "number of bits to rotate left")
            .switch(
                "signed",
                "always treat input number as a signed number",
--- a/crates/nu-cmd-extra/src/extra/bits/rotate_right.rs
+++ b/crates/nu-cmd-extra/src/extra/bits/rotate_right.rs
@ -37,7 +37,7 @@ impl Command for BitsRor {
                ),
            ])
            .allow_variants_without_examples(true)
-            .required("bits", SyntaxShape::Int, "Number of bits to rotate right.")
+            .required("bits", SyntaxShape::Int, "number of bits to rotate right")
            .switch(
                "signed",
                "always treat input number as a signed number",
--- a/crates/nu-cmd-extra/src/extra/bits/shift_left.rs
+++ b/crates/nu-cmd-extra/src/extra/bits/shift_left.rs
@ -40,7 +40,7 @@ impl Command for BitsShl {
                ),
            ])
            .allow_variants_without_examples(true)
-            .required("bits", SyntaxShape::Int, "Number of bits to shift left.")
+            .required("bits", SyntaxShape::Int, "number of bits to shift left")
            .switch(
                "signed",
                "always treat input number as a signed number",
@ -249,7 +249,7 @@ fn shift_bytes_and_bits_left(data: &[u8], byte_shift: usize, bit_shift: usize) -
            Last | Only => lhs << bit_shift,
            _ => (lhs << bit_shift) | (rhs >> (8 - bit_shift)),
        })
-        .chain(iter::repeat_n(0, byte_shift))
+        .chain(iter::repeat(0).take(byte_shift))
        .collect::<Vec<u8>>()
 }

--- a/crates/nu-cmd-extra/src/extra/bits/shift_right.rs
+++ b/crates/nu-cmd-extra/src/extra/bits/shift_right.rs
@ -37,7 +37,7 @@ impl Command for BitsShr {
                ),
            ])
            .allow_variants_without_examples(true)
-            .required("bits", SyntaxShape::Int, "Number of bits to shift right.")
+            .required("bits", SyntaxShape::Int, "number of bits to shift right")
            .switch(
                "signed",
                "always treat input number as a signed number",
--- a/crates/nu-cmd-extra/src/extra/bits/xor.rs
+++ b/crates/nu-cmd-extra/src/extra/bits/xor.rs
@ -27,7 +27,7 @@ impl Command for BitsXor {
            .required(
                "target",
                SyntaxShape::OneOf(vec![SyntaxShape::Binary, SyntaxShape::Int]),
-                "Right-hand side of the operation.",
+                "right-hand side of the operation",
            )
            .named(
                "endian",
--- a/crates/nu-cmd-extra/src/extra/strings/format/number.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/format/number.rs
@ -2,11 +2,11 @@ use nu_cmd_base::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct FormatNumber;
+pub struct Fmt;

-impl Command for FormatNumber {
+impl Command for Fmt {
    fn name(&self) -> &str {
-        "format number"
+        "fmt"
    }

    fn description(&self) -> &str {
@ -14,19 +14,19 @@ impl Command for FormatNumber {
    }

    fn signature(&self) -> nu_protocol::Signature {
-        Signature::build("format number")
+        Signature::build("fmt")
            .input_output_types(vec![(Type::Number, Type::record())])
            .category(Category::Conversions)
    }

    fn search_terms(&self) -> Vec<&str> {
-        vec!["display", "render", "fmt"]
+        vec!["display", "render", "format"]
    }

    fn examples(&self) -> Vec<Example> {
        vec![Example {
            description: "Get a record containing multiple formats for the number 42",
-            example: "42 | format number",
+            example: "42 | fmt",
            result: Some(Value::test_record(record! {
                    "binary" =>   Value::test_string("0b101010"),
                    "debug" =>    Value::test_string("42"),
@ -47,11 +47,11 @@ impl Command for FormatNumber {
        call: &Call,
        input: PipelineData,
    ) -> Result<PipelineData, ShellError> {
-        format_number(engine_state, stack, call, input)
+        fmt(engine_state, stack, call, input)
    }
 }

-pub(crate) fn format_number(
+fn fmt(
    engine_state: &EngineState,
    stack: &mut Stack,
    call: &Call,
@ -64,9 +64,9 @@ pub(crate) fn format_number(

 fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
    match input {
-        Value::Float { val, .. } => format_f64(*val, span),
-        Value::Int { val, .. } => format_i64(*val, span),
-        Value::Filesize { val, .. } => format_i64(val.get(), span),
+        Value::Float { val, .. } => fmt_it_64(*val, span),
+        Value::Int { val, .. } => fmt_it(*val, span),
+        Value::Filesize { val, .. } => fmt_it(*val, span),
        // Propagate errors by explicitly matching them before the final case.
        Value::Error { .. } => input.clone(),
        other => Value::error(
@ -81,7 +81,7 @@ fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
    }
 }

-fn format_i64(num: i64, span: Span) -> Value {
+fn fmt_it(num: i64, span: Span) -> Value {
    Value::record(
        record! {
            "binary" => Value::string(format!("{num:#b}"), span),
@ -97,7 +97,7 @@ fn format_i64(num: i64, span: Span) -> Value {
    )
 }

-fn format_f64(num: f64, span: Span) -> Value {
+fn fmt_it_64(num: f64, span: Span) -> Value {
    Value::record(
        record! {
            "binary" => Value::string(format!("{:b}", num.to_bits()), span),
@ -121,6 +121,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(FormatNumber {})
+        test_examples(Fmt {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/conversions/mod.rs
+++ b/crates/nu-cmd-extra/src/extra/conversions/mod.rs
@ -0,0 +1,3 @@
+mod fmt;
+
+pub(crate) use fmt::Fmt;
--- a/crates/nu-cmd-extra/src/extra/filters/each_while.rs
+++ b/crates/nu-cmd-extra/src/extra/filters/each_while.rs
@ -25,8 +25,8 @@ impl Command for EachWhile {
            )])
            .required(
                "closure",
-                SyntaxShape::Closure(Some(vec![SyntaxShape::Any])),
-                "The closure to run.",
+                SyntaxShape::Closure(Some(vec![SyntaxShape::Any, SyntaxShape::Int])),
+                "the closure to run",
            )
            .category(Category::Filters)
    }
--- a/crates/nu-cmd-extra/src/extra/filters/rotate.rs
+++ b/crates/nu-cmd-extra/src/extra/filters/rotate.rs
@ -13,17 +13,14 @@ impl Command for Rotate {
            .input_output_types(vec![
                (Type::record(), Type::table()),
                (Type::table(), Type::table()),
-                (Type::list(Type::Any), Type::table()),
-                (Type::String, Type::table()),
            ])
            .switch("ccw", "rotate counter clockwise", None)
            .rest(
                "rest",
                SyntaxShape::String,
-                "The names to give columns once rotated.",
+                "the names to give columns once rotated",
            )
            .category(Category::Filters)
-            .allow_variants_without_examples(true)
    }

    fn description(&self) -> &str {
--- a/crates/nu-cmd-extra/src/extra/filters/update_cells.rs
+++ b/crates/nu-cmd-extra/src/extra/filters/update_cells.rs
@ -16,7 +16,7 @@ impl Command for UpdateCells {
            .required(
                "closure",
                SyntaxShape::Closure(Some(vec![SyntaxShape::Any])),
-                "The closure to run an update for each cell.",
+                "the closure to run an update for each cell",
            )
            .named(
                "columns",
--- a/crates/nu-cmd-extra/src/extra/formats/mod.rs
+++ b/crates/nu-cmd-extra/src/extra/formats/mod.rs
@ -2,4 +2,4 @@ mod from;
 mod to;

 pub(crate) use from::url::FromUrl;
-pub use to::html::ToHtml;
+pub(crate) use to::html::ToHtml;
--- a/crates/nu-cmd-extra/src/extra/formats/to/html.rs
+++ b/crates/nu-cmd-extra/src/extra/formats/to/html.rs
@ -330,12 +330,7 @@ fn to_html(
        output_string = run_regexes(&regex_hm, &output_string);
    }

-    let metadata = PipelineMetadata {
-        data_source: nu_protocol::DataSource::None,
-        content_type: Some(mime::TEXT_HTML_UTF_8.to_string()),
-    };
-
-    Ok(Value::string(output_string, head).into_pipeline_data_with_metadata(metadata))
+    Ok(Value::string(output_string, head).into_pipeline_data())
 }

 fn theme_demo(span: Span) -> PipelineData {
--- a/crates/nu-cmd-extra/src/extra/math/arccos.rs
+++ b/crates/nu-cmd-extra/src/extra/math/arccos.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathArcCos;
+pub struct SubCommand;

-impl Command for MathArcCos {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math arccos"
    }
@ -114,6 +114,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathArcCos {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/arccosh.rs
+++ b/crates/nu-cmd-extra/src/extra/math/arccosh.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathArcCosH;
+pub struct SubCommand;

-impl Command for MathArcCosH {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math arccosh"
    }
@ -100,6 +100,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathArcCosH {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/arcsin.rs
+++ b/crates/nu-cmd-extra/src/extra/math/arcsin.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathArcSin;
+pub struct SubCommand;

-impl Command for MathArcSin {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math arcsin"
    }
@ -115,6 +115,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathArcSin {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/arcsinh.rs
+++ b/crates/nu-cmd-extra/src/extra/math/arcsinh.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathArcSinH;
+pub struct SubCommand;

-impl Command for MathArcSinH {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math arcsinh"
    }
@ -88,6 +88,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathArcSinH {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/arctan.rs
+++ b/crates/nu-cmd-extra/src/extra/math/arctan.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathArcTan;
+pub struct SubCommand;

-impl Command for MathArcTan {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math arctan"
    }
@ -102,6 +102,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathArcTan {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/arctanh.rs
+++ b/crates/nu-cmd-extra/src/extra/math/arctanh.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathArcTanH;
+pub struct SubCommand;

-impl Command for MathArcTanH {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math arctanh"
    }
@ -101,6 +101,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathArcTanH {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/cos.rs
+++ b/crates/nu-cmd-extra/src/extra/math/cos.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathCos;
+pub struct SubCommand;

-impl Command for MathCos {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math cos"
    }
@ -108,6 +108,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathCos {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/cosh.rs
+++ b/crates/nu-cmd-extra/src/extra/math/cosh.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathCosH;
+pub struct SubCommand;

-impl Command for MathCosH {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math cosh"
    }
@ -88,6 +88,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathCosH {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/exp.rs
+++ b/crates/nu-cmd-extra/src/extra/math/exp.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathExp;
+pub struct SubCommand;

-impl Command for MathExp {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math exp"
    }
@ -93,6 +93,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathExp {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/ln.rs
+++ b/crates/nu-cmd-extra/src/extra/math/ln.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathLn;
+pub struct SubCommand;

-impl Command for MathLn {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math ln"
    }
@ -100,6 +100,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathLn {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/mod.rs
+++ b/crates/nu-cmd-extra/src/extra/math/mod.rs
@ -15,19 +15,19 @@ mod arcsinh;
 mod arctan;
 mod arctanh;

-pub use cos::MathCos;
-pub use cosh::MathCosH;
-pub use sin::MathSin;
-pub use sinh::MathSinH;
-pub use tan::MathTan;
-pub use tanh::MathTanH;
+pub use cos::SubCommand as MathCos;
+pub use cosh::SubCommand as MathCosH;
+pub use sin::SubCommand as MathSin;
+pub use sinh::SubCommand as MathSinH;
+pub use tan::SubCommand as MathTan;
+pub use tanh::SubCommand as MathTanH;

-pub use exp::MathExp;
-pub use ln::MathLn;
+pub use exp::SubCommand as MathExp;
+pub use ln::SubCommand as MathLn;

-pub use arccos::MathArcCos;
-pub use arccosh::MathArcCosH;
-pub use arcsin::MathArcSin;
-pub use arcsinh::MathArcSinH;
-pub use arctan::MathArcTan;
-pub use arctanh::MathArcTanH;
+pub use arccos::SubCommand as MathArcCos;
+pub use arccosh::SubCommand as MathArcCosH;
+pub use arcsin::SubCommand as MathArcSin;
+pub use arcsinh::SubCommand as MathArcSinH;
+pub use arctan::SubCommand as MathArcTan;
+pub use arctanh::SubCommand as MathArcTanH;
--- a/crates/nu-cmd-extra/src/extra/math/sin.rs
+++ b/crates/nu-cmd-extra/src/extra/math/sin.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathSin;
+pub struct SubCommand;

-impl Command for MathSin {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math sin"
    }
@ -108,6 +108,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathSin {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/sinh.rs
+++ b/crates/nu-cmd-extra/src/extra/math/sinh.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathSinH;
+pub struct SubCommand;

-impl Command for MathSinH {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math sinh"
    }
@ -87,6 +87,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathSinH {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/tan.rs
+++ b/crates/nu-cmd-extra/src/extra/math/tan.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathTan;
+pub struct SubCommand;

-impl Command for MathTan {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math tan"
    }
@ -106,6 +106,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathTan {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/math/tanh.rs
+++ b/crates/nu-cmd-extra/src/extra/math/tanh.rs
@ -1,9 +1,9 @@
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct MathTanH;
+pub struct SubCommand;

-impl Command for MathTanH {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "math tanh"
    }
@ -86,6 +86,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(MathTanH {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/mod.rs
+++ b/crates/nu-cmd-extra/src/extra/mod.rs
@ -1,12 +1,14 @@
 mod bits;
+mod conversions;
 mod filters;
 mod formats;
 mod math;
 mod platform;
 mod strings;

-pub use bits::{Bits, BitsAnd, BitsNot, BitsOr, BitsRol, BitsRor, BitsShl, BitsShr, BitsXor};
-pub use formats::ToHtml;
+pub use bits::{
+    Bits, BitsAnd, BitsInto, BitsNot, BitsOr, BitsRol, BitsRor, BitsShl, BitsShr, BitsXor,
+};
 pub use math::{MathArcCos, MathArcCosH, MathArcSin, MathArcSinH, MathArcTan, MathArcTanH};
 pub use math::{MathCos, MathCosH, MathSin, MathSinH, MathTan, MathTanH};
 pub use math::{MathExp, MathLn};
@ -26,6 +28,8 @@ pub fn add_extra_command_context(mut engine_state: EngineState) -> EngineState {
            };
        }

+        bind_command!(conversions::Fmt);
+
        bind_command!(
            filters::UpdateCells,
            filters::EachWhile,
@ -41,8 +45,6 @@ pub fn add_extra_command_context(mut engine_state: EngineState) -> EngineState {

        bind_command!(
            strings::format::FormatPattern,
-            strings::format::FormatBits,
-            strings::format::FormatNumber,
            strings::str_::case::Str,
            strings::str_::case::StrCamelCase,
            strings::str_::case::StrKebabCase,
@ -52,12 +54,12 @@ pub fn add_extra_command_context(mut engine_state: EngineState) -> EngineState {
            strings::str_::case::StrTitleCase
        );

-        bind_command!(ToHtml, formats::FromUrl);
-
+        bind_command!(formats::ToHtml, formats::FromUrl);
        // Bits
        bind_command! {
            Bits,
            BitsAnd,
+            BitsInto,
            BitsNot,
            BitsOr,
            BitsRol,
--- a/crates/nu-cmd-extra/src/extra/platform/ansi/gradient.rs
+++ b/crates/nu-cmd-extra/src/extra/platform/ansi/gradient.rs
@ -38,7 +38,7 @@ impl Command for SubCommand {
            .rest(
                "cell path",
                SyntaxShape::CellPath,
-                "For a data structure input, add a gradient to strings at the given cell paths.",
+                "for a data structure input, add a gradient to strings at the given cell paths",
            )
            .input_output_types(vec![
                (Type::String, Type::String),
--- a/crates/nu-cmd-extra/src/extra/strings/format/command.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/format/command.rs
@ -18,7 +18,7 @@ impl Command for FormatPattern {
            .required(
                "pattern",
                SyntaxShape::String,
-                "The pattern to output. e.g.) \"{foo}: {bar}\".",
+                "the pattern to output. e.g.) \"{foo}: {bar}\"",
            )
            .allow_variants_without_examples(true)
            .category(Category::Strings)
@ -253,11 +253,12 @@ fn format_record(
                        optional: false,
                    })
                    .collect();
-
-                let expanded_string = data_as_value
-                    .follow_cell_path(&path_members, false)?
-                    .to_expanded_string(", ", config);
-                output.push_str(expanded_string.as_str())
+                match data_as_value.clone().follow_cell_path(&path_members, false) {
+                    Ok(value_at_column) => {
+                        output.push_str(value_at_column.to_expanded_string(", ", config).as_str())
+                    }
+                    Err(se) => return Err(se),
+                }
            }
        }
    }
--- a/crates/nu-cmd-extra/src/extra/strings/format/mod.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/format/mod.rs
@ -1,7 +1,3 @@
-mod bits;
 mod command;
-mod number;

-pub(crate) use bits::FormatBits;
 pub(crate) use command::FormatPattern;
-pub(crate) use number::FormatNumber;
--- a/crates/nu-cmd-extra/src/extra/strings/str_/case/camel_case.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/str_/case/camel_case.rs
@ -3,9 +3,9 @@ use heck::ToLowerCamelCase;
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct StrCamelCase;
+pub struct SubCommand;

-impl Command for StrCamelCase {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "str camel-case"
    }
@ -25,7 +25,7 @@ impl Command for StrCamelCase {
            .rest(
                "rest",
                SyntaxShape::CellPath,
-                "For a data structure input, convert strings at the given cell paths.",
+                "For a data structure input, convert strings at the given cell paths",
            )
            .category(Category::Strings)
    }
@ -91,6 +91,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(StrCamelCase {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/strings/str_/case/kebab_case.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/str_/case/kebab_case.rs
@ -3,9 +3,9 @@ use heck::ToKebabCase;
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct StrKebabCase;
+pub struct SubCommand;

-impl Command for StrKebabCase {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "str kebab-case"
    }
@ -25,7 +25,7 @@ impl Command for StrKebabCase {
            .rest(
                "rest",
                SyntaxShape::CellPath,
-                "For a data structure input, convert strings at the given cell paths.",
+                "For a data structure input, convert strings at the given cell paths",
            )
            .category(Category::Strings)
    }
@ -90,6 +90,6 @@ mod tests {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(StrKebabCase {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/strings/str_/case/mod.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/str_/case/mod.rs
@ -6,13 +6,13 @@ mod snake_case;
 mod str_;
 mod title_case;

-pub use camel_case::StrCamelCase;
-pub use kebab_case::StrKebabCase;
-pub use pascal_case::StrPascalCase;
-pub use screaming_snake_case::StrScreamingSnakeCase;
-pub use snake_case::StrSnakeCase;
+pub use camel_case::SubCommand as StrCamelCase;
+pub use kebab_case::SubCommand as StrKebabCase;
+pub use pascal_case::SubCommand as StrPascalCase;
+pub use screaming_snake_case::SubCommand as StrScreamingSnakeCase;
+pub use snake_case::SubCommand as StrSnakeCase;
 pub use str_::Str;
-pub use title_case::StrTitleCase;
+pub use title_case::SubCommand as StrTitleCase;

 use nu_cmd_base::input_handler::{operate as general_operate, CmdArgument};
 use nu_engine::command_prelude::*;
--- a/crates/nu-cmd-extra/src/extra/strings/str_/case/pascal_case.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/str_/case/pascal_case.rs
@ -3,9 +3,9 @@ use heck::ToUpperCamelCase;
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct StrPascalCase;
+pub struct SubCommand;

-impl Command for StrPascalCase {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "str pascal-case"
    }
@ -25,7 +25,7 @@ impl Command for StrPascalCase {
            .rest(
                "rest",
                SyntaxShape::CellPath,
-                "For a data structure input, convert strings at the given cell paths.",
+                "For a data structure input, convert strings at the given cell paths",
            )
            .category(Category::Strings)
    }
@ -91,6 +91,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(StrPascalCase {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/strings/str_/case/screaming_snake_case.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/str_/case/screaming_snake_case.rs
@ -3,9 +3,9 @@ use heck::ToShoutySnakeCase;
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct StrScreamingSnakeCase;
+pub struct SubCommand;

-impl Command for StrScreamingSnakeCase {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "str screaming-snake-case"
    }
@ -25,7 +25,7 @@ impl Command for StrScreamingSnakeCase {
            .rest(
                "rest",
                SyntaxShape::CellPath,
-                "For a data structure input, convert strings at the given cell paths.",
+                "For a data structure input, convert strings at the given cell paths",
            )
            .category(Category::Strings)
    }
@ -91,6 +91,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(StrScreamingSnakeCase {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/strings/str_/case/snake_case.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/str_/case/snake_case.rs
@ -3,9 +3,9 @@ use heck::ToSnakeCase;
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct StrSnakeCase;
+pub struct SubCommand;

-impl Command for StrSnakeCase {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "str snake-case"
    }
@ -25,7 +25,7 @@ impl Command for StrSnakeCase {
            .rest(
                "rest",
                SyntaxShape::CellPath,
-                "For a data structure input, convert strings at the given cell paths.",
+                "For a data structure input, convert strings at the given cell paths",
            )
            .category(Category::Strings)
    }
@ -91,6 +91,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(StrSnakeCase {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/src/extra/strings/str_/case/title_case.rs
+++ b/crates/nu-cmd-extra/src/extra/strings/str_/case/title_case.rs
@ -3,9 +3,9 @@ use heck::ToTitleCase;
 use nu_engine::command_prelude::*;

 #[derive(Clone)]
-pub struct StrTitleCase;
+pub struct SubCommand;

-impl Command for StrTitleCase {
+impl Command for SubCommand {
    fn name(&self) -> &str {
        "str title-case"
    }
@ -25,7 +25,7 @@ impl Command for StrTitleCase {
            .rest(
                "rest",
                SyntaxShape::CellPath,
-                "For a data structure input, convert strings at the given cell paths.",
+                "For a data structure input, convert strings at the given cell paths",
            )
            .category(Category::Strings)
    }
@ -86,6 +86,6 @@ mod test {
    fn test_examples() {
        use crate::test_examples;

-        test_examples(StrTitleCase {})
+        test_examples(SubCommand {})
    }
 }
--- a/crates/nu-cmd-extra/tests/commands/bits/format.rs
+++ b/crates/nu-cmd-extra/tests/commands/bits/format.rs
@ -2,12 +2,12 @@ use nu_test_support::nu;

 #[test]
 fn byte_stream_into_bits() {
-    let result = nu!("[0x[01] 0x[02 03]] | bytes collect | format bits");
+    let result = nu!("[0x[01] 0x[02 03]] | bytes collect | into bits");
    assert_eq!("00000001 00000010 00000011", result.out);
 }

 #[test]
 fn byte_stream_into_bits_is_stream() {
-    let result = nu!("[0x[01] 0x[02 03]] | bytes collect | format bits | describe");
+    let result = nu!("[0x[01] 0x[02 03]] | bytes collect | into bits | describe");
    assert_eq!("string (stream)", result.out);
 }
--- a/crates/nu-cmd-extra/tests/commands/bits/mod.rs
+++ b/crates/nu-cmd-extra/tests/commands/bits/mod.rs
@ -1 +1 @@
-mod format;
+mod into;
--- a/crates/nu-cmd-lang/Cargo.toml
+++ b/crates/nu-cmd-lang/Cargo.toml
@ -6,7 +6,7 @@ repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cmd-lang"
 edition = "2021"
 license = "MIT"
 name = "nu-cmd-lang"
-version = "0.104.1"
+version = "0.100.0"

 [lib]
 bench = false
@ -15,34 +15,20 @@ bench = false
 workspace = true

 [dependencies]
-nu-engine = { path = "../nu-engine", version = "0.104.1", default-features = false }
-nu-parser = { path = "../nu-parser", version = "0.104.1" }
-nu-protocol = { path = "../nu-protocol", version = "0.104.1", default-features = false }
-nu-utils = { path = "../nu-utils", version = "0.104.1", default-features = false }
+nu-engine = { path = "../nu-engine", version = "0.100.0" }
+nu-parser = { path = "../nu-parser", version = "0.100.0" }
+nu-protocol = { path = "../nu-protocol", version = "0.100.0" }
+nu-utils = { path = "../nu-utils", version = "0.100.0" }

 itertools = { workspace = true }
-shadow-rs = { version = "1.1", default-features = false }
+shadow-rs = { version = "0.35", default-features = false }

 [build-dependencies]
-shadow-rs = { version = "1.1", default-features = false, features = ["build"] }
-
-[dev-dependencies]
-quickcheck = { workspace = true }
-quickcheck_macros = { workspace = true }
+shadow-rs = { version = "0.35", default-features = false }

 [features]
-default = ["os"]
-os = [
-  "nu-engine/os",
-  "nu-protocol/os",
-  "nu-utils/os",
-]
-plugin = [
-  "nu-protocol/plugin",
-  "os",
-]
-
+mimalloc = []
 trash-support = []
 sqlite = []
 static-link-openssl = []
-system-clipboard = []
+system-clipboard = []
--- a/Show More
+++ b/Show More