Translated using Weblate (French)

Currently translated at 100.0% (428 of 428 strings) Co-authored-by: Hosted Weblate <hosted@weblate.org> Co-authored-by: Med <45147847+kitsumed@users.noreply.github.com> Translate-URL: https://hosted.weblate.org/projects/tagstudio/strings/fr/ Translation: TagStudio/Application Strings
Translated using Weblate (Dutch)
2026-09-03 01:29:15 +02:00 · 2026-08-16 18:08:42 +02:00 · 2026-08-16 18:08:42 +02:00 · 2026-08-16 18:08:42 +02:00 · 2026-08-15 21:46:46 -07:00 · 2026-08-15 21:46:20 -07:00
147 changed files with 5278 additions and 3454 deletions
@@ -13,7 +13,7 @@ on:
      - .github/actions/setup-python/action.yml
      - .github/workflows/build_docs.yml
      - docs/**
-      - mkdocs.yml
+      - properdocs.yml
  workflow_dispatch:

 concurrency:
@@ -50,7 +50,5 @@ jobs:
          path: .cache
          restore-keys: |
            mkdocs-material-
-      - name: Run mkdocs
-        env:
-          DISABLE_MKDOCS_2_WARNING: 'true'
-        run: mkdocs gh-deploy --force
+      - name: Run properdocs
+        run: properdocs gh-deploy --force
@@ -8,26 +8,29 @@ on:
    paths: &on_paths
      - .github/actions/setup-python/action.yml
      - .github/workflows/checks_python.yml
+      - src/**/resources/**
+      - src/**/*.json
+      - src/**/*.qrc
+      - tests/**
      - .editorconfig
      - pyproject.toml
      - uv.lock
-      - '**.py'
-      - '**.pyi'
-      - 'src/tagstudio/resources/**'
+      - '**.pyi?'
  push:
+    branches-ignore:
+      - translations
    paths: *on_paths
  workflow_dispatch:

-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
 defaults:
  run:
    shell: sh

 jobs:
  run-conditions:
+    permissions:
+      pull-requests: read
+
    name: Run Conditions
    runs-on: ubuntu-latest
    outputs:
@@ -36,14 +39,25 @@ jobs:
      ruff: ${{ steps.run-conditions.outputs.ruff }}
    steps:
      - name: Checkout repository
+        if: github.event_name != 'pull_request'
        uses: actions/checkout@v7
        with:
-          fetch-depth: 0
+          # Largest positive number; infinite depth.
+          # Using 0 would grab all branches.
+          # See: https://github.com/actions/checkout/issues/520
+          # See: https://stackoverflow.com/questions/6802145/how-to-convert-a-git-shallow-clone-to-a-full-clone/6802238#6802238
+          # `git fetch --unshallow` as suggested in later answers would be an extra operation.
+          fetch-depth: '2147483647'

      - name: Check changed files
        id: changed-files
        uses: tj-actions/changed-files@v47.0.6
        with:
+          fail_on_initial_diff_error: 'true'
+          fail_on_submodule_diff_error: 'true'
+          skip_initial_fetch: 'true'
+
+          # WARNING: Does not support `?` glob operand!
          files_yaml: |
            generic:
              - .github/workflows/checks_python.yml
@@ -55,20 +69,51 @@ jobs:
              - .github/actions/setup-python/action.yml
            pytest:
              - .github/actions/setup-python/action.yml
-              - 'src/tagstudio/resources/**'
+              - src/**/resources/**
+              - src/**/*.json
+              - src/**/*.qrc
+              - tests/**
            ruff:
              - .editorconfig

      - name: Set run conditions
        id: run-conditions
+        env:
+          CHANGED_GENERIC: ${{ steps.changed-files.outputs.generic_any_changed }}
+          CHANGED_PYRIGHT: ${{ steps.changed-files.outputs.pyright_any_changed }}
+          CHANGED_PYTEST: ${{ steps.changed-files.outputs.pytest_any_changed }}
+          CHANGED_RUFF: ${{ steps.changed-files.outputs.ruff_any_changed }}
        run: |
+          pyright=false
+          pytest=false
+          ruff=false
+          if [ "${CHANGED_GENERIC}" = true ]; then
+              pyright=true
+              pytest=true
+              ruff=true
+          else
+              if [ "${CHANGED_PYRIGHT}" = true ]; then
+                  pyright=true
+              fi
+              if [ "${CHANGED_PYTEST}" = true ]; then
+                  pytest=true
+              fi
+              if [ "${CHANGED_RUFF}" = true ]; then
+                  ruff=true
+              fi
+          fi
+
          cat <<EOF >>"${GITHUB_OUTPUT}"
-          pyright=${{ steps.changed-files.outputs.generic_any_changed || steps.changed-files.outputs.pyright_any_changed }}
-          pytest=${{ steps.changed-files.outputs.generic_any_changed || steps.changed-files.outputs.pytest_any_changed }}
-          ruff=${{ steps.changed-files.outputs.generic_any_changed || steps.changed-files.outputs.ruff_any_changed }}
+          pyright=${pyright}
+          pytest=${pytest}
+          ruff=${ruff}
          EOF

  check-pyright:
+    concurrency:
+      group: pyright-${{ github.workflow }}-${{ github.ref }}
+      cancel-in-progress: true
+
    name: Pyright
    needs: run-conditions
    if: needs.run-conditions.outputs.pyright == 'true'
@@ -89,6 +134,9 @@ jobs:
        run: pyright

  check-pytest:
+    concurrency:
+      group: ${{ matrix.os }}-pytest-${{ github.workflow }}-${{ github.ref }}
+      cancel-in-progress: true
    strategy:
      fail-fast: false
      matrix:
@@ -151,6 +199,10 @@ jobs:
        run: pytest

  check-ruff:
+    concurrency:
+      group: ruff-${{ github.workflow }}-${{ github.ref }}
+      cancel-in-progress: true
+
    name: Ruff
    needs: run-conditions
    if: needs.run-conditions.outputs.ruff == 'true'
@@ -158,11 +210,18 @@ jobs:
    steps:
      - *checkout

+      - name: Setup Ruff
+        uses: astral-sh/ruff-action@v4.0.0
+        with:
+          # No-op operation, since executing Ruff cannot be disabled for the action.
+          # Note that `--version` has different behavior than `version`, as the
+          # latter will fail if passed any extra args, even if that arg is empty.
+          args: --version
+          src: ''
+
      - parallel:
          - name: Run Ruff linter
-            uses: astral-sh/ruff-action@v4.0.0
+            run: ruff check

          - name: Run Ruff formatter
-            uses: astral-sh/ruff-action@v4.0.0
-            with:
-              args: format --check
+            run: ruff format --check
@@ -3,7 +3,12 @@
 ---
 name: REUSE Compliance Check

-on: [pull_request, push]
+on:
+  pull_request:
+  push:
+    branches-ignore:
+      - translations
+  workflow_dispatch:

 concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
@@ -8,7 +8,7 @@ path = [
    "docs/CNAME",
    "docs/assets/**",
    "src/tagstudio/qt/resources.json",
-    "src/tagstudio/resources/icon.*",
+    "src/tagstudio/resources/icon*.*",
    "src/tagstudio/resources/tagstudio.desktop",
    "src/tagstudio/resources/templates/ts_ignore_template.txt",
    "src/tagstudio/resources/templates/ts_ignore_template_blank.txt",
@@ -45,6 +45,13 @@ SPDX-FileCopyrightText = "(c) 2026 Boxicons"
 SPDX-License-Identifier = "MIT"

 [[annotations]]
-path = ["src/tagstudio/resources/qt/images/dupe_file_stat.png"]
+path = [
+    "src/tagstudio/resources/qt/images/dupe_file_stat.png",
+    "src/tagstudio/resources/qt/images/hint_field_add.png",
+    "src/tagstudio/resources/qt/images/hint_field_create.png",
+    "src/tagstudio/resources/qt/images/hint_tag_add.png",
+    "src/tagstudio/resources/qt/images/hint_tag_added.png",
+    "src/tagstudio/resources/qt/images/hint_tag_create.png",
+]
 SPDX-FileCopyrightText = "(c) github:google/material-design-icons Contributors"
 SPDX-License-Identifier = "Apache-2.0"
@@ -9,6 +9,96 @@ toc_depth: 2

 # :material-script-text: Changelog

+### 9.6.3 <small>August 15th, 2026</small>
+
+This update includes some critical library bugfixes along with a handful QoL tweaks and additions to the tag/field search bars. The [documentation](https://docs.tagstud.io/usage/#tagging) on this feature has been updated to include the new improvements.
+
+### Added
+
+- feat(ui): show library format version in "About" window by @CyanVoxel in 102cfdf4a2e12635f4b6e47259aa23ea95787421
+
+#### Tag and Field Bars
+
+- feat(ui): keep tag/field search bars open by default by @CyanVoxel in #1472
+- feat(ui): translate vertical scrolling to horizontal in tag/field search bars by @CyanVoxel in #1473
+- feat(ui): use tab and shift+tab to navigate tag/field search bars by @CyanVoxel in #1474
+- feat(ui): add hint icons to tag/field search bars by @CyanVoxel in #1475
+
+### Changed
+
+#### Internal Changes
+
+- refactor: almost final migrations cleanup by @Computerdores in #1456
+
+#### Translations
+
+- **French** updated by @kitsumed
+- **Hebrew** updated by @Tatrask
+- **Hungarian** updated by @smileyhead
+- **Japanese** updated by @coolzdaddy55-art
+
+### Fixed
+
+- fix: fix being unable to create new colors by @CyanVoxel in dd00f4d4a02fd74b24d40c51b55ae3cc7db09203
+- fix(ui): increase spacing between color palettes by @CyanVoxel in 354c0a0afcdaae2e490dd6c1eca5a556e7724aea
+- fix: fix infinite loading in various refresh operations by @CyanVoxel in 3ce65552f7d459a2edebadb29cf1c17de6a1c742
+- fix(ui): fix update popup showing after closing main window by @CyanVoxel in 30c81257fa3882376111ec03637bd6f517500908
+- fix(ui): fix accent color issues on Windows by @CyanVoxel in #1477
+
+---
+
+## 9.6.2 <small>August 6th, 2026</small>
+
+### Added
+
+- feat(thumbs): render `.ai` (Adobe Illustrator) thumbnails by @purpletennisball in #1453
+
+### Changed
+
+#### Tag & Field Search/Create Bars (by @CyanVoxel in #1451)
+
+The tagging workflow has gotten a major overhaul! Clicking the "Add Tag" button or pressing <kbd>Ctrl</kbd>+<kbd>T</kbd> will now activate an inline tag search bar that you can also use to quickly create and apply new or existing tags! Creating new tags in an empty library is now as simple as clicking the "Add Tag" button, typing in the name of a tag you wish to create, and hitting <kbd>Enter</kbd>! The whole workflow was redone with both casual and power users in mind, and is entirely keyboard friendly. And fields have also gotten the same treatment!
+
+![Empty File Entry](assets/tag_field_bars/add_buttons_normal.png){ width=45% } ![Empty File Entry](assets/tag_field_bars/tag_bar_empty.png){ width=45% }
+![Empty File Entry](assets/tag_field_bars/tag_bar_search_match.png){ width=45% } ![Empty File Entry](assets/tag_field_bars/field_bar_search.png){ width=45% }
+
+You can read the brief feature overview below or read the updated [documentation](https://docs.tagstud.io/usage/#tagging) to see the full changes and features:
+
+- Open tagging bar clicking "Add Tag" or using <kbd>Ctrl</kbd>+<kbd>T</kbd>
+- Open field bar clicking "Add Field" or using <kbd>Ctrl</kbd>+<kbd>L</kbd>
+- When searching, the underlined tag/field template will be added on <kbd>Enter</kbd>
+- With no search results, a new tag or field template will be created on <kbd>Enter</kbd> and added to the selection
+- Holding <kbd>Shift</kbd> while pressing <kbd>Enter</kbd> will force create a new tag/field template, regardless of the search results
+- An option to always open an Edit window for new tags after creation is available by right-clicking the search bar or by going to the Settings (**off** by default)
+- An option to always open an Edit window for field content after applying a template is available by right-clicking the search bar or by going to the Settings (**on** by default)
+    - Field templates are _always_ edited after being created
+- The classic tag search panel can be accessed from **File -> Add Tag to Selected** / <kbd>Shift</kbd>+<kbd>Ctrl</kbd>+<kbd>T</kbd>
+
+#### Internal Changes
+
+- refactor: split out sql migrations from library by @Computerdores in #1432
+- refactor: remove dead folders table by @Computerdores in #1444
+- ci(docs): migrate from mkdocs to properdocs by @CyanVoxel in #1459
+- refactor(ui): refactor PanelModal and PanelWidget into MVC Modal, ModalView, and ModalContent classes by @CyanVoxel in #1454
+- refactor(ui): apply new MVC guidelines to search panels by @CyanVoxel in #1461
+- refactor: split ThumbRenderer class by @CyanVoxel in #1462
+
+#### Translations
+
+- **French** updated by @kitsumed
+- **Hungarian** updated by @smileyhead
+- **Chinese (Simplified Han Script)** updated by ？？？
+- **Spanish** updated by @2004milenadiaz-source, @JulArr22
+
+### Fixed
+
+- fix: thumbnail rendering for older pxd files by @purpletennisball in #1441
+- fix: correctly display duration statistic in preview panel by @ludvig-sandh in #1421
+- fix: fix new aliases not saving on new tags by @CyanVoxel in #1455
+- fix: don't update media playback when adding tags from menu modal by @CyanVoxel in f52e0fa56816ae43c4faf01b61d46ee8f49b206f
+
+---
+
 ## 9.6.1 <small>July 9th, 2026</small>

 ### Added
@@ -117,7 +117,7 @@ Licensing is now accomplished using the [REUSE](https://reuse.software/spec-3.3/
 !!! tip "PR Scope"
    If you're unsure where to stop the scope of your PR, ask yourself: _"If I broke this up, could any parts of it still be used by the project in the meantime?"_

-### Workflow Checks
+### :material-check-circle: Workflow Checks

 When pushing your code, several automated [workflows](https://github.com/TagStudioDev/TagStudio/tree/main/.github/workflows) will check it against predefined tests and style checks. It's _highly recommended_ that you run these checks locally beforehand to avoid having to fight back-and-forth with the workflow checks inside your pull requests. These checks currently include:

@@ -126,7 +126,7 @@ When pushing your code, several automated [workflows](https://github.com/TagStud
 - [Pytest](developing.md#pytest) tests
 - REUSE [license compliance](#licenses)

-### Runtime Requirements
+## :material-timer-play: Runtime Requirements

 Code must function on all of the supported operating systems and versions:

@@ -134,18 +134,8 @@ Code must function on all of the supported operating systems and versions:
 - macOS 14.0+
 - Common Linux distributions and versions

-## :material-file-document: Documentation Guidelines
+Final submitted code must **_NOT:_**

-Documentation contributions include anything inside of the `docs/` folder as well as the `README.md`. Documentation inside the `docs/` folder is built and hosted on our static documentation site, [docs.tagstud.io](https://docs.tagstud.io/).
-
- Use "[dash-case / kebab-case](https://developer.mozilla.org/en-US/docs/Glossary/Kebab_case)" for file and folder names
- Follow the folder structure pattern
- Don't add images or other media with excessively large file sizes
- Provide alt text for embedded media
- Use "[Title Case](https://apastyle.apa.org/style-grammar-guidelines/capitalization/title-case)" for title capitalization
-
-## :material-translate: Translation Guidelines
-
-Translations are performed on the TagStudio [Weblate project](https://hosted.weblate.org/projects/tagstudio/).
-
-_Translation guidelines coming soon._
+- Contain superfluous or unnecessary logging statements
+- Cause unreasonable slowdowns to the program outside of a progress-indicated task
+- Cause undesirable visual glitches or artifacts on screen
@@ -118,7 +118,7 @@ If you choose to manually set up a virtual environment and install dependencies
 !!! Warning "Linux Library Dependencies"
    If developing TagStudio on Linux, certain libraries are required that may not be included with your distribution. A full list of these can be found [here](install.md#linux).

-## Nix(OS)
+## Nix & NixOS

 If using [Nix](https://nixos.org/), there is a development environment already provided in the [flake](https://wiki.nixos.org/wiki/Flakes) that is accessible with the following command:

@@ -214,7 +214,7 @@ From there, Git will automatically run through the hooks during commit actions!

 You can automatically enter this development shell, and keep your user shell, with a tool like [direnv](https://direnv.net/). Some reference `.envrc` files are provided in the repository at [`contrib`](https://github.com/TagStudioDev/TagStudio/tree/main/contrib).

-Two currently available are for [Nix](#nixos) and [uv](#installing-with-uv), to use one:
+Two currently available are for [Nix](#nix-nixos) and [uv](#installing-with-uv), to use one:

 ```sh
 ln -s .envrc-$variant .envrc
@@ -10,6 +10,8 @@ icon: material/text-box

 Fields are extra pieces of information you can add to [file entries](./entries.md), similar to how [tags](tags.md) are added to entries. Fields are useful for storing information that doesn't nessisarily need to be a tag, such as titles, comments, notes, specific dates or times, etc.

+Unlike tags, fields are based on [templates](#templates) that contain pre-filled information such as the field type and title, and that information is _copied_ to fields when adding them to entries. Editing field information on entries **does not** modify the template it was created from.
+
 To add a field to an entry, click the "Add Field" button in the preview panel. From there you can search and/or select a [field template](#field-templates) to choose from, or create a new one from the search bar. Alternatively you can create new field templates from **Edit -> Manage Field Templates**.

 <figure markdown="span">
@@ -27,12 +27,12 @@ hide:

 ![TagStudio screenshot](./assets/tag_bubbles.png)

-**TagStudio** is a photo & file organization application with an underlying tag-based system that focuses on giving freedom and flexibility to the user. No proprietary programs or formats, no sea of sidecar files, and no complete upheaval of your filesystem structure.
+<span style="font-family: Bai Jamjuree, Roboto, sans-serif; font-size: 1.1rem; letter-spacing: -0.05rem;"><span style="font-weight: 900;">Tag</span><span style="font-weight: 500;"><i>Studio</i></span></span> is a photo & file organization application with an underlying tag-based system that focuses on giving freedom and flexibility to the user. No proprietary programs or formats, no sea of sidecar files, and no complete upheaval of your filesystem structure.

 </div>

 <figure markdown="span">
-  [:material-download: Download Latest Release](https://github.com/TagStudioDev/TagStudio/releases){ .md-button .md-button--primary }
+  [:material-github: Download Latest Release](https://github.com/TagStudioDev/TagStudio/releases){ .md-button .md-button--primary }
 </figure>

 ## :material-star: Core Features
@@ -95,9 +95,9 @@ Some external dependencies are required for TagStudio to execute. Below is a tab
    Aborted (core dumped)
    ```

-### :material-nix: Nix(OS)
+### :material-nix: Nix & NixOS

-For [Nix(OS)](https://nixos.org/), the TagStudio repository includes a [flake](https://wiki.nixos.org/wiki/Flakes) that provides some outputs such as a development shell and package.
+For [Nix](https://nixos.org/), the TagStudio repository includes a [flake](https://wiki.nixos.org/wiki/Flakes) that provides some outputs such as a development shell and package.

 Two packages are provided: `tagstudio` and `tagstudio-jxl`. The distinction was made because `tagstudio-jxl` has an extra compilation step for [JPEG-XL](https://jpeg.org/jpegxl) image support. To give either of them a test run, you can execute `nix run github:TagStudioDev/TagStudio#tagstudio`. If you are in a cloned repository and wish to run a package with the context of the repository, you can simply use `nix run` with no arguments.

@@ -256,4 +256,4 @@ To generate thumbnails for RAR-based files (like `.cbr`) you'll need an extracto

 ### ripgrep

-A recommended tool to improve the performance of directory scanning is [`ripgrep`](https://github.com/BurntSushi/ripgrep), a Rust-based directory walker that natively integrates with our [`.ts_ignore`](ignore.md) (`.gitignore`-style) pattern matching system for excluding files and directories. Ripgrep is already pre-installed on some Linux distributions and also available from several package managers.
+A recommended tool to improve the performance of directory scanning is [ripgrep](https://github.com/BurntSushi/ripgrep), a Rust-based directory walker that natively integrates with our [`.ts_ignore`](ignore.md) (`.gitignore`-style) pattern matching system for excluding files and directories. Ripgrep is already pre-installed on some Linux distributions and also available from several package managers.
@@ -98,7 +98,7 @@ A detailed specification written for the TagStudio tag and/or library format. In
 - [x] Translations
 - [ ] Search Bar Rework :material-chevron-triple-up:{ .priority-high title="High Priority" } **[v9.6.x]**
    - [ ] Improved Tag Autocomplete :material-chevron-triple-up:{ .priority-high title="High Priority" }
-    - [ ] Tags appear as widgets in search bar :material-chevron-triple-up:{ .priority-high title="High Priority" }
+    - [ ] Tags appear as widgets in search bar _(similar to new tag search/create bar)_ :material-chevron-triple-up:{ .priority-high title="High Priority" }
 - [x] Unified Media Player
    - [x] Auto-Hiding Player Controls
    - [x] Play/Pause
@@ -116,7 +116,7 @@ A detailed specification written for the TagStudio tag and/or library format. In
    - [x] Basic Support
    - [ ] Full File Preview :material-chevron-triple-up:{ .priority-high title="High Priority" } **[v9.6.x]**
    - [ ] Syntax Highlighting :material-chevron-double-up:{ .priority-med title="Medium Priority" } **[v9.6.x]**
- [ ] Toggleable Persistent Tagging Panel :material-chevron-triple-up:{ .priority-high title="High Priority" } **[v9.8.x]**
+- [ ] Toggleable Persistent Tagging Panel :material-chevron-triple-up:{ .priority-high title="High Priority" } **[v9.7.x]**
    - [ ] Top Tags
    - [ ] Recent Tags
    - [ ] Tag Search
@@ -6,116 +6,207 @@ icon: material/sign-text
 <!-- SPDX-FileCopyrightText: (c) TagStudio Contributors -->
 <!-- SPDX-License-Identifier: GPL-3.0-only -->

+<!-- prettier-ignore -->
+!!! abstract "Prerequisite Reading"
+    This guide assumes you've read the [Developing](developing.md) and [Contributing](contributing.md) pages first.
+
 # :material-sign-text: Style Guide

-## Formatting
+## :material-script-text: General Principles

-Most of the style guidelines can be checked, fixed, and enforced via Ruff. Older code may not be adhering to all of these guidelines, in which case _"do as I say, not as I do"..._
+- Write **clear**, **concise**, and **modular** code.
+- If the purpose of a peice of code is not obvious, a **short comment** should help explain it.
+- Remember to follow the rest of the [contribution guidelines](contributing.md)!

- Do your best to write clear, concise, and modular code.
-    - This should include making methods private by default (e.g. `__method()`)
-    - Methods should only be protected (e.g. `_method()`) or public (e.g. `method()`) when needed and warranted
- Keep a maximum column width of no more than **100** characters.
- Code comments should be used to help describe sections of code that can't speak for themselves.
- Use [Google style](https://google.github.io/styleguide/pyguide.html#s3.8-comments-and-docstrings) docstrings for any classes and functions you add.
-    - If you're modifying an existing function that does _not_ have docstrings, you don't _have_ to add docstrings to it... but it would be pretty cool if you did ;)
- Imports should be ordered alphabetically.
- Lists of values should be ordered using their [natural sort order](https://en.wikipedia.org/wiki/Natural_sort_order).
-    - Some files have their methods ordered alphabetically as well (i.e. [`thumb_renderer`](https://github.com/TagStudioDev/TagStudio/blob/main/src/tagstudio/qt/widgets/thumb_renderer.py)). If you're working in a file and notice this, please try and keep to the pattern.
- When writing text for window titles or form titles, use "[Title Case](https://apastyle.apa.org/style-grammar-guidelines/capitalization/title-case)" capitalization. Your IDE may have a command to format this for you automatically, although some may incorrectly capitalize short prepositions. In a pinch you can use a website such as [capitalizemytitle.com](https://capitalizemytitle.com/) to check.
- If it wasn't mentioned above, then stick to [**PEP-8**](https://peps.python.org/pep-0008/)!
+---

-### Modules & Implementations
+## :material-text-box-check: Formatting

- **Do not** modify legacy library code in the `src/core/library/json/` directory
- Avoid direct calls to `os`
-    - Use `Pathlib` library instead of `os.path`
-    - Use `platform.system()` instead of `os.name` and `sys.platform`
- Don't prepend local imports with `tagstudio`, stick to `src`
- Use the `logger` system instead of `print` statements
- Avoid nested f-strings
- Use HTML-like tags inside Qt widgets over stylesheets where possible
-
-Final submitted code must **_NOT:_**
-
- Contain superfluous or unnecessary logging statements
- Cause unreasonable slowdowns to the program outside of a progress-indicated task
- Cause undesirable visual glitches or artifacts on screen
-
-### Formatter Configs
+Linting in Python files is mostly taken care of by [ruff](developing.md#ruff) and is based on the rules declared in `pyproject.toml` and `.editorconfig`.

 TagStudio provides an [EditorConfig](https://editorconfig.org/#example-file) file ([`.editorconfig`](https://github.com/TagStudioDev/TagStudio/blob/main/.editorconfig)) along with a [Prettier](https://prettier.io/) config file ([`.prettierrc.toml`](https://github.com/TagStudioDev/TagStudio/blob/main/.prettierrc.toml)) for formatting files other than .py files (Markdown, JSON, YAML, HTML, CSS, etc.). If editing these types of files it's recommended that you use a formatter that supports EditorConfig or has its settings matched to the EditorConfig and Prettier configs. Lastly, please pay attention to the `prettier-ignore` flags in present in some files if you are not using Prettier, as formatting these sections will break formatting used elsewhere such as the [MkDocs site](https://docs.tagstud.io/).

-## Qt
+### :material-code-braces-box: Syntax Guidelines

-As of writing this section, the QT part of the code base is quite unstructured and the View and Controller parts are completely intermixed[^1]. This makes maintenance, fixes and general understanding of the code base quite challenging, because the interesting parts you are looking for are entangled in a bunch of repetitive UI setup code. To address this we are aiming to more strictly separate the view and controller aspects of the QT frontend.
+- Python files should always follow the [**PEP 8**](https://peps.python.org/pep-0008/) style guide conventions, unless specifically allowed otherwise.
+    - The most notable exception in our project is the line length limit of **100** characters, which is enforced via ruff.
+    - Internal Qt methods also use `camelCase` instead of `snake_case`, so overrides of those are commonly seen in the codebase.
+- Classes and attributes considered to be "[private](https://docs.python.org/3/tutorial/classes.html#private-variables)" should be prepended with a **single underscore** (e.g. `_internal_method()`).
+    - If _functionally necessary_, an attribute name may be prepended with a double underscore to trigger "[name mangling](https://docs.python.org/3/reference/expressions.html#private-name-mangling)" (e.g. `__mangled_method()`).
+- Classes and methods should contain [Google style](https://google.github.io/styleguide/pyguide.html#s3.8-comments-and-docstrings) docstrings _(this style is enforced via ruff)_.
+- Lists and JSON keys should be ordered by their [natural sort order](https://en.wikipedia.org/wiki/Natural_sort_order) unless otherwise specified or readily indicated.
+- Some files have some or all of their attributes sorted. Please respect any established patterns like these in files you modify.

-The general structure of the QT code base should look like this:
+---

+## :material-filter-cog: Modules & Systems
+
+### :fontawesome-brands-python: Python Modules
+
+- Use `Pathlib` library instead of `os.path`
+- Use `platform.system()` instead of `os.name` or `sys.platform`
+- Avoid nested f-strings
+
+### :material-tag: TagStudio Systems
+
+- Translation keys can be accessed via bracket notation (e.g. `Translations["translation_key"]`) or with the `Translations.format()` method when a value needs to be passed to a placeholder in the translation.
+- Avoid passing around the `QtDriver` class where possible. Instead, pass only the necessary components such as the `Library` and `GlobalSettings` instances.
+- Use HTML-like tags inside strings over explicit stylesheets where possible. The `Style` class provides several handy methods for formatting text with these.
+- Use the `format` method in the stylesheets class to format text headers.
+
+---
+
+## :material-folder-file: Project Layout
+
+### :material-engine: Core <small>Backend</small>
+
+Code that is integral to the core functionality of TagStudio and is UI-independent belongs under the `core/` directory. It's possible that some code that serves the UI can go here, as long as its purpose is to serve _any_ UI and is independent from Qt (e.g. file preview rendering).
+
+```yaml title="Core Backend Directory Example"
+core/
+│
+├── library/ # The TagStudio library system
+│   │
+│   ├── alchemy/ # Current SQLite backend w/ SQLAlchemy ORM
+│   │
+│   ├── json/ # Read-only legacy JSON library system, kept for migrations
+│   │
+│   ├── query_lang/ # The query parser
+│   │
+│   │   # Library files that do not involve the SQLAlchemy ORM
+│   │   # NOTE: Future Non-SQLAlchemy library files will be placed here
+│   ├── refresh.py
+│   └── ...
+│
+└── utils/ # Utility classes and functions for the core
 ```
-qt
-├── controllers
-│   ├── widgets
-│   │   └── preview_panel_controller.py
-│   └── main_window_controller.py
-├── views
-│   ├── widgets
-│   │   └── preview_panel_view.py
-│   └── main_window_view.py
-├── ts_qt.py
-└── mixed.py
-```
-
-In this structure there are the `views` and `controllers` sub-directories. They have the exact same structure and for every `<component>_view.py` there is a `<component>_controller.py` at the same location in the other subdirectory and vice versa.
-
-Typically the classes should look like this:
-
-```py
-# my_cool_widget_view.py
-class MyCoolWidgetView(QWidget):
-    def __init__(self):
-        super().__init__()
-        self.__button = QPushButton()
-        self.__color_dropdown = QComboBox()
-        # ...
-        self.__connect_callbacks()
-
-    def __connect_callbacks(self):
-        self.__button.clicked.connect(self._button_click_callback)
-        self.__color_dropdown.currentIndexChanged.connect(
-            lambda idx: self._color_dropdown_callback(self.__color_dropdown.itemData(idx))
-        )
-
-    def _button_click_callback(self):
-        raise NotImplementedError()
-```
-
-```py
-# my_cool_widget_controller.py
-class MyCoolWidget(MyCoolWidgetView):
-    def __init__(self):
-        super().__init__()
-
-    def _button_click_callback(self):
-        print("Button was clicked!")
-
-    def _color_dropdown_callback(self, color: Color):
-        print(f"The selected color is now: {color}")
-```
-
-Observe the following key aspects of this example:
-
- The Controller is just called `MyCoolWidget` instead of `MyCoolWidgetController` as it will be directly used by other code
- The UI elements are in private variables
-    - This enforces that the controller shouldn't directly access UI elements
-    - Instead the view should provide a protected API (e.g. `_get_color()`) for things like setting/getting the value of a dropdown, etc.
-    - Instead of `_get_color()` there could also be a `_color` method marked with `@property`
- The callback methods are already defined as protected methods with NotImplementedErrors
-    - Defines the interface the callbacks
-    - Enforces that UI events be handled

 <!-- prettier-ignore -->
-!!! tip
-    A good (non-exhaustive) rule of thumb is: If it requires a non-UI import, then it doesn't belong in the `*_view.py` file.
+!!! danger "Read-Only Legacy Code"
+    **Do not modify** legacy library code in the `src/core/library/json/` directory!

-[^1]: For an explanation of the Model-View-Controller (MVC) Model, checkout this article: [MVC Framework Introduction](https://www.geeksforgeeks.org/mvc-framework-introduction/).
+---
+
+### :material-button-cursor: App UI <small>Frontend</small>
+
+The application UI code is stored in the `qt/` directory, and contains all code specific to the Qt frontend. Qt widgets are built using an [MVC](https://www.geeksforgeeks.org/software-engineering/mvc-framework-introduction/) pattern, which is described in-depth below:
+
+#### MVC Pattern
+
+- **Models** are usually just objects from the [library](#core-backend).
+    - The **controller** interacts with these, the _view_ does **not**.
+- **Views** are Qt layout classes that **_only_** contain the **layout** and **styling** for one or more widgets.
+    - Class names are appended with `View`, and filenames appended with `_view`.
+    - Not to be used standalone, but as the layouts for one or more controllers.
+    - Some logic is acceptable in these classes if it serves to modularize the layout and allows controllers to influence how the layout is initialized.
+    - **Reusable Layouts**
+        - If a layout class is **_not meant_** to act as a view but instead be a generic layout, it belongs in the `views/layouts/` directory and the file should be appended with `_layout`.
+    - **Styling Classes**
+        - If a class is purely a source of reusable styling, it belongs in the `views/styles/` directory.
+
+- **Controllers** are complete widgets or base classes for complete widgets.
+    - Controller files simply take on the name of the final widget they create.
+        - This also creates naming parity with other widgets that simply extend existing Qt widgets with additional logic.
+
+```yaml title="Qt Frontend Directory Example"
+qt/
+│
+├── controllers/ # Widgets implementing views or extending other widgets
+│   ├── tag_suggest_box.py # Extends from `suggest_box.py`
+│   ├── suggest_box.py # Implements `suggest_box_view.py`
+│   ├── main_window.py
+│   └── ...
+│
+├── mixed/ # Files yet to be refactored into controllers and views
+│
+├── views/ # Everything related to widget layouts and appearances
+│   │
+│   ├── layouts/ # Layouts meant to be reused on their own inside other layouts
+│   │   ├── flow_layout.py
+│   │   └── ...
+│   │
+│   ├── styles/ # Classes specific for styling
+│   │   ├── palette.py
+│   │   ├── stylesheets.py
+│   │   └── ...
+│   │
+│   │   # Views (layouts) that get implemented by controllers (widgets)
+│   ├── main_window_view.py
+│   ├── suggest_box_view.py
+│   └── ...
+│
+│   # Frontend classes that aren't related to widgets, like managers
+├── resource_manager.py
+├── cache_manager.py
+├── ts_qt.py # Qt Driver
+└── ...
+```
+
+<!-- prettier-ignore -->
+!!! warning "Pre-MVC UI Code"
+    **Do not add** new files to the `qt/mixed/` directory! These files have yet to to be refactored per the current MVC style guidelines and the directory will be **removed** once those migrations have concluded.
+
+Observe the following key aspects of the example below:
+
+- The **view** extends from a Qt layout class, and the **controller** simply extends from QWidget.
+- The **controller** is just called `MyCoolWidget` instead of `MyCoolWidgetController` as it will be directly used by other code.
+- The **view's** widgets that are intended to be controlled by the controller are **public**, while the **controller's** methods are largely **private**.
+
+<!-- prettier-ignore -->
+!!! example "MVC-Separated Widget Example"
+
+    ```py title="views/my_cool_widget_view.py"
+    class MyCoolWidgetView(QVBoxLayout):
+        def __init__(self):
+            super().__init__()
+            self.button = QPushButton()
+            self.color_dropdown = QComboBox()
+
+            self.addWidget(self.button)
+            self.addWidget(self.color_dropdown)
+    ```
+
+    ```py title="controllers/my_cool_widget.py"
+    class MyCoolWidget(QWidget):
+        def __init__(self):
+            super().__init__()
+            self.setLayout(MyCoolWidgetView())
+            self._connect_callbacks()
+
+        def _connect_callbacks(self):
+            self.layout().button.clicked.connect(self._button_click_callback)
+            self.layout().color_dropdown.currentIndexChanged.connect(
+            lambda idx: self._color_dropdown_callback(self.color_dropdown.itemData(idx)))
+
+        def _button_click_callback(self):
+            print("Button was clicked!")
+
+        def _color_dropdown_callback(self, color: Color):
+            print(f"The selected color is now: {color}")
+    ```
+
+<!-- prettier-ignore -->
+!!! tip "Tip for Logic Placement"
+    A good rule of thumb is: If there's **conditional logic** after a widget has been created, it should probably go in a **controller**.
+
+---
+
+## :material-file-document: Documentation
+
+Documentation contributions include anything inside the `docs/` folder as well as the `README.md`. Documentation inside the `docs/` folder is built and hosted on our static documentation site, [docs.tagstud.io](https://docs.tagstud.io/). Some files such as the `CHANGELOG.md`, `CONTRIBUTING.md`, and `STYLE.md` are symlinked in the repo root from the `docs/` folder.
+
+- Use "[dash-case / kebab-case](https://developer.mozilla.org/en-US/docs/Glossary/Kebab_case)" for file and folder names
+- Follow the folder structure pattern
+- Don't add images or other media with excessively large file sizes
+- Provide alt text for embedded media
+- Use "[Title Case](https://apastyle.apa.org/style-grammar-guidelines/capitalization/title-case)" for title capitalization
+
+---
+
+## :material-translate: Translations
+
+Translations are performed on the TagStudio [Weblate project](https://hosted.weblate.org/projects/tagstudio/).
+
+- Do not change text inside placeholders
+- Do not change the style tags inside translations
+- Use the glossary for term definitions
@@ -3,11 +3,14 @@
 * SPDX-License-Identifier: GPL-3.0-only
 */
 /* Dark Theme */
+
 [data-md-color-scheme="slate"] {
+    --md-primary-fg-color: rgb(197, 110, 255);
+    --md-accent-fg-color: rgb(92, 222, 255);
    --md-default-bg-color: #060617;
    --md-default-fg-color: #eae1ff;
-    --md-default-fg-color--light: #b898ff;
-    --md-code-fg-color: #eae1ffcc;
+    --md-default-fg-color--light: #c2a5ff;
+    --md-code-fg-color: #d8c7ffcc;
    --md-code-hl-string-color: rgb(92, 255, 228);
    --md-code-hl-keyword-color: rgb(61, 155, 255);
    --md-code-hl-constant-color: rgb(205, 78, 255);
@@ -17,6 +20,8 @@

 /* Light Theme */
 [data-md-color-scheme="default"] {
+    --md-primary-fg-color: #7758ff;
+    --md-accent-fg-color: rgb(22, 166, 255);
    --md-default-fg-color--light: #090a26;
 }

@@ -68,11 +73,20 @@
    border-color: #ffffff33;
 }

+img {
+    border-radius: 6px;
+}
+
 th,
 td {
    padding: 0.5em 1em 0.5em 1em !important;
 }

+hr {
+    border-bottom-width: 2px !important;
+    border-color: #9988ff50 !important;
+}
+
 .md-typeset ul li ul {
    margin-top: 0;
    margin-bottom: 0.1rem;
@@ -119,6 +133,18 @@ h2,
    margin-right: -0.8rem;
 }

+.md-code__nav,
+.md-content__button,
+.headerlink {
+    border-radius: 0.2rem;
+    background: none;
+    color: #9988ff50 !important;
+}
+
+.md-code__nav:hover {
+    background-color: #9988ff50;
+}
+
 figcaption {
    margin-top: 0 !important;
 }
@@ -149,6 +175,51 @@ td code {
    padding: 0 !important;
 }

+.admonition {
+    border-radius: 0.4rem !important;
+    border-width: 2px !important;
+}
+
+.highlight > .filename {
+    border-width: 2px !important;
+    border: solid;
+    border-color: #9988ff10 !important;
+    border-radius: 0.4rem 0.4rem 0 0 !important;
+}
+
+code {
+    border-radius: 0.4rem !important;
+    border-width: 2px !important;
+    border: solid;
+    border-color: #9988ff10;
+}
+
+:is(span, ul, li, td, p, a) > code {
+    border-width: 1px !important;
+    border-radius: 0.1rem !important;
+}
+
+.filename + pre > code {
+    border-top-width: 0 !important;
+    border-radius: 0 0 0.4rem 0.4rem !important;
+}
+
+.tabbed-labels.tabbed-labels--linked {
+    padding-left: 0.4rem;
+    padding-right: 0.4rem;
+    box-shadow: none !important;
+}
+
+.admonition-title {
+    font-size: 0.7rem;
+    font-family: "Bai Jamjuree", Roboto, sans-serif;
+    font-weight: 600 !important;
+}
+
+.admonition-title span {
+    margin-top: 0.05rem !important;
+}
+
 /* Matches the palette used by mkdocs-material */
 .priority-high {
    color: #f1185a;
@@ -29,3 +29,30 @@ h2 {
        margin-right: 0;
    }
 }
+
+.grid.cards > ul > li {
+    border-radius: 0.4rem !important;
+    border-width: 2px !important;
+    border-color: #9988ff20 !important;
+}
+
+.md-button--primary {
+    margin: 1rem;
+    padding: 0.3rem 1.2rem !important;
+    border-radius: 0.4rem !important;
+    font-size: 1rem;
+    font-family: "Bai Jamjuree", Roboto, sans-serif;
+    background: linear-gradient(60deg, rgb(205, 78, 255) 0%, rgb(116, 123, 255) 100%);
+    border-style: solid;
+    border-width: 0 0 2px 0 !important;
+    border-color: #ffffff33 !important;
+}
+
+.md-button--primary:hover {
+    background: linear-gradient(60deg, rgb(205, 78, 255) 30%, rgb(116, 123, 255) 100%);
+    border-color: #ffffff55 !important;
+}
+
+.md-button--primary span {
+    margin-top: 0.1rem !important;
+}
@@ -116,12 +116,10 @@ Due to the nature of how tags and Tag Felids operated prior to v9.5, the organiz

 #### Is Hidden

-<!-- prettier-ignore -->
-!!! warning ""
-    **_Coming in version 9.6.x_**
-
 When the "Is Hidden" property is checked, any file entries tagged with this tag will not show up in searches by default. This property comes by default with the built-in "Archived" tag.

+---
+
 ## Tag Search Examples

 The following are examples of how a set of given tags will respond to various search queries.
@@ -17,47 +17,103 @@ To create or open a [library](libraries.md), go to **File -> Open/Create Library
 TagStudio automatically scans for new or updated files when opening a library by default. Manually refresh by going to **File -> Refresh Directories** in the menu or by using <kbd>Ctrl</kbd>+<kbd>R</kbd> (<kbd>⌘ Command </kbd>+<kbd>R</kbd> on macOS).

 <!-- prettier-ignore -->
-!!! tip "TagStudio Libraries"
+!!! abstract "TagStudio Libraries"
    To learn more about how TagStudio libraries work and how to use them, visit the **[Libraries](libraries.md)** page.

-## Adding Tags to File Entries
+---

-Access the "Add Tag" search box by either clicking on the "Add Tag" button at the bottom of the right sidebar, accessing the "Add Tags to Selected" option from the File menu, or by pressing <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>T</kbd>.
+## :material-tag-text: Tagging

-From here you can search for existing tags or create a new one if the one you're looking for doesn't exist. Click the "+" button next to any tags you want to the currently selected file entries. To quickly add the top result, press the <kbd>Enter</kbd>/<kbd>Return</kbd> key to add the topmost tag and reset the tag search. Press <kbd>Enter</kbd>/<kbd>Return</kbd> once more to close the dialog box. By using this method, you can quickly add various tags in quick succession just by using the keyboard!
+With one or more file entries selected, you can **search for** or **create a new tag** by clicking the "Add Tag" button at the bottom of the preview panel or by pressing <kbd>Ctrl</kbd>+<kbd>T</kbd>.

-To remove a tag from a file entry, hover over the tag in the preview panel and click on the "-" icon that appears.
+This will open the the **"Tag Bar"**, a combination search/creation bar that is designed to allow you to quickly create and apply tags that don't exist yet, find and apply existing tags from your library, and verify if certain tags already exist and/or are applied to your selection.

-## Adding Metadata to File Entries
+Every step is keyboard-friendly, allowing for an efficient tagging "flow state" when it comes to creating and applying tags.

-To add a metadata field to a file entry, start by clicking the "Add Field" button at the bottom of the preview panel. From the dropdown menu, select the type of metadata field you’d like to add to the entry
+<figure markdown="span">
+  ![Empty File Entry](assets/tag_field_bars/add_buttons_normal.png){ width=80% }
+  <br>
+  ![Empty File Entry](assets/tag_field_bars/tag_bar_empty.png){ width=80% }
+  <figcaption>
+  Clicking "Add Tag" or pressing <kbd>Ctrl</kbd>+<kbd>T</kbd> replaces the "Add" buttons with a tag search bar.
+  <br>
+  You can close the search by pressing <kbd>Enter</kbd> or clicking away (with a blank search), or at any time by pressing <kbd>Esc</kbd>.
+  </figcaption>
+</figure>

-## Editing Metadata Fields
+<!-- prettier-ignore -->
+!!! note "Classic Tag Search Panel"
+    You can access the classic tag search panel by going to **File -> Add Tag to Selected** in the menu bar, or by pressing <kbd>Shift</kbd>+<kbd>Ctrl</kbd>+<kbd>T</kbd>. Note that this panel will change and move in the future, becoming part of a set of dockable side-panels for tagging that can stay open between making selections. See the [roadmap](./roadmap.md#uiux) for more info.

-### Text Line / Text Box
+### :material-tag-plus: Tag Bar: Creating Tags

-Hover over the field and click the pencil icon. From there, add or edit text in the dialog box popup.
+Type to search for an existing tag, or use that search term to quickly create and apply a new tag to your selection. Pressing <kbd>Enter</kbd> with **no results** will **create** :material-tag-plus-outline: a tag from your search query and apply it to the selected entries.

-## Creating Tags
+After applying a tag, the "Add Tag" button is now focused, allowing you to press <kbd>Enter</kbd> or <kbd>Space</kbd> to quickly reactivate the bar. Alternatively, you may edit your new tag by right-clicking the tag and selecting **"Edit"**.

-Create a new tag by accessing the "New Tag" option from the Edit menu or by pressing <kbd>Ctrl</kbd>+<kbd>T</kbd>. In the tag creation panel, enter a tag name, optional shorthand name, optional tag aliases, optional parent tags, and an optional color.
+Tags can be also viewed, created, edited, or deleted from the **Edit -> Manage Tags** window.

- The tag **name** is the base name of the tag. **_This does NOT have to be unique!_**
- The tag **shorthand** is a special type of alias that displays in situations where screen space is more valuable, notably with name disambiguation.
- **Aliases** are alternate names for a tag. These let you search for terms other than the exact tag name in order to find the tag again.
- **Parent Tags** are tags in which this tag can substitute for in searches. In other words, tags under this section are parents of this tag.
-    - Parent tags with the disambiguation check next to them will be used to help disambiguate tag names that may not be unique.
-    - For example: If you had a tag for "Freddy Fazbear", you might add "Five Nights at Freddy's" as one of the parent tags. If the disambiguation box is checked next to "Five Nights at Freddy's" parent tag, then the tag "Freddy Fazbear" will display as "Freddy Fazbear (Five Nights at Freddy's)". Furthermore, if the "Five Nights at Freddy's" tag has a shorthand like "FNAF", then the "Freddy Fazbear" tag will display as "Freddy Fazbear (FNAF)".
- The **color** option lets you select an optional color palette to use for your tag.
- The **"Is Category"** property lets you treat this tag as a category under which itself and any child tags inheriting from it will be sorted by inside the preview panel.
+<figure markdown="span">
+  ![Empty File Entry](assets/tag_field_bars/tag_bar_new.png){ width=80% }
+  <figcaption>A tag named "Cube" does not exist yet, and will be created and applied to the selection when <kbd>Enter</kbd> is pressed.</figcaption>
+  ![Empty File Entry](assets/tag_field_bars/tag_button_highlighted.png){ width=80% }
+  <figcaption>The new tag "Cube" has been created and applied to our selection.</figcaption>
+</figure>

-### Tag Manager
+<!-- prettier-ignore -->
+!!! tip "Optionally Always Edit New Tags"
+    If you prefer opening an "Edit" window for tags after creating them and before they get applied to your selection, you can toggle this option on by right-clicking the search bar and clicking **"Edit After Creating a New Tag"**, or by visiting the same setting in the **Settings** window. By default, this option is **off.**

-You can manage your library of tags by opening the "Tag Manager" panel from Edit -> "Manage Tags". From here you can create, search for, edit, and permanently delete any tags you've created in your library.
+### :material-tag-search: Tag Bar: Searching for Tags

-## Editing Tags
+Pressing <kbd>Enter</kbd> with **one or more results** will **apply** :material-tag: the underlined tag to your selection (assuming it's not already on your selection).

-To edit a tag, click on it inside the preview panel or right-click the tag and select "Edit Tag" from the context menu.
+Matching tags that are **already applied** :material-tag-check: to your entries will be greyed out placed at the end of the autofill results. This lets you visually confirm that a tag already exists and has been applied to the selection. Applying them again with <kbd>Enter</kbd> has no effect other than closing the search.
+
+You can navigate the list of autofill suggestions using the scroll wheel, and change the selected tag by pressing <kbd>Tab</kbd> or <kbd>Shift</kbd>+<kbd>Tab</kbd> to navigate right and left, respectively.
+
+<figure markdown="span">
+  ![Empty File Entry](assets/tag_field_bars/tag_bar_search_match.png){ width=80% }
+  <figcaption>On a new selected entry, typing "Cube" will find our existing tag.</figcaption>
+  ![Empty File Entry](assets/tag_field_bars/tag_bar_search_match_greyed.png){ width=80% }
+  <figcaption>If the matched tag is already applied to the selected entries, it will be greyed out and ignored when pressing <kbd>Enter</kbd>.</figcaption>
+</figure>
+
+#### :material-tag-arrow-up: Force Create Tag
+
+Holding <kbd>Shift</kbd> while pressing <kbd>Enter</kbd> will **force create** :material-tag-plus-outline: a tag from the search bar text, regardless of the search results. This is especially useful when you need to create a new tag with a name that partially overlaps with an existing tag's name.
+
+<figure markdown="span">
+  ![Empty File Entry](assets/tag_field_bars/tag_bar_shift_off.png){ width=80% }
+  <figcaption markdown="span">Pressing <kbd>Enter</kbd> will **apply** :material-tag: the underlined tag, "Cube".</figcaption>
+  ![Empty File Entry](assets/tag_field_bars/tag_bar_shift_on.png){ width=80% }
+  <figcaption markdown="span">
+  <kbd>Shift</kbd>+<kbd>Enter</kbd> will **create** :material-tag-plus-outline: a new tag called "Cub".
+  <br>
+  Note the the greyed-out tag, showing it will not be applied.
+  </figcaption>
+</figure>
+
+---
+
+## :material-text-box: Creating and Adding Fields
+
+[Fields](./fields.md) are extra pieces of information you can add to file entries, such as titles, comments, notes, specific dates or times. Unlike tags, fields are based on [templates](./fields.md#field-templates) that contain pre-filled information such as the field type and title, and that information is _copied_ to fields when adding them to entries. Editing field information on entries **does not** modify the template it was created from.
+
+Creating and adding fields to entries is extremely similar to how [tagging](#tagging) works, with a few notable differences:
+
+- Click "Add Field" or press <kbd>Ctrl</kbd>+<kbd>L</kbd> to open the field bar.
+- The same template can by applied to an entry any number of times.
+- New field templates are automatically edited after being created, since they have a type that must be chosen before they can be used.
+    - This is separate from the option to automatically edit a field's _contents_ once a field has been added to an entry
+- Editing a field's contents immediately after it's added to an entry is **enabled** by default, and can be toggled by right-clicking the search bar and clicking **"Edit After Adding a Field"**, or by visiting the same setting in the **Settings** window.
+
+<figure markdown="span">
+  ![Empty File Entry](assets/tag_field_bars/field_bar_search.png){ width=80% }
+  <figcaption>Searching for field templates inside the field bar.</figcaption>
+</figure>
+
+---

 ## Relinking Moved Files

@@ -71,9 +127,7 @@ Inevitably some of the files inside your library will be renamed, moved, or dele
 !!! warning
    If multiple matches for a moved file are found (matches are currently defined as files with a matching filename as the original), TagStudio will currently ignore the match groups. Adding a GUI for manual selection, as well as smarter automated relinking, are high priorities for future versions.

-### Saving the Library
-
-As of version 9.5, libraries are saved automatically as you go. To save a backup of your library, select File -> Save Library Backup from the menu bar.
+---

 ## Launch Arguments

@@ -7,11 +7,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1778716662,
-        "narHash": "sha256-m1Yf0wZ8j1OHjTc2UwHwyQRSnNeSgLJOd7q5Y45hzi4=",
+        "lastModified": 1782949081,
+        "narHash": "sha256-vp6Y/Grm98ESt6ceOkWiHWyZRDV3J1RID4w+6NWK9yA=",
        "owner": "hercules-ci",
        "repo": "flake-parts",
-        "rev": "f7c1a2d347e4c52d5fb8d10cb4d94b5884e546fb",
+        "rev": "17c9d6cdfc60c64f4ee8d306f9bc0b4ccb51481e",
        "type": "github"
      },
      "original": {
@@ -22,11 +22,11 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1782723713,
-        "narHash": "sha256-oPXCU/SSUokcGaJREHibG1CBX3+s/W7orDWQOZDsEeQ=",
+        "lastModified": 1785571196,
+        "narHash": "sha256-KoTsyMQqnXQZq8deCEnu4QkyldkwH/bpMMhUcfMdGIw=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "b5aa0fbd538984f6e3d201be0005b4463d8b09f8",
+        "rev": "148bab9c1c3c53136ecb44a6ea356a0ed5b39b06",
        "type": "github"
      },
      "original": {
@@ -97,7 +97,7 @@ python3Packages.buildPythonApplication {
    with python3Packages;
    [
      audioop-lts
-      chardet
+      chardet_5
      ffmpeg-python
      humanfriendly
      mutagen
@@ -27,11 +27,11 @@ let
        libdrm
        libpulseaudio
        libva
+        libx11
        libxkbcommon
+        libxrandr
        pipewire
        qt6.qtwayland
-        xorg.libX11
-        xorg.libXrandr
      ]
    );

@@ -73,19 +73,17 @@ let
  };
 in
 pkgs.mkShellNoCC {
-  nativeBuildInputs = with pkgs; [
+  packages = [
+    python3Wrapped
+  ]
+  ++ (with pkgs; [
    coreutils
+    ffmpeg-headless
+    ripgrep
    uv

    pyright
    ruff
-  ];
-  buildInputs = [
-    python3Wrapped
-  ]
-  ++ (with pkgs; [
-    ffmpeg-headless
-    ripgrep
  ]);

  env = {
@@ -70,16 +70,16 @@ theme:
    # Palette toggle for light mode
    - media: "(prefers-color-scheme: light)"
      scheme: default
-      primary: purple
-      accent: purple
+      primary: custom
+      accent: custom
      toggle:
        icon: material/lightbulb
        name: Switch to Dark Mode
    # Palette toggle for dark mode
    - media: "(prefers-color-scheme: dark)"
      scheme: slate
-      primary: purple
-      accent: purple
+      primary: custom
+      accent: custom
      toggle:
        icon: material/lightbulb-night-outline
        name: Switch to System Preference
@@ -9,7 +9,7 @@ build-backend = "hatchling.build"
 [project]
 name = "TagStudio"
 description = "A User-Focused Photo & File Management System."
-version = "9.6.1"
+version = "9.6.4"
 license = "GPL-3.0-only"
 readme = "README.md"
 requires-python = ">=3.12,<3.14"
@@ -60,7 +60,11 @@ extra = [{ include-group = "pre-commit" }]
 lint = [{ include-group = "pyright" }, { include-group = "ruff" }]
 test = [{ include-group = "pytest" }]

-mkdocs = ["mkdocs-material[imaging]>=9.7", "mkdocs-redirects~=1.2"]
+mkdocs = [
+    "mkdocs-material[imaging]>=9.7",
+    "mkdocs-redirects~=1.2",
+    "properdocs",
+]
 pre-commit = ["pre-commit~=4.2"]
 pyinstaller = ["Pyinstaller~=6.21"]
 pyright = ["pyright~=1.1.409"]
@@ -88,7 +92,7 @@ filterwarnings = [
 ignore = [
    ".venv/**",
    "src/tagstudio/core/library/json/",
-    "src/tagstudio/qt/previews/vendored/pydub/",
+    "src/tagstudio/renderers/vendored/pydub/",
 ]
 include = ["src/tagstudio", "tests"]
 # Reference for the settings here: https://github.com/microsoft/pyright/blob/main/docs/configuration.md
@@ -117,7 +121,7 @@ ignore = ["D100", "D101", "D102", "D103", "D104", "D105", "D106", "D107"]

 [tool.ruff.lint.per-file-ignores]
 "tests/**" = ["D", "E402"]
-"src/tagstudio/qt/previews/vendored/**" = ["B", "E", "N", "UP", "SIM115"]
+"src/tagstudio/renderers/vendored/**" = ["B", "E", "N", "UP", "SIM115"]

 [tool.ruff.lint.pydocstyle]
 convention = "google"
@@ -3,8 +3,8 @@

 from importlib.metadata import version

-VERSION: str = version("tagstudio")  # Major.Minor.Patch
-VERSION_BRANCH: str = ""  # Usually "" or "Pre-Release"
+VERSION: str = version("tagstudio")
+BUILD_TYPE: str = ""  # Usually "", "app.nightly", or "app.pre_release"
 COPYRIGHT_YEARS: str = "2021-2026"
 COPYRIGHT: str = f"© {COPYRIGHT_YEARS} Travis Abendshien & TagStudio Contributors"
 COPYRIGHT_COMPACT: str = f"© {COPYRIGHT_YEARS} Travis Abendshien\n& TagStudio Contributors"
@@ -4,12 +4,17 @@

 from sqlalchemy import text

+from tagstudio.core.library.alchemy.fields import (
+    DatetimeFieldTemplate,
+    TextFieldTemplate,
+)
+
 SQL_FILENAME: str = "ts_library.sqlite"
 JSON_FILENAME: str = "ts_library.json"

 DB_VERSION_CURRENT_KEY: str = "CURRENT"
 DB_VERSION_INITIAL_KEY: str = "INITIAL"
-DB_VERSION: int = 202
+DB_VERSION: int = 300

 TAG_CHILDREN_QUERY = text("""
 WITH RECURSIVE ChildTags AS (
@@ -32,3 +37,15 @@ WITH RECURSIVE ChildTags AS (
 )
 SELECT tag_id FROM ChildTags;
 """)
+
+
+DEFAULT_FIELD_TEMPLATES = (
+    TextFieldTemplate(name="Title"),
+    TextFieldTemplate(name="Author"),
+    TextFieldTemplate(name="Artist"),
+    TextFieldTemplate(name="URL"),
+    TextFieldTemplate(name="Description", is_multiline=True),
+    TextFieldTemplate(name="Notes", is_multiline=True),
+    TextFieldTemplate(name="Comments", is_multiline=True),
+    DatetimeFieldTemplate(name="Date"),
+)
@@ -6,12 +6,9 @@ from pathlib import Path
 from typing import override

 import structlog
-from sqlalchemy import Dialect, Engine, String, TypeDecorator, create_engine, text
-from sqlalchemy.exc import OperationalError
+from sqlalchemy import Dialect, String, TypeDecorator
 from sqlalchemy.orm import DeclarativeBase

-from tagstudio.core.constants import RESERVED_TAG_END
-
 logger = structlog.getLogger(__name__)


@@ -34,34 +31,3 @@ class PathType(TypeDecorator):

 class Base(DeclarativeBase):
    type_annotation_map = {Path: PathType}
-
-
-def make_engine(connection_string: str) -> Engine:
-    return create_engine(connection_string)
-
-
-def make_tables(engine: Engine) -> None:
-    logger.info("[Library] Creating DB tables...")
-    Base.metadata.create_all(engine)
-
-    # tag IDs < 1000 are reserved
-    # create tag and delete it to bump the autoincrement sequence
-    # TODO - find a better way
-    # is this the better way?
-    with engine.connect() as conn:
-        result = conn.execute(text("SELECT SEQ FROM sqlite_sequence WHERE name='tags'"))
-        autoincrement_val = result.scalar()
-        if not autoincrement_val or autoincrement_val <= RESERVED_TAG_END:
-            try:
-                conn.execute(
-                    text(
-                        "INSERT INTO tags "
-                        "(id, name, color_namespace, color_slug, is_category, is_hidden) VALUES "
-                        f"({RESERVED_TAG_END}, 'temp', NULL, NULL, false, false)"
-                    )
-                )
-                conn.execute(text(f"DELETE FROM tags WHERE id = {RESERVED_TAG_END}"))
-                conn.commit()
-            except OperationalError as e:
-                logger.error("Could not initialize built-in tags", error=e)
-                conn.rollback()
@@ -2,11 +2,6 @@
 # SPDX-License-Identifier: GPL-3.0-only


-# NOTE: This file contains necessary use of deprecated first-party code until that
-# code is removed in a future version (prefs).
-# pyright: reportDeprecated=false
-
-
 import re
 import shutil
 import sys
@@ -18,8 +13,6 @@ from datetime import UTC, datetime
 from os import makedirs
 from pathlib import Path
 from typing import TYPE_CHECKING
-from uuid import uuid4
-from warnings import catch_warnings

 import sqlalchemy
 import structlog
@@ -45,7 +38,7 @@ from sqlalchemy import (
    update,
 )
 from sqlalchemy.dialects import sqlite
-from sqlalchemy.exc import IntegrityError
+from sqlalchemy.exc import IntegrityError, OperationalError
 from sqlalchemy.orm import (
    InstanceState,
    Session,
@@ -73,16 +66,13 @@ from tagstudio.core.library.alchemy.constants import (
    DB_VERSION,
    DB_VERSION_CURRENT_KEY,
    DB_VERSION_INITIAL_KEY,
+    DEFAULT_FIELD_TEMPLATES,
    JSON_FILENAME,
    SQL_FILENAME,
    TAG_CHILDREN_QUERY,
 )
-from tagstudio.core.library.alchemy.db import make_tables
-from tagstudio.core.library.alchemy.enums import (
-    MAX_SQL_VARIABLES,
-    BrowsingState,
-    SortingModeEnum,
-)
+from tagstudio.core.library.alchemy.db import Base as ModelBase
+from tagstudio.core.library.alchemy.enums import MAX_SQL_VARIABLES, BrowsingState, SortingModeEnum
 from tagstudio.core.library.alchemy.fields import (
    LEGACY_FIELD_MAP,
    BaseField,
@@ -93,9 +83,9 @@ from tagstudio.core.library.alchemy.fields import (
    TextFieldTemplate,
 )
 from tagstudio.core.library.alchemy.joins import TagEntry, TagParent
+from tagstudio.core.library.alchemy.migrations import DBMigrations, MigrationError
 from tagstudio.core.library.alchemy.models import (
    Entry,
-    Folder,
    Namespace,
    Tag,
    TagAlias,
@@ -106,7 +96,6 @@ from tagstudio.core.library.alchemy.visitors import SQLBoolExpressionBuilder
 from tagstudio.core.library.ignore import migrate_ext_list
 from tagstudio.core.library.json.library import Library as JsonLibrary
 from tagstudio.core.utils.types import unwrap
-from tagstudio.qt.translations import Translations

 if TYPE_CHECKING:
    from sqlalchemy import Select
@@ -172,20 +161,6 @@ def get_default_tags() -> tuple[Tag, ...]:
    return archive_tag, favorite_tag, meta_tag


-def get_default_field_templates() -> tuple[BaseFieldTemplate, ...]:
-    """Return the default field templates for a new TagStudio library."""
-    title = TextFieldTemplate(name="Title")
-    author = TextFieldTemplate(name="Author")
-    artist = TextFieldTemplate(name="Artist")
-    url = TextFieldTemplate(name="URL")
-    description = TextFieldTemplate(name="Description", is_multiline=True)
-    notes = TextFieldTemplate(name="Notes", is_multiline=True)
-    comments = TextFieldTemplate(name="Comments", is_multiline=True)
-    date = DatetimeFieldTemplate(name="Date")
-
-    return title, author, artist, url, description, notes, comments, date
-
-
 # The difference in the number of default JSON tags vs default tags in the current version.
 DEFAULT_TAG_DIFF: int = len(get_default_tags()) - len([TAG_ARCHIVED, TAG_FAVORITE])

@@ -234,7 +209,6 @@ class Library:

    library_dir: Path | None = None
    engine: Engine | None = None
-    folder: Folder | None = None
    included_files: set[Path] = set()

    def __init__(self) -> None:
@@ -259,7 +233,6 @@ class Library:
        """Migrate JSON library data to the SQLite database."""
        logger.info("Starting Library Conversion...")
        start_time = time.time()
-        folder: Folder = Folder(path=self.library_dir, uuid=str(uuid4()))

        # Tags
        for tag in json_lib.tags:
@@ -312,7 +285,6 @@ class Library:
            [
                Entry(
                    path=entry.path / entry.filename,
-                    folder=folder,
                    fields=[],
                    id=entry.id + 1,  # NOTE: JSON IDs start at 0 instead of 1
                    date_added=datetime.now(),
@@ -381,20 +353,19 @@ class Library:
            return tag.name

    def open_library(self, library_dir: Path, in_memory: bool = False) -> LibraryStatus:
-        """Wrapper for open_sqlite_library.
+        """Wrapper for open_sqlite_library and create_sqlite_library.

        Handles in-memory storage and checks whether a JSON-migration is necessary.
        """
        assert isinstance(library_dir, Path)

-        if in_memory:
-            return self.open_sqlite_library(library_dir, is_new=True, storage_path=":memory:")
-
-        is_new = True
        sql_path = library_dir / TS_FOLDER_NAME / SQL_FILENAME
-        if self.verify_ts_folder(library_dir) and (is_new := not sql_path.exists()):
-            json_path = library_dir / TS_FOLDER_NAME / JSON_FILENAME
-            if json_path.exists():
+        json_path = library_dir / TS_FOLDER_NAME / JSON_FILENAME
+
+        is_new = not sql_path.exists()
+        if not in_memory:
+            self.verify_ts_folder(library_dir)  # ensure .TagStudio directory exists
+            if is_new and json_path.exists():
                return LibraryStatus(
                    success=False,
                    library_path=library_dir,
@@ -402,14 +373,18 @@ class Library:
                    json_migration_req=True,
                )

-        return self.open_sqlite_library(library_dir, is_new, str(sql_path))
+        if is_new:
+            return self.create_sqlite_library(library_dir, in_memory)

-    def open_sqlite_library(
-        self, library_dir: Path, is_new: bool, storage_path: str
-    ) -> LibraryStatus:
+        return self.open_sqlite_library(library_dir, in_memory)
+
+    @staticmethod
+    def __get_engine(library_dir: Path, in_memory: bool, sql_filename: str):
        connection_string = URL.create(
            drivername="sqlite",
-            database=storage_path,
+            database=(
+                ":memory:" if in_memory else str(library_dir / TS_FOLDER_NAME / sql_filename)
+            ),
        )
        # NOTE: File-based databases should use NullPool to create new DB connection in order to
        # keep connections on separate threads, which prevents the DB files from being locked
@@ -418,169 +393,92 @@ class Library:
        # More info can be found on the SQLAlchemy docs:
        # https://docs.sqlalchemy.org/en/20/changelog/migration_07.html
        # Under -> sqlite-the-sqlite-dialect-now-uses-nullpool-for-file-based-databases
-        poolclass = None if storage_path == ":memory:" else NullPool
-        loaded_db_version: int = 0
-        initial_db_version: int = DB_VERSION
+        poolclass = None if in_memory else NullPool
+
+        logger.info(
+            "[Library] Creating SQLAlchemy Engine",
+            connection_string=connection_string,
+            poolclass=poolclass,
+        )
+        return create_engine(
+            connection_string, poolclass=poolclass, connect_args={"autocommit": False}
+        )
+
+    def create_sqlite_library(
+        self, library_dir: Path, in_memory: bool, sql_filename: str = SQL_FILENAME
+    ) -> LibraryStatus:
+        self.engine = self.__get_engine(library_dir, in_memory, sql_filename)

        logger.info(
            "[Library] Opening SQLite Library",
            library_dir=library_dir,
-            connection_string=connection_string,
        )
-        self.engine = create_engine(connection_string, poolclass=poolclass)
-        with Session(self.engine) as session:
-            # Don't check DB version when creating new library
-            if not is_new:
-                loaded_db_version = self.get_version(DB_VERSION_CURRENT_KEY)
-                initial_db_version = self.get_version(DB_VERSION_INITIAL_KEY)

-                # ======================== Library Database Version Checking =======================
-                # DB_VERSION 6 is the first supported SQLite DB version.
-                # If the DB_VERSION is >= 100, that means it's a compound major + minor version.
-                #   - Dividing by 100 and flooring gives the major (breaking changes) version.
-                #   - If a DB has major version higher than the current program, don't load it.
-                #   - If only the minor version is higher, it's still allowed to load.
-                if loaded_db_version < 6 or (
-                    loaded_db_version >= 100 and loaded_db_version // 100 > DB_VERSION // 100
-                ):
-                    mismatch_text = Translations["status.library_version_mismatch"]
-                    found_text = Translations["status.library_version_found"]
-                    expected_text = Translations["status.library_version_expected"]
-                    return LibraryStatus(
-                        success=False,
-                        message=(
-                            f"{mismatch_text}\n"
-                            f"{found_text} v{loaded_db_version}, "
-                            f"{expected_text} v{DB_VERSION}"
-                        ),
+        logger.info("[Library] Creating DB tables...")
+        with self.engine.connect() as conn:
+            ModelBase.metadata.create_all(conn)
+            conn.commit()
+
+            # TODO - find a better way
+            # is this the better way?
+            # Could we perhaps update the row we are reading from here?
+            result = conn.execute(text("SELECT SEQ FROM sqlite_sequence WHERE name='tags'"))
+            autoincrement_val = result.scalar()
+            if not autoincrement_val or autoincrement_val <= RESERVED_TAG_END:
+                try:
+                    conn.execute(
+                        text(
+                            "INSERT INTO tags "
+                            "(id, name, color_namespace, color_slug, is_category, is_hidden) "
+                            f"VALUES ({RESERVED_TAG_END}, 'temp', NULL, NULL, false, false)"
+                        )
                    )
+                    conn.execute(text(f"DELETE FROM tags WHERE id = {RESERVED_TAG_END}"))
+                    conn.commit()
+                except OperationalError as e:
+                    logger.error("Could not initialize built-in tags", error=e)
+                    conn.rollback()

-            logger.info(f"[Library] Library DB version: {loaded_db_version}")
-            make_tables(self.engine)
+        with Session(self.engine) as session:
+            # Add default tag color namespaces.
+            namespaces = default_color_groups.namespaces()

-            if is_new:
-                # Add default tag color namespaces.
-                namespaces = default_color_groups.namespaces()
-                try:
-                    session.add_all(namespaces)
-                    session.commit()
-                except IntegrityError as e:
-                    logger.error("[Library] Couldn't add default tag color namespaces", error=e)
-                    session.rollback()
+            session.add_all(namespaces)
+            session.flush()

-                # Add default tag colors.
-                tag_colors: list[TagColorGroup] = default_color_groups.standard()
-                tag_colors += default_color_groups.pastels()
-                tag_colors += default_color_groups.shades()
-                tag_colors += default_color_groups.grayscale()
-                tag_colors += default_color_groups.earth_tones()
-                tag_colors += default_color_groups.neon()
-                if is_new:
-                    try:
-                        session.add_all(tag_colors)
-                        session.commit()
-                    except IntegrityError as e:
-                        logger.error("[Library] Couldn't add default tag colors", error=e)
-                        session.rollback()
+            # Add default tag colors.
+            tag_colors: list[TagColorGroup] = default_color_groups.standard()
+            tag_colors += default_color_groups.pastels()
+            tag_colors += default_color_groups.shades()
+            tag_colors += default_color_groups.grayscale()
+            tag_colors += default_color_groups.earth_tones()
+            tag_colors += default_color_groups.neon()

-                # Add default tags.
-                tags = get_default_tags()
-                try:
-                    session.add_all(tags)
-                    session.commit()
-                except IntegrityError:
-                    session.rollback()
+            session.add_all(tag_colors)
+            session.flush()
+
+            # Add default tags.
+            session.add_all(get_default_tags())
+            session.flush()

            # Add default field templates
-            if is_new:
-                for template in get_default_field_templates():
-                    try:
-                        session.add(template)
-                        session.commit()
-                    except IntegrityError:
-                        logger.info(
-                            "[Library] FieldTemplate already exists", field_template=template
-                        )
-                        session.rollback()
+            for template in DEFAULT_FIELD_TEMPLATES:
+                session.add(template)
+            session.flush()

            # Ensure version rows are present
-            with catch_warnings(record=True):
-                try:
-                    initial = DB_VERSION if is_new else 100
-                    session.add(Version(key=DB_VERSION_INITIAL_KEY, value=initial))
-                    session.commit()
-                except IntegrityError:
-                    session.rollback()
-
-                try:
-                    session.add(Version(key=DB_VERSION_CURRENT_KEY, value=DB_VERSION))
-                    session.commit()
-                except IntegrityError:
-                    session.rollback()
-
-            # check if folder matching current path exists already
-            self.folder = session.scalar(select(Folder).where(Folder.path == library_dir))
-            if not self.folder:
-                folder = Folder(
-                    path=library_dir,
-                    uuid=str(uuid4()),
-                )
-                session.add(folder)
-                session.expunge(folder)
-                session.commit()
-                self.folder = folder
+            session.add(Version(key=DB_VERSION_INITIAL_KEY, value=DB_VERSION))
+            session.add(Version(key=DB_VERSION_CURRENT_KEY, value=DB_VERSION))
+            session.flush()

            # Generate default .ts_ignore file
-            if is_new:
-                try:
-                    ts_ignore_template = (
-                        Path(__file__).parents[3] / "resources/templates/ts_ignore_template.txt"
-                    )
-                    shutil.copy2(ts_ignore_template, library_dir / TS_FOLDER_NAME / IGNORE_NAME)
-                except Exception as e:
-                    logger.error("[ERROR][Library] Could not generate '.ts_ignore' file!", error=e)
-
-            # Apply any post-SQL migration patches.
-            if not is_new:
-                assert loaded_db_version >= 6
-
-                # save backup if patches will be applied
-                if loaded_db_version < DB_VERSION:
-                    self.library_dir = library_dir
-                    self.save_library_backup_to_disk()
-                    self.library_dir = None
-
-                # migrate DB step by step from one version to the next
-                if loaded_db_version < 7:
-                    # changes: value_type, tags
-                    self.__apply_db7_migration(session)
-                if loaded_db_version < 8:
-                    # changes: tag_colors
-                    self.__apply_db8_migration(session)
-                if loaded_db_version < 9:
-                    # changes: entries
-                    self.__apply_db9_migration(session)
-                if loaded_db_version < 100:
-                    # changes: tag_parents
-                    self.__apply_db100_migration(session)
-                if loaded_db_version < 102:
-                    # changes: tag_parents
-                    self.__apply_db102_migration(session)
-                if loaded_db_version < 103:
-                    # changes: tags
-                    self.__apply_db103_migration(session)
-                if loaded_db_version < 104:
-                    # changes: deletes preferences
-                    self.__apply_db104_migration(session, library_dir)
-                if loaded_db_version < 200:
-                    # changes: field tables
-                    self.__apply_db200_migration(session)
-                if initial_db_version < 200 and loaded_db_version < 201:
-                    # changes: field tables
-                    self.__apply_db201_migration(session)
-                if loaded_db_version < 202:
-                    # changes: tag_parents
-                    self.__apply_db202_migration(session)
+            try:
+                ts_ignore_template = (
+                    Path(__file__).parents[3] / "resources/templates/ts_ignore_template.txt"
+                )
+                shutil.copy2(ts_ignore_template, library_dir / TS_FOLDER_NAME / IGNORE_NAME)
+            except Exception as e:
+                logger.error("[ERROR][Library] Could not generate '.ts_ignore' file!", error=e)

            session.execute(
                text("CREATE INDEX IF NOT EXISTS idx_tags_name_shorthand ON tags (name, shorthand)")
@@ -596,337 +494,33 @@ class Library:
                )
            )

-            # Update DB_VERSION
-            if loaded_db_version < DB_VERSION:
-                logger.info(f"[Library] Library migrated to DB version {DB_VERSION}")
-                self.set_version(DB_VERSION_CURRENT_KEY, DB_VERSION)
+            session.commit()

        # everything is fine, set the library path
        self.library_dir = library_dir
        return LibraryStatus(success=True, library_path=library_dir)

-    def __apply_db7_migration(self, session: Session):
-        """Migrate DB from DB_VERSION 6 to 7."""
-        logger.info("[Library][Migration] Applying patches to DB_VERSION: 6 library...")
-        with session:
-            # Repair tags that may have a disambiguation_id pointing towards a deleted tag.
-            all_tag_ids = session.scalars(text("SELECT DISTINCT id FROM tags")).all()
-            disam_stmt = (
-                update(Tag)
-                .where(Tag.disambiguation_id.not_in(all_tag_ids))
-                .values(disambiguation_id=None)
-            )
-            session.execute(disam_stmt)
-            session.commit()
+    def open_sqlite_library(
+        self, library_dir: Path, in_memory: bool, sql_filename: str = SQL_FILENAME
+    ) -> LibraryStatus:
+        logger.info("[Library] Opening SQLite Library", library_dir=library_dir)
+
+        self.engine = self.__get_engine(library_dir, in_memory, sql_filename)

-    def __apply_db8_migration(self, session: Session):
-        """Migrate DB from DB_VERSION 7 to 8."""
-        # Add the missing color_border column to the TagColorGroups table.
-        color_border_stmt = text(
-            "ALTER TABLE tag_colors ADD COLUMN color_border BOOLEAN DEFAULT FALSE NOT NULL"
-        )
        try:
-            session.execute(color_border_stmt)
-            session.commit()
-            logger.info("[Library][Migration] Added color_border column to tag_colors table")
-        except Exception as e:
-            logger.error(
-                "[Library][Migration] Could not create color_border column in tag_colors table!",
-                error=e,
-            )
-            session.rollback()
+            migrations = DBMigrations(library_dir, self.engine)

-        # collect new default tag colors
-        tag_colors: list[TagColorGroup] = default_color_groups.standard()
-        tag_colors += default_color_groups.pastels()
-        tag_colors += default_color_groups.shades()
-        tag_colors += default_color_groups.grayscale()
-        tag_colors += default_color_groups.earth_tones()
-        # tag_colors += default_color_groups.neon() # NOTE: Neon is handled separately
+            # save backup if patches will be applied
+            if migrations.required:
+                Library.save_library_backup_to_disk(library_dir)

-        # Add any new default colors introduced in DB_VERSION 8
-        for color in tag_colors:
-            try:
-                session.add(color)
-                logger.info(
-                    "[Library][Migration] Migrated tag color to DB_VERSION 8+",
-                    color_name=color.name,
-                )
-                session.commit()
-            except IntegrityError:
-                session.rollback()
+            migrations.run()
+        except MigrationError as e:
+            return LibraryStatus(success=False, message=e.args[0])

-        # Update Neon colors to use the the color_border property
-        for color in default_color_groups.neon():
-            try:
-                neon_stmt = (
-                    update(TagColorGroup)
-                    .where(
-                        and_(
-                            TagColorGroup.namespace == color.namespace,
-                            TagColorGroup.slug == color.slug,
-                        )
-                    )
-                    .values(
-                        slug=color.slug,
-                        namespace=color.namespace,
-                        name=color.name,
-                        primary=color.primary,
-                        secondary=color.secondary,
-                        color_border=color.color_border,
-                    )
-                )
-                session.execute(neon_stmt)
-                session.commit()
-            except IntegrityError as e:
-                logger.error(
-                    "[Library] Could not migrate Neon colors to DB_VERSION 8+!",
-                    error=e,
-                )
-                session.rollback()
-
-    def __apply_db9_migration(self, session: Session):
-        """Migrate DB from DB_VERSION 8 to 9."""
-        # Apply database schema changes
-        add_filename_column = text(
-            "ALTER TABLE entries ADD COLUMN filename TEXT NOT NULL DEFAULT ''"
-        )
-        try:
-            session.execute(add_filename_column)
-            session.commit()
-            logger.info("[Library][Migration] Added filename column to entries table")
-        except Exception as e:
-            logger.error(
-                "[Library][Migration] Could not create filename column in entries table!",
-                error=e,
-            )
-            session.rollback()
-
-        # Populate the new filename column.
-        for entry in self.all_entries():
-            session.merge(entry).filename = entry.path.name
-        session.commit()
-        logger.info("[Library][Migration] Populated filename column in entries table")
-
-    def __apply_db100_migration(self, session: Session):
-        """Migrate DB to DB_VERSION 100."""
-        with session:
-            # Repair parent-child tag relationships that are the wrong way around.
-            stmt = update(TagParent).values(
-                parent_id=TagParent.child_id,
-                child_id=TagParent.parent_id,
-            )
-            session.execute(stmt)
-            session.commit()
-            logger.info("[Library][Migration] Refactored TagParent table")
-
-    def __apply_db102_migration(self, session: Session):
-        """Migrate DB to DB_VERSION 102."""
-        with session:
-            stmt = delete(TagParent).where(TagParent.parent_id.not_in(select(Tag.id).distinct()))
-            session.execute(stmt)
-            session.commit()
-            logger.info("[Library][Migration] Verified TagParent table data")
-
-    def __apply_db103_migration(self, session: Session):
-        """Migrate DB from DB_VERSION 102 to 103."""
-        # add the new hidden column for tags
-        add_is_hidden_column = text(
-            "ALTER TABLE tags ADD COLUMN is_hidden BOOLEAN NOT NULL DEFAULT 0"
-        )
-        try:
-            session.execute(add_is_hidden_column)
-            session.commit()
-            logger.info("[Library][Migration] Added is_hidden column to tags table")
-        except Exception as e:
-            logger.error(
-                "[Library][Migration] Could not create is_hidden column in tags table!",
-                error=e,
-            )
-            session.rollback()
-
-        # mark the "Archived" tag as hidden
-        try:
-            session.query(Tag).filter(Tag.id == TAG_ARCHIVED).update({"is_hidden": True})
-            session.commit()
-            logger.info("[Library][Migration] Updated archived tag to be hidden")
-        except Exception as e:
-            logger.error(
-                "[Library][Migration] Could not update archived tag to be hidden!",
-                error=e,
-            )
-            session.rollback()
-
-    def __apply_db104_migration(self, session: Session, library_dir: Path):
-        """Migrate DB from DB_VERSION 103 to 104."""
-        # Convert file extension list to ts_ignore file, if a .ts_ignore file does not exist
-        self.__migrate_sql_to_ts_ignore(library_dir)
-        session.execute(text("DROP TABLE preferences"))
-        session.commit()
-
-    def __migrate_sql_to_ts_ignore(self, library_dir: Path):
-        # Do not continue if existing '.ts_ignore' file is found
-        ts_ignore = library_dir / TS_FOLDER_NAME / IGNORE_NAME
-        if Path(ts_ignore).exists():
-            return
-
-        # Load legacy extension data
-        with Session(self.engine) as session:
-            extensions: list[str] = unwrap(
-                session.scalar(text("SELECT value FROM preferences WHERE key = 'EXTENSION_LIST'"))
-            )
-            is_exclude_list: bool = unwrap(
-                session.scalar(text("SELECT value FROM preferences WHERE key = 'IS_EXCLUDE_LIST'"))
-            )
-
-        with open(ts_ignore, "w") as f:
-            f.write(migrate_ext_list(extensions, is_exclude_list))
-
-    def __apply_db200_migration(self, session: Session):
-        """Migrate DB to DB_VERSION 200."""
-        with session:
-            # Drop unused 'boolean_fields' and 'value_type' tables
-            logger.info(
-                "[Library][Migration][200] Dropping boolean_fields and value_type tables..."
-            )
-            session.execute(text("DROP TABLE boolean_fields"))
-            session.execute(text("DROP TABLE value_type"))
-
-            # Add 'name' column to text_fields and datetime_fields tables
-            logger.info("[Library][Migration][200] Adding name columns to field tables...")
-            stmt = text('ALTER TABLE text_fields ADD COLUMN name VARCHAR DEFAULT ""')
-            session.execute(stmt)
-            stmt = text('ALTER TABLE datetime_fields ADD COLUMN name VARCHAR DEFAULT ""')
-            session.execute(stmt)
-
-            # Drop unnecessary 'position' columns
-            logger.info("[Library][Migration][200] Dropping position columns to field tables...")
-            session.execute(text("ALTER TABLE datetime_fields DROP COLUMN position"))
-            session.execute(text("ALTER TABLE text_fields DROP COLUMN position"))
-
-            # Add 'is_multiline' column to text_fields table
-            logger.info("[Library][Migration][200] Adding is_multiline column to text_fields...")
-            stmt = text(
-                "ALTER TABLE text_fields ADD COLUMN is_multiline BOOLEAN NOT NULL DEFAULT 0"
-            )
-            session.execute(stmt)
-            session.flush()
-
-            # Move values from old `type_key` columns into new `name` columns
-            logger.info("[Library][Migration][200] Moving values from type_key columns to name...")
-            session.execute(text("UPDATE text_fields SET name = type_key"))
-            session.execute(text("UPDATE datetime_fields SET name = type_key"))
-            session.flush()
-
-            # Change `name` values to title case
-            logger.info("[Library][Migration][200] Normalizing TextField names...")
-            for text_field in session.execute(select(TextField)).scalars():
-                # NOTE: The only exception to the "Title Case" conversion is the "URL" field.
-                text_field.name = text_field.name.title().replace("Url", "URL").replace("_", " ")
-            logger.info("[Library][Migration][200] Normalizing DatetimeField names...")
-            for datetime_field in session.execute(select(DatetimeField)).scalars():
-                datetime_field.name = datetime_field.name.title().replace("_", " ")
-            session.flush()
-
-            # Add correct `is_multiline` values to text_fields table
-            logger.info("[Library][Migration][200] Updating is_multiline for legacy TEXT_BOXes...")
-            text_boxes = [
-                x.get("name") for x in LEGACY_FIELD_MAP.values() if x.get("is_multiline") is True
-            ]
-            update_stmt = (
-                update(TextField).where(TextField.name.in_(text_boxes)).values(is_multiline=True)
-            )
-            session.execute(update_stmt)
-            session.flush()
-
-            # Repair legacy "Description" fields to use is_multiline = True
-            logger.info("[Library][Migration][200] Repairing legacy Description fields...")
-            desc_stmt = (
-                update(TextField)
-                .where(TextField.name == "Description" and TextField.is_multiline == False)  # noqa: E712
-                .values(is_multiline=True)
-            )
-            session.execute(desc_stmt)
-
-            # Repair legacy "Comments" fields to use is_multiline = True
-            logger.info("[Library][Migration][200] Repairing legacy Comment fields...")
-            comm_stmt = (
-                update(TextField)
-                .where(TextField.name == "Comments" and TextField.is_multiline == False)  # noqa: E712
-                .values(is_multiline=True)
-            )
-            session.execute(comm_stmt)
-
-            # Add default field templates
-            logger.info("[Library][Migration][200] Adding default field templates...")
-            for template in get_default_field_templates():
-                try:
-                    session.add(template)
-                    session.flush()
-                except IntegrityError:
-                    logger.error("[Library] FieldTemplate already exists", field_template=template)
-                    session.rollback()
-
-            session.commit()
-
-    def __apply_db201_migration(self, session: Session):
-        """Migrate DB to DB_VERSION 201."""
-        with session:
-            create_text_fields_table = text("""
-            CREATE TABLE text_fields_new (
-                id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-                name VARCHAR NOT NULL,
-                entry_id INTEGER NOT NULL,
-                value VARCHAR,
-                is_multiline BOOLEAN NOT NULL,
-                FOREIGN KEY(entry_id) REFERENCES entries (id)
-            )
-            """)
-            create_datetime_fields_table = text("""
-            CREATE TABLE datetime_fields_new (
-                id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-                name VARCHAR NOT NULL,
-                entry_id INTEGER NOT NULL,
-                value VARCHAR,
-                FOREIGN KEY(entry_id) REFERENCES entries (id)
-            )
-            """)
-
-            logger.info("[Library][Migration][201] Dropping type_key from text_fields table...")
-            session.execute(create_text_fields_table)
-            session.flush()
-            session.execute(
-                text("""
-                    INSERT INTO text_fields_new (id, name, entry_id, value, is_multiline)
-                    SELECT id, name, entry_id, value, is_multiline
-                    FROM text_fields
-                """)
-            )
-            session.execute(text("DROP TABLE text_fields"))
-            session.execute(text("ALTER TABLE text_fields_new RENAME TO text_fields"))
-
-            logger.info("[Library][Migration][201] Dropping type_key from datetime_fields table...")
-            session.execute(create_datetime_fields_table)
-            session.flush()
-            session.execute(
-                text("""
-                    INSERT INTO datetime_fields_new (id, name, entry_id, value)
-                    SELECT id, name, entry_id, value
-                    FROM datetime_fields
-                """)
-            )
-            session.execute(text("DROP TABLE datetime_fields"))
-            session.execute(text("ALTER TABLE datetime_fields_new RENAME TO datetime_fields"))
-
-            session.commit()
-
-    def __apply_db202_migration(self, session: Session):
-        """Migrate DB to DB_VERSION 202."""
-        with session:
-            stmt = delete(TagParent).where(TagParent.child_id.not_in(select(Tag.id).distinct()))
-            session.execute(stmt)
-            session.commit()
-            logger.info("[Library][Migration] Verified TagParent table data")
+        # everything is fine, set the library path
+        self.library_dir = library_dir
+        return LibraryStatus(success=True, library_path=library_dir)

    @property
    def field_templates(self) -> Sequence[BaseFieldTemplate]:
@@ -1075,32 +669,37 @@ class Library:
        with Session(self.engine) as session:
            return unwrap(session.scalar(select(func.count(Entry.id))))

+    @staticmethod
+    def _all_entries(session: Session, with_joins: bool = False) -> Iterator[Entry]:
+        """Load entries without joins."""
+        stmt = select(Entry)
+        if with_joins:
+            # load Entry with all joins and all tags
+            stmt = (
+                stmt.outerjoin(Entry.text_fields)
+                .outerjoin(Entry.datetime_fields)
+                .outerjoin(Entry.tags)
+            )
+            stmt = stmt.options(
+                contains_eager(Entry.text_fields),
+                contains_eager(Entry.datetime_fields),
+                contains_eager(Entry.tags),
+            )
+
+        stmt = stmt.distinct()
+
+        entries = session.execute(stmt).scalars()
+        if with_joins:
+            entries = entries.unique()
+
+        for entry in entries:
+            yield entry
+            session.expunge(entry)
+
    def all_entries(self, with_joins: bool = False) -> Iterator[Entry]:
        """Load entries without joins."""
        with Session(self.engine) as session:
-            stmt = select(Entry)
-            if with_joins:
-                # load Entry with all joins and all tags
-                stmt = (
-                    stmt.outerjoin(Entry.text_fields)
-                    .outerjoin(Entry.datetime_fields)
-                    .outerjoin(Entry.tags)
-                )
-                stmt = stmt.options(
-                    contains_eager(Entry.text_fields),
-                    contains_eager(Entry.datetime_fields),
-                    contains_eager(Entry.tags),
-                )
-
-            stmt = stmt.distinct()
-
-            entries = session.execute(stmt).scalars()
-            if with_joins:
-                entries = entries.unique()
-
-            for entry in entries:
-                yield entry
-                session.expunge(entry)
+            yield from Library._all_entries(session, with_joins)

    @property
    def tags(self) -> list[Tag]:
@@ -1128,11 +727,12 @@ class Library:
            raise ValueError("Invalid library directory.")

        full_ts_path = library_dir / TS_FOLDER_NAME
-        if not full_ts_path.exists():
-            logger.info("creating library directory", dir=full_ts_path)
-            full_ts_path.mkdir(parents=True, exist_ok=True)
-            return False
-        return True
+        if full_ts_path.exists():
+            return True
+
+        logger.info("creating library directory", dir=full_ts_path)
+        full_ts_path.mkdir(parents=True, exist_ok=True)
+        return False

    def add_entries(self, items: list[Entry]) -> list[int]:
        """Add multiple Entry records to the Library."""
@@ -1737,6 +1337,8 @@ class Library:
                    session.flush()

                if aliases is not None:
+                    for a in aliases:
+                        a.tag_id = tag.id
                    self.update_aliases(tag, aliases, session)
                    session.flush()

@@ -1845,16 +1447,17 @@ class Library:
                session.rollback()
                return None

-    def save_library_backup_to_disk(self) -> Path:
-        assert isinstance(self.library_dir, Path)
-        makedirs(str(self.library_dir / TS_FOLDER_NAME / BACKUP_FOLDER_NAME), exist_ok=True)
+    @staticmethod
+    def save_library_backup_to_disk(library_dir: Path) -> Path:
+        assert isinstance(library_dir, Path)
+        makedirs(str(library_dir / TS_FOLDER_NAME / BACKUP_FOLDER_NAME), exist_ok=True)

        filename = f"ts_library_backup_{datetime.now(UTC).strftime('%Y_%m_%d_%H%M%S')}.sqlite"

-        target_path = self.library_dir / TS_FOLDER_NAME / BACKUP_FOLDER_NAME / filename
+        target_path = library_dir / TS_FOLDER_NAME / BACKUP_FOLDER_NAME / filename

        shutil.copy2(
-            self.library_dir / TS_FOLDER_NAME / SQL_FILENAME,
+            library_dir / TS_FOLDER_NAME / SQL_FILENAME,
            target_path,
        )

@@ -2067,8 +1670,10 @@ class Library:
                )
                session.execute(update_tags_stmt)
                session.commit()
-            else:
-                self.add_color(new_color_group)
+                return
+
+        # "if not existing_color", out of the session context
+        self.add_color(new_color_group)

    def update_aliases(self, tag: Tag, aliases: Iterable[TagAlias], session: Session) -> bool:
        """Update TagAliases for a given Tag."""
@@ -2146,8 +1751,12 @@ class Library:
        Args:
            key(str): The key for the name of the version type to set.
        """
-        with Session(self.engine) as session:
-            engine = sqlalchemy.inspect(self.engine)
+        return Library._get_version(self.engine, key)
+
+    @staticmethod
+    def _get_version(engine, key: str) -> int:
+        with Session(engine) as session:
+            engine = sqlalchemy.inspect(engine)
            try:
                # "Version" table added in DB_VERSION 101
                if engine and engine.has_table("versions"):
@@ -2167,24 +1776,6 @@ class Library:
            except Exception:
                return 0

-    def set_version(self, key: str, value: int) -> None:
-        """Set a version value to the DB.
-
-        Args:
-            key(str): The key for the name of the version type to set.
-            value(int): The version value to set.
-        """
-        with Session(self.engine) as session:
-            try:
-                version = session.scalar(select(Version).where(Version.key == key))
-                assert version
-                version.value = value
-                session.add(version)
-                session.commit()
-            except (IntegrityError, AssertionError) as e:
-                logger.error("[Library][ERROR] Couldn't add default tag color namespaces", error=e)
-                session.rollback()
-
    def mirror_entry_fields(self, entries: list[Entry]) -> None:
        """Mirror fields among multiple Entry items."""
        all_fields: set[BaseField] = set()
@@ -0,0 +1,580 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: MIT
+
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import override
+
+import structlog
+import ujson
+from sqlalchemy import Engine, and_, delete, select, text, update
+from sqlalchemy.orm import Session
+
+from tagstudio.core.constants import IGNORE_NAME, TAG_ARCHIVED, TS_FOLDER_NAME
+from tagstudio.core.library.alchemy import default_color_groups
+from tagstudio.core.library.alchemy.constants import (
+    DB_VERSION,
+    DB_VERSION_CURRENT_KEY,
+    DB_VERSION_INITIAL_KEY,
+    DEFAULT_FIELD_TEMPLATES,
+)
+from tagstudio.core.library.alchemy.fields import LEGACY_FIELD_MAP, DatetimeField, TextField
+from tagstudio.core.library.alchemy.joins import TagParent
+from tagstudio.core.library.alchemy.models import Tag, TagColorGroup, Version
+from tagstudio.core.library.ignore import migrate_ext_list
+from tagstudio.core.utils.types import unwrap
+from tagstudio.qt.translations import Translations
+
+logger = structlog.get_logger(__name__)
+
+LoggingMethod = Callable[[str], str]
+
+
+class MigrationError(Exception):
+    pass
+
+
+class DBMigration:
+    version: int
+    initial_version: int | None = None
+
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod) -> None:  # pyright: ignore[reportUnusedParameter]
+        raise NotImplementedError
+
+
+class DBMigrations:
+    def __init__(self, library_dir: Path, engine: Engine) -> None:
+        # TODO: Remove local import and don't make calls to private methods.
+        from tagstudio.core.library.alchemy.library import Library
+
+        self.library_dir = library_dir
+        self.engine = engine
+
+        # Don't check DB version when creating new library
+        self.loaded_db_version = Library._get_version(engine, DB_VERSION_CURRENT_KEY)
+        self.initial_db_version = Library._get_version(engine, DB_VERSION_INITIAL_KEY)
+
+        # ======================== Library Database Version Checking =======================
+        # DB_VERSION 6 is the first supported SQLite DB version.
+        # If the DB_VERSION is >= 100, that means it's a compound major + minor version.
+        #   - Dividing by 100 and flooring gives the major (breaking changes) version.
+        #   - If a DB has major version higher than the current program, don't load it.
+        #   - If only the minor version is higher, it's still allowed to load.
+        if self.loaded_db_version < 6 or (
+            self.loaded_db_version >= 100 and self.loaded_db_version // 100 > DB_VERSION // 100
+        ):
+            mismatch_text = Translations["status.library_version_mismatch"]
+            found_text = Translations["status.library_version_found"]
+            expected_text = Translations["status.library_version_expected"]
+            raise MigrationError(
+                f"{mismatch_text}\n"
+                f"{found_text} v{self.loaded_db_version}, "
+                f"{expected_text} v{DB_VERSION}"
+            )
+
+        logger.info(
+            f"[Library][Migration] "
+            f"Opening Library with DB Version {self.loaded_db_version}/{DB_VERSION}"
+        )
+
+    @property
+    def required(self) -> bool:
+        return self.loaded_db_version < DB_VERSION
+
+    def run(self):
+
+        # migrate DB step by step from one version to the next
+        # (migration_method, db_version, initial_db_version)
+        migrations: list[type[DBMigration]] = [
+            MigrationTo7,  # changes: value_type, tags
+            MigrationTo8,  # changes: tag_colors
+            MigrationTo9,  # changes: entries
+            MigrationTo100,  # changes: tag_parents
+            MigrationTo101,  # changes: versions
+            MigrationTo102,  # changes: tag_parents
+            MigrationTo103,  # changes: tags
+            MigrationTo104,  # changes: deletes preferences
+            MigrationTo200,  # changes: field tables
+            MigrationTo201,  # changes: field tables
+            MigrationTo202,  # changes: tag_parents
+            MigrationTo300,  # changes: deletes folders
+        ]
+        with Session(self.engine) as session:
+            if self.loaded_db_version > DB_VERSION:
+                return
+
+            for migration in migrations:
+                if self.loaded_db_version < migration.version and (
+                    migration.initial_version is None
+                    or self.initial_db_version < migration.initial_version
+                ):
+                    logger.info(f"[Library][Migration][{migration.version}] Starting DB Migration")
+                    # any error causes transaction to rollback
+                    migration.run(
+                        session,
+                        self.library_dir,
+                        lambda msg, v=migration.version: f"[Library][Migration][{v}] {msg}",
+                    )
+                    self.loaded_db_version = migration.version
+                    try:
+                        self._set_version(session, DB_VERSION_CURRENT_KEY, migration.version)
+                        logger.info(
+                            f"[Library][Migration][{migration.version}] Completed DB Migration"
+                        )
+                    except Exception as e:
+                        logger.info(
+                            f"[Library][Migration][{migration.version}] "
+                            "Couldn't update version, continuing without commit",
+                            error=e,
+                        )
+                        session.flush()
+                    else:
+                        session.commit()
+
+        assert self.loaded_db_version >= DB_VERSION, (
+            "Ran all migrations, but the DB is still not on the newest version"
+        )
+
+    def _set_version(self, session: Session, key: str, value: int) -> None:
+        """Set a version value to the DB.
+
+        Args:
+            session(Session): The SQLAlchemy DB Session to use.
+            key(str): The key for the name of the version type to set.
+            value(int): The version value to set.
+        """
+        # Insert if key has no value yet, otherwise update the value
+        session.merge(Version(key=key, value=value))
+
+
+class MigrationTo7(DBMigration):
+    version = 7
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB from DB_VERSION 6 to 7."""
+        logger.info(fmt_log("Applying patches to DB_VERSION: 6 library..."))
+        # Repair tags that may have a disambiguation_id pointing towards a deleted tag.
+        # TODO: combine into single sql statement
+        all_tag_ids = session.scalars(text("SELECT DISTINCT id FROM tags")).all()
+        disam_stmt = (
+            update(Tag)
+            .where(Tag.disambiguation_id.not_in(all_tag_ids))
+            .values(disambiguation_id=None)
+        )
+        session.execute(disam_stmt)
+        session.flush()
+
+
+class MigrationTo8(DBMigration):
+    version = 8
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB from DB_VERSION 7 to 8."""
+        # Add the missing color_border column to the TagColorGroups table.
+        session.execute(
+            text("ALTER TABLE tag_colors ADD COLUMN color_border BOOLEAN DEFAULT FALSE NOT NULL")
+        )
+        session.flush()
+        logger.info(fmt_log("Added color_border column to tag_colors table"))
+
+        # collect new default tag colors
+        tag_colors: list[TagColorGroup] = [
+            color
+            for color in default_color_groups.shades()
+            if color.slug in ["burgundy", "dark-teal", "dark_lavender"]
+        ]
+
+        # Add any new default colors introduced in DB_VERSION 8
+        for color in tag_colors:
+            session.add(color)
+        session.flush()
+        logger.info(
+            fmt_log("Migrated tag colors to DB_VERSION 8+"),
+            color_name=tag_colors,
+        )
+
+        # Update Neon colors to use the the color_border property
+        for color in default_color_groups.neon():
+            neon_stmt = (
+                update(TagColorGroup)
+                .where(
+                    and_(
+                        TagColorGroup.namespace == color.namespace,
+                        TagColorGroup.slug == color.slug,
+                    )
+                )
+                .values(
+                    slug=color.slug,
+                    namespace=color.namespace,
+                    name=color.name,
+                    primary=color.primary,
+                    secondary=color.secondary,
+                    color_border=color.color_border,
+                )
+            )
+            session.execute(neon_stmt)
+        session.flush()
+
+
+class MigrationTo9(DBMigration):
+    version = 9
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB from DB_VERSION 8 to 9."""
+        # Apply database schema changes
+        add_filename_column = text(
+            "ALTER TABLE entries ADD COLUMN filename TEXT NOT NULL DEFAULT ''"
+        )
+        session.execute(add_filename_column)
+        session.flush()
+        logger.info(fmt_log("Added filename column to entries table"))
+
+        # TODO: Remove local import and don't make calls to private methods.
+        # Populate the new filename column.
+        from tagstudio.core.library.alchemy.library import Library
+
+        for entry in Library._all_entries(session):
+            entry.filename = entry.path.name
+            session.merge(entry)
+        session.flush()
+        logger.info(fmt_log("Populated filename column in entries table"))
+
+
+class MigrationTo100(DBMigration):
+    version = 100
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB to DB_VERSION 100."""
+        # Repair parent-child tag relationships that are the wrong way around.
+        stmt = update(TagParent).values(
+            parent_id=TagParent.child_id,
+            child_id=TagParent.parent_id,
+        )
+        session.execute(stmt)
+        session.flush()
+        logger.info(fmt_log("Refactored TagParent table"))
+
+
+class MigrationTo101(DBMigration):
+    version = 101
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB to DB_VERSION 101."""
+        # Create versions table
+        session.execute(
+            text("""
+        CREATE TABLE versions (
+            "key" VARCHAR NOT NULL PRIMARY KEY,
+            value INTEGER NOT NULL
+        )
+        """)
+        )
+        session.flush()
+        # Ensure version rows are present
+        session.add(Version(key=DB_VERSION_INITIAL_KEY, value=100))
+        session.flush()
+        logger.info(fmt_log("Created versions table"))
+
+
+class MigrationTo102(DBMigration):
+    version = 102
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB to DB_VERSION 102."""
+        # delete TagParents with a dangling parent reference
+        stmt = delete(TagParent).where(TagParent.parent_id.not_in(select(Tag.id).distinct()))
+        session.execute(stmt)
+        session.flush()
+        logger.info(fmt_log("Verified TagParent table data"))
+
+
+class MigrationTo103(DBMigration):
+    version = 103
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB from DB_VERSION 102 to 103."""
+        # add the new hidden column for tags
+        session.execute(text("ALTER TABLE tags ADD COLUMN is_hidden BOOLEAN NOT NULL DEFAULT 0"))
+        session.flush()
+        logger.info(fmt_log("Added is_hidden column to tags table"))
+
+        # mark the "Archived" tag as hidden
+        session.query(Tag).filter(Tag.id == TAG_ARCHIVED).update({"is_hidden": True})
+        session.flush()
+        logger.info(fmt_log("Updated archived tag to be hidden"))
+
+
+class MigrationTo104(DBMigration):
+    version = 104
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB from DB_VERSION 103 to 104."""
+        # Convert file extension list to ts_ignore file, if a .ts_ignore file does not exist
+        cls.__migrate_sql_to_ts_ignore(session, library_dir)
+        session.execute(text("DROP TABLE preferences"))
+        session.flush()
+
+    @classmethod
+    def __migrate_sql_to_ts_ignore(cls, session: Session, library_dir: Path):
+        # Do not continue if existing '.ts_ignore' file is found
+        ts_ignore = library_dir / TS_FOLDER_NAME / IGNORE_NAME
+        if Path(ts_ignore).exists():
+            return
+
+        # Load legacy extension data
+        extensions: list[str] = ujson.loads(
+            unwrap(
+                session.scalar(text("SELECT value FROM preferences WHERE key = 'EXTENSION_LIST'"))
+            )
+        )
+        is_exclude_list: bool = unwrap(
+            session.scalar(text("SELECT value FROM preferences WHERE key = 'IS_EXCLUDE_LIST'"))
+        )
+
+        with open(ts_ignore, "w") as f:
+            f.write(migrate_ext_list(extensions, is_exclude_list))
+
+
+class MigrationTo200(DBMigration):
+    version = 200
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB to DB_VERSION 200."""
+        # Drop unused 'boolean_fields' and 'value_type' tables
+        logger.info(fmt_log("Dropping boolean_fields and value_type tables..."))
+        session.execute(text("DROP TABLE boolean_fields"))
+        session.execute(text("DROP TABLE value_type"))
+
+        # Add 'name' column to text_fields and datetime_fields tables
+        logger.info(fmt_log("Adding name columns to field tables..."))
+        stmt = text('ALTER TABLE text_fields ADD COLUMN name VARCHAR DEFAULT ""')
+        session.execute(stmt)
+        stmt = text('ALTER TABLE datetime_fields ADD COLUMN name VARCHAR DEFAULT ""')
+        session.execute(stmt)
+
+        # Drop unnecessary 'position' columns
+        logger.info(fmt_log("Dropping position columns to field tables..."))
+        session.execute(text("ALTER TABLE datetime_fields DROP COLUMN position"))
+        session.execute(text("ALTER TABLE text_fields DROP COLUMN position"))
+
+        # Add 'is_multiline' column to text_fields table
+        logger.info(fmt_log("Adding is_multiline column to text_fields..."))
+        stmt = text("ALTER TABLE text_fields ADD COLUMN is_multiline BOOLEAN NOT NULL DEFAULT 0")
+        session.execute(stmt)
+        session.flush()
+
+        # Move values from old `type_key` columns into new `name` columns
+        logger.info(fmt_log("Moving values from type_key columns to name..."))
+        session.execute(text("UPDATE text_fields SET name = type_key"))
+        session.execute(text("UPDATE datetime_fields SET name = type_key"))
+        session.flush()
+
+        # Change `name` values to title case
+        logger.info(fmt_log("Normalizing TextField names..."))
+        for text_field in session.execute(select(TextField)).scalars():
+            # NOTE: The only exception to the "Title Case" conversion is the "URL" field.
+            text_field.name = text_field.name.title().replace("Url", "URL").replace("_", " ")
+        logger.info(fmt_log("Normalizing DatetimeField names..."))
+        for datetime_field in session.execute(select(DatetimeField)).scalars():
+            datetime_field.name = datetime_field.name.title().replace("_", " ")
+        session.flush()
+
+        # Add correct `is_multiline` values to text_fields table
+        logger.info(fmt_log("Updating is_multiline for legacy TEXT_BOXes..."))
+        text_boxes = [
+            x.get("name") for x in LEGACY_FIELD_MAP.values() if x.get("is_multiline") is True
+        ]
+        update_stmt = (
+            update(TextField).where(TextField.name.in_(text_boxes)).values(is_multiline=True)
+        )
+        session.execute(update_stmt)
+        session.flush()
+
+        # Repair legacy "Description" fields to use is_multiline = True
+        logger.info(fmt_log("Repairing legacy Description fields..."))
+        desc_stmt = (
+            update(TextField)
+            .where(TextField.name == "Description" and TextField.is_multiline == False)  # noqa: E712
+            .values(is_multiline=True)
+        )
+        session.execute(desc_stmt)
+
+        # Repair legacy "Comments" fields to use is_multiline = True
+        logger.info(fmt_log("Repairing legacy Comment fields..."))
+        comm_stmt = (
+            update(TextField)
+            .where(TextField.name == "Comments" and TextField.is_multiline == False)  # noqa: E712
+            .values(is_multiline=True)
+        )
+        session.execute(comm_stmt)
+
+        # Add field templates tables
+        session.execute(
+            text("""
+        CREATE TABLE text_field_templates (
+            id INTEGER NOT NULL PRIMARY KEY,
+            is_multiline BOOLEAN NOT NULL,
+            name VARCHAR NOT NULL
+        )
+        """)
+        )
+        session.execute(
+            text("""
+        CREATE TABLE datetime_field_templates (
+            id INTEGER NOT NULL PRIMARY KEY,
+            name VARCHAR NOT NULL
+        )
+        """)
+        )
+        session.flush()
+
+        # Add default field templates
+        logger.info(fmt_log("Adding default field templates..."))
+        for template in DEFAULT_FIELD_TEMPLATES:
+            session.add(template)
+        session.flush()
+
+        # DB indices for improved performance
+        session.execute(
+            text("CREATE INDEX IF NOT EXISTS idx_tags_name_shorthand ON tags (name, shorthand)")
+        )
+        session.execute(
+            text("CREATE INDEX IF NOT EXISTS idx_tag_parents_child_id ON tag_parents (child_id)")
+        )
+        session.execute(
+            text("CREATE INDEX IF NOT EXISTS idx_tag_entries_entry_id ON tag_entries (entry_id)")
+        )
+
+
+class MigrationTo201(DBMigration):
+    version = 201
+    initial_version = 200
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB to DB_VERSION 201."""
+        create_text_fields_table = text("""
+        CREATE TABLE text_fields_new (
+            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+            name VARCHAR NOT NULL,
+            entry_id INTEGER NOT NULL,
+            value VARCHAR,
+            is_multiline BOOLEAN NOT NULL,
+            FOREIGN KEY(entry_id) REFERENCES entries (id)
+        )
+        """)
+        create_datetime_fields_table = text("""
+        CREATE TABLE datetime_fields_new (
+            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+            name VARCHAR NOT NULL,
+            entry_id INTEGER NOT NULL,
+            value VARCHAR,
+            FOREIGN KEY(entry_id) REFERENCES entries (id)
+        )
+        """)
+
+        logger.info(fmt_log("Dropping type_key from text_fields table..."))
+        session.execute(create_text_fields_table)
+        session.flush()
+        session.execute(
+            text("""
+                INSERT INTO text_fields_new (id, name, entry_id, value, is_multiline)
+                SELECT id, name, entry_id, value, is_multiline
+                FROM text_fields
+            """)
+        )
+        session.execute(text("DROP TABLE text_fields"))
+        session.execute(text("ALTER TABLE text_fields_new RENAME TO text_fields"))
+
+        logger.info(fmt_log("Dropping type_key from datetime_fields table..."))
+        session.execute(create_datetime_fields_table)
+        session.flush()
+        session.execute(
+            text("""
+                INSERT INTO datetime_fields_new (id, name, entry_id, value)
+                SELECT id, name, entry_id, value
+                FROM datetime_fields
+            """)
+        )
+        session.execute(text("DROP TABLE datetime_fields"))
+        session.execute(text("ALTER TABLE datetime_fields_new RENAME TO datetime_fields"))
+
+        session.flush()
+
+
+class MigrationTo202(DBMigration):
+    version = 202
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        """Migrate DB to DB_VERSION 202."""
+        stmt = delete(TagParent).where(TagParent.child_id.not_in(select(Tag.id).distinct()))
+        session.execute(stmt)
+        session.flush()
+        logger.info(fmt_log("Verified TagParent table data"))
+
+
+class MigrationTo300(DBMigration):
+    version = 300
+
+    @override
+    @classmethod
+    def run(cls, session: Session, library_dir: Path, fmt_log: LoggingMethod):
+        ## remove folder_id column from entries table
+        # create new table in the desired scheme (without folder_id column)
+        session.execute(
+            text("""
+        CREATE TABLE entries_new (
+            id INTEGER NOT NULL,
+            path VARCHAR NOT NULL,
+            suffix VARCHAR NOT NULL,
+            date_created DATETIME,
+            date_modified DATETIME,
+            date_added DATETIME,
+            filename TEXT NOT NULL DEFAULT '',
+            PRIMARY KEY (id),
+            UNIQUE (path)
+        )
+        """)
+        )
+        session.flush()
+        # transfer data to new table
+        session.execute(
+            text("""
+            INSERT INTO entries_new (id, path, suffix, date_created, date_modified, date_added,
+                                     filename)
+            SELECT id, path, suffix, date_created, date_modified, date_added, filename
+            FROM entries
+        """)
+        )
+        # delete old table
+        session.execute(text("DROP TABLE entries"))
+        # rename new table to old table
+        session.execute(text("ALTER TABLE entries_new RENAME TO entries"))
+        session.flush()
+
+        ## drop table "folders"
+        session.execute(text("DROP TABLE folders"))
+        session.flush()
@@ -182,23 +182,11 @@ class Tag(Base):
        return self.name >= other.name


-class Folder(Base):
-    __tablename__ = "folders"
-
-    # TODO - implement this
-    id: Mapped[int] = mapped_column(primary_key=True)
-    path: Mapped[Path] = mapped_column(PathType, unique=True)
-    uuid: Mapped[str] = mapped_column(unique=True)
-
-
 class Entry(Base):
    __tablename__ = "entries"

    id: Mapped[int] = mapped_column(primary_key=True)

-    folder_id: Mapped[int] = mapped_column(ForeignKey("folders.id"))
-    folder: Mapped[Folder] = relationship("Folder")
-
    path: Mapped[Path] = mapped_column(PathType, unique=True)
    filename: Mapped[str] = mapped_column()
    suffix: Mapped[str] = mapped_column()
@@ -235,7 +223,6 @@ class Entry(Base):
    def __init__(
        self,
        path: Path,
-        folder: Folder,
        fields: list[BaseField],
        id: int | None = None,
        date_created: dt | None = None,
@@ -244,7 +231,6 @@ class Entry(Base):
    ) -> None:
        super().__init__()
        self.path = path
-        self.folder = folder
        self.id = id  # pyright: ignore[reportAttributeAccessIssue]
        self.filename = path.name
        self.suffix = path.suffix.lstrip(".").lower()
@@ -16,7 +16,6 @@ from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import Entry
 from tagstudio.core.library.ignore import PATH_GLOB_FLAGS, Ignore, ignore_to_glob
 from tagstudio.core.utils.silent_subprocess import silent_run  # pyright: ignore
-from tagstudio.core.utils.types import unwrap

 logger = structlog.get_logger(__name__)

@@ -41,7 +40,6 @@ class RefreshTracker:
            entries = [
                Entry(
                    path=entry_path,
-                    folder=unwrap(self.library.folder),
                    fields=[],
                    date_added=dt.now(),
                )
@@ -105,6 +105,7 @@ class MediaCategories:
    # These sets are used either individually or together to form the final sets
    # for the MediaCategory(s).
    # These sets may be combined and are NOT 1:1 with the final categories.
+    _ADOBE_ILLUSTRATOR_SET: set[str] = {".ai"}
    _ADOBE_PHOTOSHOP_SET: set[str] = {
        ".pdd",
        ".psb",
@@ -304,6 +305,7 @@ class MediaCategories:
        ".nef",
        ".nrw",
        ".orf",
+        ".r3d",
        ".raf",
        ".raw",
        ".rw2",
@@ -580,7 +582,7 @@ class MediaCategories:
    )
    PDF_TYPES = MediaCategory(
        media_type=MediaType.PDF,
-        extensions=_PDF_SET,
+        extensions=_PDF_SET | _ADOBE_ILLUSTRATOR_SET,
        is_iana=False,
        name="pdf",
    )
@@ -25,6 +25,8 @@ class TagStudioCore:
    @lru_cache(maxsize=1)
    def get_most_recent_release_version() -> str | None:
        """Get the version of the most recent GitHub release."""
+        logger.info("[Core] Checking for updates...")
+
        try:
            resp = requests.get(
                "https://api.github.com/repos/TagStudioDev/TagStudio/releases/latest"
@@ -49,3 +49,14 @@ def is_version_outdated(current: str, latest: str) -> bool:
        return vcur.patch < vlat.patch
    else:
        return vcur.prerelease is not None or vcur.build is not None
+
+
+def format_duration(duration: int | float) -> str:
+    """Format a duration in seconds as M:SS or H:MM:SS."""
+    try:
+        seconds = int(float(duration))
+        hours, seconds = divmod(seconds, 3600)
+        minutes, seconds = divmod(seconds, 60)
+        return f"{hours}:{minutes:02}:{seconds:02}" if hours else f"{minutes}:{seconds:02}"
+    except (OverflowError, ValueError):
+        return "-:--"
@@ -10,7 +10,8 @@ import traceback

 import structlog

-from tagstudio.core.constants import VERSION, VERSION_BRANCH
+from tagstudio.core.constants import BUILD_TYPE, VERSION
+from tagstudio.qt.translations import Translations
 from tagstudio.qt.ts_qt import QtDriver

 logger = structlog.get_logger(__name__)
@@ -59,7 +60,7 @@ def main():
        "--version",
        action="version",
        help="Displays TagStudio version information.",
-        version=f"TagStudio v{VERSION} {VERSION_BRANCH}",
+        version=f"TagStudio v{VERSION} {Translations[BUILD_TYPE] if BUILD_TYPE else ''}",
    )
    args = parser.parse_args()

@@ -0,0 +1,84 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+from typing import override
+
+import structlog
+from PySide6 import QtCore, QtGui
+from PySide6.QtCore import QPoint, Signal
+from PySide6.QtWidgets import (
+    QLineEdit,
+    QMenu,
+    QWidget,
+)
+
+from tagstudio.qt.views.stylesheets.stylesheets import (
+    autofill_scroll_top_focus_style,
+    autofill_scroll_top_style,
+)
+
+logger = structlog.get_logger(__name__)
+
+
+class AutofillLineEdit(QLineEdit):
+    return_pressed = Signal()
+    shift_return_pressed = Signal()
+    holding_shift = Signal(bool)
+    index_updated = Signal(int)
+
+    def __init__(self, popup: QWidget) -> None:
+        super().__init__()
+        self._popup = popup
+
+    @override
+    def focusOutEvent(self, arg__1: QtGui.QFocusEvent) -> None:
+        self._popup.setStyleSheet(autofill_scroll_top_style("container"))
+        return super().focusOutEvent(arg__1)
+
+    @override
+    def focusInEvent(self, arg__1: QtGui.QFocusEvent) -> None:
+        self._popup.setStyleSheet(autofill_scroll_top_focus_style("container"))
+        return super().focusInEvent(arg__1)
+
+    @override
+    def event(self, arg__1: QtCore.QEvent) -> bool:
+        if arg__1.type() == QtCore.QEvent.Type.KeyPress:
+            assert isinstance(arg__1, QtGui.QKeyEvent)
+
+            if arg__1.key() == QtCore.Qt.Key.Key_Tab:
+                self.index_updated.emit(1)
+                return True
+            elif arg__1.key() == QtCore.Qt.Key.Key_Backtab:
+                self.index_updated.emit(-1)
+                return True
+
+            if arg__1.key() == QtCore.Qt.Key.Key_Shift:
+                self.holding_shift.emit(True)  # noqa: FBT003
+
+            if arg__1.key() == QtCore.Qt.Key.Key_Escape:
+                self.setText("")
+                self.clearFocus()
+            elif (
+                arg__1.key() == QtCore.Qt.Key.Key_Enter or arg__1.key() == QtCore.Qt.Key.Key_Return
+            ):
+                if arg__1.modifiers() == QtCore.Qt.KeyboardModifier.ShiftModifier:
+                    self.shift_return_pressed.emit()
+                else:
+                    self.return_pressed.emit()
+
+        return super().event(arg__1)
+
+    @override
+    def keyReleaseEvent(self, arg__1: QtGui.QKeyEvent) -> None:
+        if arg__1.key() == QtCore.Qt.Key.Key_Shift:
+            self.holding_shift.emit(False)  # noqa: FBT003
+        return super().keyReleaseEvent(arg__1)
+
+    def show_action_menu(self, pos: QPoint) -> None:
+        """Show a context menu of actions."""
+        menu = QMenu(self)
+        for action in self.actions():
+            # Filter out icon action(s)
+            if action.text():
+                menu.addAction(action)
+        menu.exec(self.mapToGlobal(pos))  # pyright: ignore[reportArgumentType]
@@ -73,8 +73,8 @@ class EditFieldTemplateModal(EditFieldTemplateModalView):

        self.name_field.setStyleSheet(line_edit_style() if is_empty else "")

-        if self.panel_save_button is not None:
-            self.panel_save_button.setDisabled(is_empty)
+        if self.save_button is not None:
+            self.save_button.setDisabled(is_empty)

    def __on_type_changed(self, index: int):
        old_type = self.__field_type
@@ -0,0 +1,160 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+from typing import override
+from warnings import catch_warnings
+
+import structlog
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import QWidget
+
+from tagstudio.core.library.alchemy.fields import BaseFieldTemplate
+from tagstudio.core.library.alchemy.library import Library
+from tagstudio.qt.controllers.edit_field_template_modal import EditFieldTemplateModal
+from tagstudio.qt.controllers.field_template_widget_controller import FieldTemplateWidget
+from tagstudio.qt.controllers.modal import Modal
+from tagstudio.qt.controllers.modal_content import ModalContent
+from tagstudio.qt.controllers.suggest_box import SuggestBox
+from tagstudio.qt.controllers.underlined_widget import UnderlinedWidget
+from tagstudio.qt.global_settings import GlobalSettings
+from tagstudio.qt.translations import Translations
+
+logger = structlog.get_logger(__name__)
+
+
+class FieldSuggestBox(SuggestBox[BaseFieldTemplate]):
+    def __init__(self, library: Library, settings: GlobalSettings, placeholder_text: str = ""):
+        super().__init__(library, settings, placeholder_text)
+
+        # Context Menu Actions
+        edit_field_on_add_action = QAction(Translations["settings.edit_field_on_add"], self)
+        edit_field_on_add_action.setCheckable(True)
+        self.addAction(edit_field_on_add_action)
+        self.layout().search_field.addAction(edit_field_on_add_action)
+        edit_field_on_add_action.setChecked(self._settings.edit_field_on_add)
+        edit_field_on_add_action.triggered.connect(
+            lambda checked: self._toggle_edit_on_field_add(checked)
+        )
+
+    def _toggle_edit_on_field_add(self, checked: bool) -> None:
+        """Toggle the setting for opening the edit window after adding a field."""
+        self._settings.edit_field_on_add = checked
+        self._settings.save()
+
+    @override
+    def _on_item_create(self) -> None:
+        """Creates a new field template and adds it to the currently selected entries.
+
+        Optionally opens up an edit panel after creation and before adding to entries.
+        Populates name field using current search query.
+        """
+        # NOTE: Unlike tags, creating new field templates will ALWAYS spawn an edit window
+        # since the user needs to decide what type of field it should be before it's created.
+        query: str = self.layout().search_field.text()
+        panel = EditFieldTemplateModal()
+        modal = Modal(
+            panel,
+            Translations["field_template.new"],
+            Translations["field_template.new"],
+            is_savable=True,
+        )
+        if query.strip():
+            panel.name_field.setText(query)
+
+        modal.saved.connect(lambda: self._create_item_from_modal(panel))
+        modal.show()
+
+    @override
+    def _on_item_edit(self, item: BaseFieldTemplate) -> None:
+        panel: EditFieldTemplateModal = EditFieldTemplateModal(item)
+        modal: Modal = Modal(panel, item.name, Translations["field_template.edit"], is_savable=True)
+        modal.saved.connect(lambda: self._edit_item(panel))
+        modal.show()
+
+    @override
+    def _on_item_chosen(self, item: BaseFieldTemplate) -> None:
+        self.item_chosen.emit(item)
+        self.done.emit("*")
+
+    @override
+    def _search_items(self, query: str) -> tuple[list[BaseFieldTemplate], list[BaseFieldTemplate]]:
+        if query != "":
+            return self._lib.search_field_templates(name=query, limit=0), []
+        else:
+            return ([], [])
+
+    @override
+    def _update_hint_icon(self) -> None:
+        if self._is_shift_held:
+            self.set_hint_icon(self._rm.hint_field_create)
+        elif self.layout().search_field.text() and len(self._search_results) > 0:
+            self.set_hint_icon(self._rm.hint_field_add)
+        elif self.layout().search_field.text():
+            self.set_hint_icon(self._rm.hint_field_create)
+        else:
+            self.set_hint_icon(None)
+
+    @override
+    def _set_item_widget(self, item: BaseFieldTemplate | None, index: int) -> None:
+        """Set the field template of a field template widget at a specific index."""
+        underlined_widget: UnderlinedWidget = self._get_item_widget(index, self._lib)
+        field_template_widget = underlined_widget.widget
+        assert isinstance(field_template_widget, FieldTemplateWidget)
+        field_template_widget.has_remove = False
+        field_template_widget.set_field_template(item)
+        underlined_widget.setHidden(item is None)
+
+        if item is None:
+            return
+
+        # TODO: Add tabbing to different items, and use underline to indicate which will be added
+        underlined_widget.toggle_underline(index != 0)
+
+        # Disconnect previous callbacks
+        with catch_warnings(record=True):
+            field_template_widget.on_edit.disconnect()
+            field_template_widget.on_remove.disconnect()
+            field_template_widget.on_click.disconnect()
+
+        # Connect callbacks
+        field_template_widget.on_edit.connect(lambda item_=item: self._on_item_edit(item_))
+        field_template_widget.on_click.connect(
+            lambda checked=False, item_=item: self._on_item_chosen(item_)
+        )
+
+    @override
+    def _create_item_from_modal(self, edit_item_panel: ModalContent) -> None:
+        if isinstance(edit_item_panel, EditFieldTemplateModal):
+            template: BaseFieldTemplate = edit_item_panel.build_field_template()
+            self._lib.add_field_template(template)
+            self._on_item_chosen(template)
+            self._clear_search_query()
+
+        edit_item_panel.hide()
+        self._on_search_query_changed(self.layout().search_field.text())
+
+    @override
+    def _edit_item(self, edit_item_panel: ModalContent) -> None:
+        if not isinstance(edit_item_panel, EditFieldTemplateModal):
+            return
+
+        self._lib.update_field_template(
+            edit_item_panel.old_field_type, edit_item_panel.build_field_template()
+        )
+        self._update_items(self.layout().search_field.text())
+
+    @override
+    def _get_item_widget(self, index: int, library: Library | None) -> UnderlinedWidget:
+        """Gets the item widget at a specific index."""
+        # Create any new item widgets needed up to the given index
+        if self.layout().content_layout.count() <= index:
+            while self.layout().content_layout.count() <= index:
+                field_template_widget = FieldTemplateWidget()
+                widget = UnderlinedWidget(field_template_widget)
+                widget.setHidden(True)
+                self.layout().content_layout.addWidget(widget)
+
+        widget_: QWidget = self.layout().content_layout.itemAt(index).widget()
+        assert isinstance(widget_, UnderlinedWidget)
+        return widget_
@@ -7,57 +7,40 @@ from warnings import catch_warnings

 import structlog
 from PySide6.QtCore import Signal
-from PySide6.QtWidgets import QMessageBox
+from PySide6.QtWidgets import QMessageBox, QWidget

 from tagstudio.core.library.alchemy.fields import BaseFieldTemplate
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.qt.controllers.edit_field_template_modal import EditFieldTemplateModal
 from tagstudio.qt.controllers.field_template_widget_controller import FieldTemplateWidget
+from tagstudio.qt.controllers.modal import Modal
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.controllers.search_panel_controller import SearchPanel
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.field_template_search_panel_view import FieldTemplateSearchPanelView
-from tagstudio.qt.views.panel_modal import PanelModal, PanelWidget
+from tagstudio.qt.views.search_panel_view import SearchPanelView

 logger = structlog.get_logger(__name__)


-class FieldTemplateSearchModal(PanelModal):
-    def __init__(
-        self,
-        library: Library,
-        is_field_template_chooser: bool = True,
-        has_save: bool = False,
-    ) -> None:
-        self.search_panel: FieldTemplateSearchPanel = FieldTemplateSearchPanel(
-            library,
-            is_field_template_chooser,
-            view=FieldTemplateSearchPanelView(is_field_template_chooser),
-        )
-        super().__init__(
-            self.search_panel,
-            Translations["field.add.plural"],
-            is_savable=has_save,
-        )
-
-
 class FieldTemplateSearchPanel(SearchPanel[BaseFieldTemplate]):
    field_template_chosen = Signal(object)

    def __init__(
        self,
        library: Library,
-        is_field_template_chooser: bool = True,
-        view: FieldTemplateSearchPanelView | None = None,
+        is_chooser: bool = True,
+        view: SearchPanelView | None = None,
    ) -> None:
        super().__init__(
-            view=view or FieldTemplateSearchPanelView(is_field_template_chooser),
+            view=view
+            or SearchPanelView(Translations["home.search_field_templates"], is_chooser=is_chooser),
            exclude=[],
-            is_chooser=is_field_template_chooser,
+            is_chooser=is_chooser,
        )
        self.__lib = library

        self._unlimited_limit_item_label = Translations["field_template.all_field_templates"]
-        self._create_and_add_button_label_key = "field_template.create_add"
+        self._create_and_add_button_key = "field_template.create_add"

    @override
    def _get_max_limit(self) -> int:
@@ -76,7 +59,7 @@ class FieldTemplateSearchPanel(SearchPanel[BaseFieldTemplate]):
        logger.info("[FieldTemplateSearch] Create and Add Field Template", name=query)

        panel: EditFieldTemplateModal = EditFieldTemplateModal()
-        modal: PanelModal = PanelModal(
+        modal: Modal = Modal(
            panel,
            Translations["field_template.new"],
            Translations["field_template.new"],
@@ -93,7 +76,7 @@ class FieldTemplateSearchPanel(SearchPanel[BaseFieldTemplate]):
    def on_item_edit(self, item: BaseFieldTemplate) -> None:

        panel: EditFieldTemplateModal = EditFieldTemplateModal(item)
-        modal: PanelModal = PanelModal(
+        modal: Modal = Modal(
            panel,
            item.name,
            Translations["field_template.edit"],
@@ -105,7 +88,7 @@ class FieldTemplateSearchPanel(SearchPanel[BaseFieldTemplate]):

    @override
    def _on_item_remove(self, item: BaseFieldTemplate) -> None:
-        if self.is_chooser:
+        if self._is_chooser:
            return

        message_box = QMessageBox(
@@ -141,7 +124,7 @@ class FieldTemplateSearchPanel(SearchPanel[BaseFieldTemplate]):
        if item is None:
            return

-        field_template_widget.has_remove = not self.is_chooser
+        field_template_widget.has_remove = not self._is_chooser

        # Disconnect previous callbacks
        with catch_warnings(record=True):
@@ -157,7 +140,7 @@ class FieldTemplateSearchPanel(SearchPanel[BaseFieldTemplate]):
        )

    @override
-    def create_item(self, edit_item_panel: PanelWidget, choose_item: bool = False) -> None:
+    def create_item(self, edit_item_panel: ModalContent, choose_item: bool = False) -> None:

        if isinstance(edit_item_panel, EditFieldTemplateModal):
            template: BaseFieldTemplate = edit_item_panel.build_field_template()
@@ -171,11 +154,25 @@ class FieldTemplateSearchPanel(SearchPanel[BaseFieldTemplate]):
        self.on_search_query_changed(self.get_search_query())

    @override
-    def edit_item(self, edit_item_panel: PanelWidget) -> None:
+    def edit_item(self, edit_item_panel: ModalContent) -> None:
        if not isinstance(edit_item_panel, EditFieldTemplateModal):
            return

        self.__lib.update_field_template(
            edit_item_panel.old_field_type, edit_item_panel.build_field_template()
        )
-        self.update_items(self.search_field.text())
+        self.update_items(self.layout().search_field.text())
+
+    @override
+    def get_item_widget(self, index: int, library: Library | None) -> FieldTemplateWidget:
+        """Gets the item widget at a specific index."""
+        # Create any new item widgets needed up to the given index
+        if self.layout().scroll_layout.count() <= index:
+            while self.layout().scroll_layout.count() <= index:
+                pad_field_template_widget = FieldTemplateWidget()
+                pad_field_template_widget.setHidden(True)
+                self.layout().scroll_layout.addWidget(pad_field_template_widget)
+
+        field_template_widget: QWidget = self.layout().scroll_layout.itemAt(index).widget()
+        assert isinstance(field_template_widget, FieldTemplateWidget)
+        return field_template_widget
@@ -0,0 +1,35 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+from typing import override
+
+import structlog
+from PySide6 import QtCore, QtGui
+from PySide6.QtWidgets import QScrollArea
+
+logger = structlog.get_logger(__name__)
+
+
+class HorizontalScrollArea(QScrollArea):
+    """A QScrollArea that translates vertical scrolling to horizontal movement."""
+
+    @override
+    def wheelEvent(self, arg__1: QtGui.QWheelEvent) -> None:
+        angle_y = arg__1.angleDelta().y()
+        pixel_y = arg__1.pixelDelta().y()
+        if angle_y != 0 or pixel_y != 0:
+            translated_event = QtGui.QWheelEvent(
+                arg__1.position(),
+                arg__1.globalPosition(),
+                QtCore.QPoint(pixel_y * -1, 0),
+                QtCore.QPoint(angle_y * -1, 0),
+                arg__1.buttons(),
+                arg__1.modifiers(),
+                arg__1.phase(),
+                arg__1.inverted(),
+            )
+            arg__1.accept()
+            return super().wheelEvent(translated_event)
+        else:
+            return super().wheelEvent(arg__1)
@@ -0,0 +1,85 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import contextlib
+from typing import Any, override
+
+import structlog
+from PySide6 import QtGui
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import QWidget
+
+from tagstudio.qt.controllers.modal_content import ModalContent
+from tagstudio.qt.views.modal_view import ModalView
+
+logger = structlog.get_logger(__name__)
+
+
+class Modal(QWidget):
+    """A generic modal window widget with common signals and styling."""
+
+    done = Signal()
+    saved = Signal()
+    saved_data = Signal(type(Any))
+
+    def __init__(
+        self,
+        content_widget: ModalContent,
+        title: str = "",
+        window_title: str | None = None,
+        is_savable: bool = False,
+        inline_title: bool = True,
+    ):
+        super().__init__()
+        self.setWindowTitle(title if window_title is None else window_title)
+        self.setWindowModality(Qt.WindowModality.ApplicationModal)
+        self.setLayout(
+            ModalView(
+                content_widget=content_widget,
+                title=title,
+                is_savable=is_savable,
+                inline_title=inline_title,
+            )
+        )
+
+        # [Done]
+        # - OR -
+        # [Cancel] [Save]
+        if not is_savable:
+            done_button = self.layout().content_widget.done_button
+            if done_button:
+                done_button.clicked.connect(self.hide)
+                done_button.clicked.connect(self.done.emit)
+        else:
+            cancel_button = self.layout().content_widget.cancel_button
+            if cancel_button:
+                cancel_button.clicked.connect(self.hide)
+                cancel_button.clicked.connect(content_widget.reset)
+
+            save_button = self.layout().content_widget.save_button
+            if save_button:
+                save_button.clicked.connect(self.hide)
+                save_button.clicked.connect(self.saved.emit)
+                save_button.clicked.connect(
+                    lambda: self.saved_data.emit(content_widget.saved_data())
+                )
+
+        content_widget.parent_post_init()
+
+    @override
+    def closeEvent(self, event: QtGui.QCloseEvent) -> None:
+        with contextlib.suppress(AttributeError):
+            cancel_button = self.layout().content_widget.cancel_button
+            if cancel_button:
+                cancel_button.click()
+        with contextlib.suppress(AttributeError):
+            done_button = self.layout().content_widget.done_button
+            if done_button:
+                done_button.click()
+        event.accept()
+
+    @override
+    def layout(self) -> ModalView:
+        """Return the typed layout for this widget."""
+        return super().layout()  # pyright: ignore[reportReturnType]
@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+from typing import Any, override
+
+import structlog
+from PySide6 import QtCore, QtGui
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QPushButton, QWidget
+
+logger = structlog.get_logger(__name__)
+
+
+class ModalContent(QWidget):
+    """Base class for widgets that go inside a Modal widget."""
+
+    save_button: QPushButton | None = None
+    cancel_button: QPushButton | None = None
+    done_button: QPushButton | None = None
+
+    def __init__(self):
+        super().__init__()
+
+    def saved_data(self) -> Any:  # pyright: ignore[reportExplicitAny]
+        return None
+
+    def reset(self) -> None:
+        pass
+
+    def parent_post_init(self) -> None:
+        pass
+
+    @override
+    def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
+        if event.key() == QtCore.Qt.Key.Key_Escape:
+            if self.cancel_button:
+                self.cancel_button.click()
+            elif self.done_button:
+                self.done_button.click()
+        elif event.key() == Qt.Key.Key_Return or event.key() == Qt.Key.Key_Enter:
+            if self.save_button:
+                self.save_button.click()
+            elif self.done_button:
+                self.done_button.click()
+        else:  # Other key presses
+            super().keyPressEvent(event)
@@ -1,65 +1,288 @@
 # SPDX-FileCopyrightText: (c) TagStudio Contributors
 # SPDX-License-Identifier: GPL-3.0-only

-
 import typing
+from datetime import datetime as dt
+from enum import IntEnum
+from functools import partial
+from pathlib import Path
+from typing import override
 from warnings import catch_warnings

-from tagstudio.core.library.alchemy.fields import BaseFieldTemplate
-from tagstudio.core.library.alchemy.library import Library
+import structlog
+from PySide6 import QtCore
+from PySide6.QtGui import QShortcut
+from PySide6.QtWidgets import QWidget
+
+from tagstudio.core.library.alchemy.fields import (
+    BaseField,
+    BaseFieldTemplate,
+    DatetimeField,
+    DatetimeFieldTemplate,
+    TextField,
+    TextFieldTemplate,
+)
+from tagstudio.core.library.alchemy.models import Entry
 from tagstudio.core.utils.ffmpeg_status import FfmpegStatus, FfprobeStatus
-from tagstudio.qt.controllers.field_template_search_panel_controller import FieldTemplateSearchModal
-from tagstudio.qt.controllers.tag_search_panel_controller import TagSearchModal
-from tagstudio.qt.translations import Translations
+from tagstudio.core.utils.types import unwrap
+from tagstudio.qt.controllers.edit_text_controller import EditText
+from tagstudio.qt.controllers.modal import Modal
+from tagstudio.qt.mixed.datetime_picker import DatetimePicker
+from tagstudio.qt.mixed.field_containers import FieldContainers
+from tagstudio.qt.mixed.file_attributes import FileAttributeData
+from tagstudio.qt.translations import FIELD_TYPE_KEYS, Translations
 from tagstudio.qt.views.preview_panel_view import PreviewPanelView

 if typing.TYPE_CHECKING:
    from tagstudio.qt.ts_qt import QtDriver

+logger = structlog.get_logger(__name__)

-class PreviewPanel(PreviewPanelView):
-    def __init__(self, library: Library, driver: "QtDriver") -> None:
-        super().__init__(library, driver)

-        self.__add_field_modal = FieldTemplateSearchModal(self.lib, is_field_template_chooser=True)
-        self.__add_tag_modal = TagSearchModal(
-            self.lib, title=Translations["tag.add.plural"], is_tag_chooser=True
+class _ItemMode(IntEnum):
+    TAG = 1
+    FIELD = 2
+
+
+class PreviewPanel(QWidget):
+    def __init__(self, driver: "QtDriver") -> None:
+        super().__init__()
+        self._driver = driver
+        self._lib = self._driver.lib
+        self._settings = self._driver.settings
+        self._selected: list[int]
+        self._current_stats: FileAttributeData | None = None
+
+        self._open_tag_search_action = QShortcut(
+            QtCore.QKeyCombination(
+                QtCore.Qt.KeyboardModifier(QtCore.Qt.KeyboardModifier.ControlModifier),
+                QtCore.Qt.Key.Key_T,
+            ),
+            self,
+        )
+        self._open_field_search_action = QShortcut(
+            QtCore.QKeyCombination(
+                QtCore.Qt.KeyboardModifier(QtCore.Qt.KeyboardModifier.ControlModifier),
+                QtCore.Qt.Key.Key_L,
+            ),
+            self,
        )
-        self.__add_tag_modal.tsp.set_driver(driver)
-        self._thumb.check_ffmpeg.connect(self._toggle_ffmpeg_warning)

-    @typing.override
-    def _add_field_button_callback(self) -> None:
-        self.__add_field_modal.show()
+        self.setLayout(PreviewPanelView(driver=driver, pixel_ratio=self.devicePixelRatio()))
+        self._set_item_mode(None)
+        self._connect_callbacks()

-    @typing.override
-    def _add_tag_button_callback(self) -> None:
-        self.__add_tag_modal.show()
+    def _connect_callbacks(self) -> None:
+        # Tag Search
+        self.layout().add_tag_button.clicked.connect(lambda: self._set_item_mode(_ItemMode.TAG))
+        self._open_tag_search_action.activated.connect(self._open_tag_search_callback)
+        self.layout().tag_search_box.done.connect(partial(self._tag_added_callback))
+        self.layout().containers.on_tags_update.connect(self._update_added_callback)
+
+        # Field Search
+        self.layout().add_field_button.clicked.connect(lambda: self._set_item_mode(_ItemMode.FIELD))
+        self._open_field_search_action.activated.connect(self._open_field_search_callback)
+        self.layout().field_search_box.done.connect(partial(self._field_added_callback))
+
+        # Previews
+        self.layout().preview_thumb.stats_updated.connect(self._thumb_stats_updated_callback)
+        self.layout().preview_thumb.check_ffmpeg.connect(self._toggle_ffmpeg_warning)
+
+    def _set_item_mode(self, mode: _ItemMode | None):
+        def hide_and_disable_buttons():
+            self.layout().add_tag_button.setHidden(True)
+            self.layout().add_tag_button.setEnabled(False)
+            self.layout().add_field_button.setHidden(True)
+            self.layout().add_field_button.setEnabled(False)
+
+        def restore_buttons():
+            self.layout().add_tag_button.setHidden(False)
+            self.layout().add_tag_button.setEnabled(True)
+            self.layout().add_field_button.setHidden(False)
+            self.layout().add_field_button.setEnabled(True)
+
+        if mode == _ItemMode.TAG:
+            self.layout().tag_search_box.added = self.layout().containers.tags
+            self.layout().field_search_box.hide_and_reset()
+            self.layout().tag_search_box.setHidden(False)
+            hide_and_disable_buttons()
+        elif mode == _ItemMode.FIELD:
+            self.layout().tag_search_box.hide_and_reset()
+            self.layout().field_search_box.setHidden(False)
+            hide_and_disable_buttons()
+        else:
+            self.layout().tag_search_box.hide_and_reset()
+            self.layout().field_search_box.hide_and_reset()
+            restore_buttons()
+
+    def _open_tag_search_callback(self) -> None:
+        self.layout().add_tag_button.setFocus()
+        self.layout().add_tag_button.click()
+
+    def _open_field_search_callback(self) -> None:
+        self.layout().add_field_button.setFocus()
+        self.layout().add_field_button.click()
+
+    def _tag_added_callback(self, query: str):
+        if not query or not self._settings.keep_suggest_boxes_open:
+            self._set_item_mode(None)
+            self.layout().add_tag_button.setFocus()
+        else:
+            self._update_added_callback()
+            self.layout().tag_search_box.layout().search_field.setFocus()
+
+    def _field_added_callback(self, query: str):
+        if not query or not self._settings.keep_suggest_boxes_open:
+            self._set_item_mode(None)
+            self.layout().add_field_button.setFocus()
+        else:
+            self.layout().field_search_box.layout().search_field.setFocus()
+
+    def _update_added_callback(self):
+        self.layout().tag_search_box.added = self.layout().containers.tags
+
+    def _thumb_stats_updated_callback(self, filepath: Path, stats: FileAttributeData) -> None:
+        if len(self._selected) != 1:
+            return
+
+        if filepath != self.layout().preview_thumb.current_file:
+            return
+
+        if self._current_stats is None:
+            self._current_stats = FileAttributeData()
+
+        if stats.width is not None:
+            self._current_stats.width = stats.width
+        if stats.height is not None:
+            self._current_stats.height = stats.height
+        if stats.duration is not None:
+            self._current_stats.duration = stats.duration
+
+        self.layout().file_attrs.update_stats(filepath, self._current_stats)

-    @typing.override
    def _set_selection_callback(self) -> None:
        with catch_warnings(record=True):
-            self.__add_field_modal.search_panel.field_template_chosen.disconnect()
-            self.__add_tag_modal.tsp.item_chosen.disconnect()
+            self.layout().field_search_box.item_chosen.disconnect()
+            self.layout().tag_search_box.item_chosen.disconnect()

-        self.__add_field_modal.search_panel.field_template_chosen.connect(
-            self._add_field_to_selected
-        )
-        self.__add_tag_modal.tsp.item_chosen.connect(self._add_tag_to_selected)
+        self.layout().field_search_box.item_chosen.connect(self._add_field_to_selected)
+        self.layout().tag_search_box.item_chosen.connect(self._add_tag_to_selected)

    def _add_field_to_selected(self, template: BaseFieldTemplate) -> None:
-        self._containers.add_field_to_selected(template)
+        self.layout().containers.add_field_to_selected(template)
+        # TODO: Allow editing of fields across multiple entries at once.
        if len(self._selected) == 1:
-            self._containers.update_from_entry(self._selected[0])
+            if self._driver.settings.edit_field_on_add:
+                entry = unwrap(self._lib.get_entry_full(self._selected[0]))
+                entry_field = None
+                if isinstance(template, TextFieldTemplate):
+                    entry_field = entry.text_fields[-1]
+                elif isinstance(template, DatetimeFieldTemplate):
+                    entry_field = entry.datetime_fields[-1]
+                if entry_field is not None:
+                    self._edit_field(entry.id, entry_field)
+
+            self.layout().containers.update_from_entry(self._selected[0])
+
+    def _edit_field(self, entry_id: int, field: BaseField) -> None:
+        # TODO: A lot of this code is similar to or straight up shared with FieldContainers.
+        # It's possible to reuse it later, after a FieldContainers refactor.
+        field_name_key: str = FIELD_TYPE_KEYS.get(field.class_name, "field_type.unknown")
+
+        if type(field) is TextField:
+            edit_modal = Modal(
+                EditText(field.name, field.value, field.is_multiline),
+                window_title=f"{Translations['field.edit']} ({Translations[field_name_key]})",
+                is_savable=True,
+                inline_title=False,
+            )
+            edit_modal.saved_data.connect(
+                partial(self.layout().containers.update_text_field_callback, field, entry_id)
+            )
+            edit_modal.show()
+        elif type(field) is DatetimeField:
+            edit_modal = Modal(
+                DatetimePicker(self._driver, field.name, field.value or dt.now()),
+                window_title=f"{Translations['field.edit']} ({Translations[field_name_key]})",
+                is_savable=True,
+                inline_title=False,
+            )
+            edit_modal.saved_data.connect(
+                partial(self.layout().containers.update_datetime_field_callback, field, entry_id)
+            )
+            edit_modal.show()

    def _add_tag_to_selected(self, tag_id: int) -> None:
-        self._containers.add_tags_to_selected(tag_id)
+        self.layout().containers.add_tags_to_selected(tag_id)
        if len(self._selected) == 1:
-            self._containers.update_from_entry(self._selected[0])
+            self.layout().containers.update_from_entry(self._selected[0])

    def _toggle_ffmpeg_warning(self, enable_warning: bool = True) -> None:
        if enable_warning and (not FfmpegStatus.which() or not FfprobeStatus.which()):
-            self._ffmpeg_warning_widget.show()
+            self.layout().warning_banner.show()
            return

-        self._ffmpeg_warning_widget.hide()
+        self.layout().warning_banner.hide()
+
+    def set_selection(self, selected: list[int], update_preview: bool = True) -> None:
+        """Render the panel widgets with the newest data from the Library.
+
+        Args:
+            selected  (list[int]): List of the IDs of the selected entries.
+            update_preview (bool): Should the file preview be updated?
+            (Only works with one or more items selected)
+        """
+        self._selected = selected
+        self._set_item_mode(None)
+        try:
+            # No Items Selected
+            if len(selected) == 0:
+                self.layout().preview_thumb.hide_preview()
+                self._current_stats = None
+                self.layout().file_attrs.update_stats()
+                self.layout().file_attrs.update_date_label()
+                self.layout().containers.hide_containers()
+                self.layout().add_tag_button.setEnabled(False)
+                self.layout().add_field_button.setEnabled(False)
+
+            # One Item Selected
+            elif len(selected) == 1:
+                entry_id = selected[0]
+                entry: Entry = unwrap(self._lib.get_entry(entry_id))
+
+                filepath: Path = unwrap(self._lib.library_dir) / entry.path
+                if filepath != self.layout().preview_thumb.current_file:
+                    self._current_stats = None
+
+                if update_preview:
+                    stats: FileAttributeData = self.layout().preview_thumb.display_file(filepath)
+                    self._current_stats = stats
+                    self.layout().file_attrs.update_stats(filepath, stats)
+                self.layout().file_attrs.update_date_label(filepath)
+                self.layout().containers.update_from_entry(entry_id)
+                self._set_selection_callback()
+
+            # Multiple Selected Items
+            elif len(selected) > 1:
+                # items: list[Entry] = [self.lib.get_entry_full(x) for x in self.driver.selected]
+                self.layout().preview_thumb.hide_preview()  # TODO: Render mixed selection
+                self._current_stats = None
+                self.layout().file_attrs.update_multi_selection(len(selected))
+                self.layout().file_attrs.update_date_label()
+                self.layout().containers.hide_containers()  # TODO: Allow for mixed editing
+                self._set_selection_callback()
+
+        except Exception as e:
+            logger.error("[Preview Panel] Error updating selection", error=e)
+
+    def stop_media_playback(self) -> None:
+        """Stop any media playback in the preview panel."""
+        self.layout().preview_thumb.media_player.stop()
+
+    @property
+    def containers(self) -> FieldContainers:
+        return self.layout().containers
+
+    @override
+    def layout(self) -> PreviewPanelView:
+        return super().layout()  # pyright: ignore[reportReturnType]
@@ -32,8 +32,6 @@ Image.MAX_IMAGE_PIXELS = None


 class PreviewThumb(PreviewThumbView):
-    __current_file: Path
-
    def __init__(self, library: Library, driver: "QtDriver"):
        super().__init__(library, driver)

@@ -114,7 +112,7 @@ class PreviewThumb(PreviewThumbView):

    def display_file(self, filepath: Path) -> FileAttributeData:
        """Render a single file preview."""
-        self.__current_file = filepath
+        self._current_file = filepath

        ext = filepath.suffix.lower()

@@ -150,21 +148,26 @@ class PreviewThumb(PreviewThumbView):

    @override
    def _open_file_action_callback(self):
-        open_file(
-            self.__current_file, windows_start_command=self.__driver.settings.windows_start_command
-        )
+        if self._current_file:
+            open_file(
+                self._current_file,
+                windows_start_command=self.__driver.settings.windows_start_command,
+            )

    @override
    def _open_explorer_action_callback(self):
-        open_file(self.__current_file, file_manager=True)
+        if self._current_file:
+            open_file(self._current_file, file_manager=True)

    @override
    def _delete_action_callback(self):
-        if bool(self.__current_file):
-            self.__driver.delete_files_callback(self.__current_file)
+        if self._current_file:
+            self.__driver.delete_files_callback(self._current_file)

    @override
    def _button_wrapper_callback(self):
-        open_file(
-            self.__current_file, windows_start_command=self.__driver.settings.windows_start_command
-        )
+        if self._current_file:
+            open_file(
+                self._current_file,
+                windows_start_command=self.__driver.settings.windows_start_command,
+            )
@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import typing
+from typing import override
+
+import structlog
+from PySide6 import QtCore, QtGui
+from PySide6.QtWidgets import QPushButton
+
+if typing.TYPE_CHECKING:
+    pass
+
+logger = structlog.get_logger(__name__)
+
+
+class ReturnButton(QPushButton):
+    def __init__(self, *args, **kwargs) -> None:  # pyright: ignore
+        super().__init__(*args, **kwargs)
+
+    @override
+    def keyPressEvent(self, arg__1: QtGui.QKeyEvent) -> None:
+        if self.hasFocus() and arg__1.key() in {QtCore.Qt.Key.Key_Enter, QtCore.Qt.Key.Key_Return}:
+            self.click()
+
+        super().keyPressEvent(arg__1)
@@ -8,11 +8,11 @@ import structlog
 from PySide6 import QtCore, QtGui
 from PySide6.QtCore import Signal
 from PySide6.QtGui import QShowEvent
-from PySide6.QtWidgets import QVBoxLayout, QWidget
+from PySide6.QtWidgets import QWidget

 from tagstudio.core.library.alchemy.library import Library
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelWidget
 from tagstudio.qt.views.search_panel_view import SearchPanelView

 logger = structlog.get_logger(__name__)
@@ -40,7 +40,7 @@ def _item_name(item: object) -> str:
        raise AttributeError()


-class SearchPanel[T](PanelWidget):
+class SearchPanel[T](ModalContent):
    item_chosen = Signal(int)

    def __init__(
@@ -50,18 +50,18 @@ class SearchPanel[T](PanelWidget):
        is_chooser: bool = True,
    ) -> None:
        super().__init__()
-        self.view = view
-        self.is_chooser = is_chooser
-        self._layout = QVBoxLayout(self)
-        self._layout.setContentsMargins(0, 0, 0, 0)
-        self._layout.addWidget(self.view)
-        self.view.connect_callbacks(self)
        self._driver: QtDriver | None = None
-        self.exclude: list[int] = exclude or []
+        self._is_chooser = is_chooser
+        self._create_and_add_button_in_layout = False
+        self._create_and_add_button_key: str = ""
+
+        # Items
+        self._excluded: list[int] = exclude or []
+        self._search_results: list[T] = []

        # Limits
        self._unlimited_limit_item_label: str = "All Items"
-        self.__limit_items: list[tuple[str, int]] = [
+        self._limit_items: list[tuple[str, int]] = [
            ("25", 25),
            ("50", 50),
            ("100", 100),
@@ -69,66 +69,102 @@ class SearchPanel[T](PanelWidget):
            ("500", 500),
            (self._unlimited_limit_item_label, -1),
        ]
-        self.__default_limit_index: int = 0  # 25 Limit (Default)
-        self.__previous_limit_index: int = self.__default_limit_index
+        self._default_limit_index: int = 0  # 25 Limit (Default)
+        self._previous_limit_index: int = self._default_limit_index

-        self.view.set_limit_items(self.__limit_items)
-        self.view.set_limit_index(self.__default_limit_index)
+        self.setLayout(view)
+        self.set_limit_items(self._limit_items)
+        self.set_limit_index(self._default_limit_index)
+        self.setMinimumSize(300, 400)
+        self.connect_callbacks(self)

-        # Items
-        self._search_results: list[T] = []
+    def connect_callbacks(self, controller: "SearchPanel[Any]") -> None:  # pyright: ignore[reportExplicitAny]
+        self.layout().limit_combobox.currentIndexChanged.connect(controller.on_limit_changed)
+        self.layout().search_field.textChanged.connect(controller.on_search_query_changed)
+        self.layout().search_field.returnPressed.connect(
+            lambda: controller.on_search_query_submitted(self.get_search_query())
+        )
+        self.layout().create_button.clicked.connect(controller.on_item_create)
+        self.layout().create_and_add_button.clicked.connect(
+            lambda: controller.on_item_create(add_to_entry=True)
+        )

-        self._create_and_add_button_label_key: str = ""
+    def set_limit_items(self, limit_items: list[tuple[str, int]]) -> None:
+        # Remove existing limit items
+        for i in reversed(range(self.layout().limit_combobox.count())):
+            self.layout().limit_combobox.removeItem(i)

-    @property
-    def search_field(self):
-        return self.view.search_field
+        # Add new limit items
+        self.layout().limit_combobox.addItems([limit_item[0] for limit_item in limit_items])

-    @property
-    def create_and_add_button(self):
-        return self.view.create_and_add_button
+    def get_limit_index(self) -> int:
+        return self.layout().limit_combobox.currentIndex()
+
+    def set_limit_index(self, index: int) -> None:
+        self.layout().limit_combobox.setCurrentIndex(index)
+
+    def focus_search_box(self, select_all: bool = False) -> None:
+        self.layout().search_field.setFocus()
+        if select_all:
+            self.layout().search_field.selectAll()

    def get_search_query(self) -> str:
-        return self.view.get_search_query()
+        return self.layout().search_field.text()

    def clear_search_query(self) -> None:
-        self.view.clear_search_query()
+        self.layout().search_field.setText("")
+        self.focus_search_box()

-    def get_item_widget(self, index: int, library: Library):
-        return self.view.get_item_widget(index, library)
+    # Item list
+    def scroll_to(self, position: int) -> None:
+        self.layout().scroll_area.verticalScrollBar().setValue(position)

-    def set_driver(self, driver: "QtDriver") -> None:
-        self._driver = driver
+    def add_create_and_add_button(self) -> None:
+        if self._create_and_add_button_in_layout:
+            return
+        self.layout().scroll_layout.addWidget(self.layout().create_and_add_button)
+        self.layout().create_and_add_button.show()
+        self._create_and_add_button_in_layout = True
+
+    def remove_create_and_add_button(self) -> None:
+        if not self._create_and_add_button_in_layout:
+            return
+        self.layout().scroll_layout.removeWidget(self.layout().create_and_add_button)
+        self.layout().create_and_add_button.hide()
+        self._create_and_add_button_in_layout = False
+
+    def get_item_widget(self, index: int, library: Library) -> Any:  # pyright: ignore[reportExplicitAny]
+        return self.get_item_widget(index, library)

    def on_limit_changed(self, index: int) -> None:
        # Method was called outside the limit_combobox callback
-        if index != self.view.get_limit_index():
-            self.view.set_limit_index(index)
+        if index != self.get_limit_index():
+            self.set_limit_index(index)

-        if self.__previous_limit_index == index:
+        if self._previous_limit_index == index:
            return

-        self.update_items(self.search_field.text())
+        self.update_items(self.layout().search_field.text())

    def _get_limit(self) -> tuple[str, int]:
-        return self.__limit_items[self.view.get_limit_index()]
+        return self._limit_items[self.get_limit_index()]

    def _get_previous_limit(self) -> tuple[str, int]:
-        return self.__limit_items[self.__previous_limit_index]
+        return self._limit_items[self._previous_limit_index]

    def _get_max_limit(self) -> int:
        raise NotImplementedError()

    def on_search_query_changed(self, query: str) -> None:
-        self.create_and_add_button.setText(
-            Translations.format(self._create_and_add_button_label_key, query=query)
+        self.layout().create_and_add_button.setText(
+            Translations.format(self._create_and_add_button_key, query=query)
        )
        self.update_items(query)

    def on_search_query_submitted(self, query: str) -> None:
        # Focus search field if no query
        if not query:
-            self.search_field.setFocus()
+            self.layout().search_field.setFocus()
            parent: QWidget | None = self.parentWidget()
            if parent is not None:  # pyright: ignore[reportUnnecessaryComparison]
                parent.hide()
@@ -137,7 +173,7 @@ class SearchPanel[T](PanelWidget):
        # Create and add item if no search results
        if len(self._search_results) <= 0:
            self.on_item_create(add_to_entry=True)
-        elif self.is_chooser:
+        elif self._is_chooser:
            self._on_item_chosen(self._search_results[0])

        self.clear_search_query()
@@ -156,14 +192,14 @@ class SearchPanel[T](PanelWidget):
        raise NotImplementedError()

    def _is_excluded(self, item: T) -> bool:
-        return _item_id(item) in self.exclude
+        return _item_id(item) in self._excluded

    def update_items(self, query: str | None = None) -> None:
        """Update the item list given a search query."""
        logger.info("[SearchPanel] Updating items", limit=self._get_limit()[1])

        # Remove the "Create & Add" button if one exists
-        self.view.remove_create_and_add_button()
+        self.remove_create_and_add_button()

        # Get results for the search query
        query_lower = "" if not query else query.lower()
@@ -205,11 +241,11 @@ class SearchPanel[T](PanelWidget):
            item: T | None = all_results[i] if i < len(all_results) else None
            self.set_item_widget(item=item, index=i)

-        self.__previous_limit_index = self.view.get_limit_index()
+        self._previous_limit_index = self.get_limit_index()

        # Add back the "Create & Add" button
        if query and query.strip():
-            self.view.add_create_and_add_button()
+            self.add_create_and_add_button()

    def search_items(self, query: str) -> tuple[list[T], list[T]]:  # pyright: ignore[reportUnusedParameter]
        raise NotImplementedError()
@@ -217,11 +253,16 @@ class SearchPanel[T](PanelWidget):
    def set_item_widget(self, item: T | None, index: int) -> None:  # pyright: ignore[reportUnusedParameter]
        raise NotImplementedError()

+    @override
+    def layout(self) -> SearchPanelView:
+        """Return the typed layout for this widget."""
+        return super().layout()  # pyright: ignore[reportReturnType]
+
    @override
    def showEvent(self, event: QShowEvent) -> None:  # noqa N802
        self.update_items()
-        self.view.scroll_to(0)
-        self.view.clear_search_query()
+        self.scroll_to(0)
+        self.clear_search_query()
        return super().showEvent(event)

    @override
@@ -229,13 +270,13 @@ class SearchPanel[T](PanelWidget):
        # When Escape is pressed, focus back on the search box.
        # If focus is already on the search box, close the modal.
        if event.key() == QtCore.Qt.Key.Key_Escape:
-            if self.search_field.hasFocus():
+            if self.layout().search_field.hasFocus():
                super().keyPressEvent(event)
            else:
-                self.view.focus_search_box(select_all=True)
+                self.focus_search_box(select_all=True)

-    def create_item(self, edit_item_panel: PanelWidget, choose_item: bool = False) -> None:  # pyright: ignore[reportUnusedParameter]
+    def create_item(self, edit_item_panel: ModalContent, choose_item: bool = False) -> None:  # pyright: ignore[reportUnusedParameter]
        raise NotImplementedError()

-    def edit_item(self, edit_item_panel: PanelWidget) -> None:  # pyright: ignore[reportUnusedParameter]
+    def edit_item(self, edit_item_panel: ModalContent) -> None:  # pyright: ignore[reportUnusedParameter]
        raise NotImplementedError()
@@ -0,0 +1,310 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+from functools import partial
+from typing import Any, override
+
+import structlog
+from PIL import Image, ImageQt
+from PySide6.QtCore import Signal
+from PySide6.QtGui import QAction, QPixmap, QShowEvent, Qt
+from PySide6.QtWidgets import QGraphicsOpacityEffect, QWidget
+
+from tagstudio.core.library.alchemy.library import Library
+from tagstudio.qt.controllers.autofill_line_edit import QtCore, QtGui
+from tagstudio.qt.controllers.modal_content import ModalContent
+from tagstudio.qt.controllers.underlined_widget import UnderlinedWidget
+from tagstudio.qt.global_settings import GlobalSettings
+from tagstudio.qt.helpers.color_overlay import auto_theme_overlay
+from tagstudio.qt.resource_manager import ResourceManager
+from tagstudio.qt.translations import Translations
+from tagstudio.qt.views.stylesheets.stylesheets import (
+    autofill_line_edit_style,
+    autofill_line_edit_top_style,
+)
+from tagstudio.qt.views.suggest_box_view import SuggestBoxView
+
+logger = structlog.get_logger(__name__)
+
+
+def _item_id(item: object) -> int:
+    item_id: Any = getattr(item, "id")  # noqa: B009  # pyright: ignore[reportExplicitAny]
+
+    if isinstance(item_id, int):
+        return item_id
+    else:
+        raise AttributeError()
+
+
+def _item_name(item: object) -> str:
+    item_name: Any = getattr(item, "name")  # noqa: B009  # pyright: ignore[reportExplicitAny]
+
+    if isinstance(item_name, str):
+        return item_name
+    else:
+        raise AttributeError()
+
+
+class SuggestBox[T](QWidget):
+    item_chosen = Signal(object)
+    done = Signal(str)  # Query
+
+    def __init__(
+        self, library: Library, settings: GlobalSettings, placeholder_text: str = ""
+    ) -> None:
+        super().__init__()
+        self._lib = library
+        self._settings = settings
+        self._rm = ResourceManager()
+        self._limit = 25
+        self._is_shift_held = False
+        self._search_results: list[T] = []
+        self._selection_index = 0
+        self.added: list[int] = []
+        self.excluded: list[int] = []
+
+        self.setLayout(SuggestBoxView(placeholder_text))
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.ActionsContextMenu)
+        self._connect_callbacks()
+
+        self._keep_box_open_action = QAction(Translations["settings.keep_suggest_boxes_open"], self)
+        self._keep_box_open_action.setCheckable(True)
+        self.addAction(self._keep_box_open_action)
+        self.layout().search_field.addAction(self._keep_box_open_action)
+        self._keep_box_open_action.triggered.connect(
+            lambda checked: self._toggle_keep_open(checked)
+        )
+
+    def _toggle_keep_open(self, checked: bool) -> None:
+        self._settings.keep_suggest_boxes_open = checked
+        self._settings.save()
+
+    def set_placeholder_text(self, text: str) -> None:
+        self.layout().search_field.setPlaceholderText(text)
+
+    def hide_and_reset(self) -> None:
+        self.hide()
+        self.layout().search_field.setDisabled(True)
+        self._on_shift_held(held=False)
+
+    def _connect_callbacks(self) -> None:
+        self.layout().search_field.textChanged.connect(self._on_search_query_changed)
+        self.layout().search_field.editingFinished.connect(self._editing_finished_callback)
+        self.layout().search_field.return_pressed.connect(
+            lambda: self._on_search_query_submitted(self.layout().search_field.text())
+        )
+        self.layout().search_field.shift_return_pressed.connect(
+            lambda: self._on_search_query_submitted(
+                self.layout().search_field.text(), always_create=True
+            )
+        )
+
+        self.layout().search_field.holding_shift.connect(partial(self._on_shift_held))
+        self.layout().search_field.index_updated.connect(partial(self._on_index_updated))
+
+    def set_hint_icon(self, icon: Image.Image | None) -> None:
+        if icon:
+            pixmap = QPixmap.fromImage(ImageQt.ImageQt(auto_theme_overlay(icon)))
+            self.layout().hint_icon_action.setIcon(pixmap)
+        else:
+            self.layout().hint_icon_action.setIcon(QPixmap())
+
+    def _on_shift_held(self, held: bool) -> None:
+        self._is_shift_held = held
+        for i in range(0, self.layout().content_layout.count()):
+            underlined_widget = self.layout().content_layout.itemAt(i).widget()
+            assert isinstance(underlined_widget, UnderlinedWidget)
+
+            if held and i == self._selection_index:
+                opacity_effect = QGraphicsOpacityEffect(self)
+                opacity_effect.setOpacity(0.3)
+                underlined_widget.widget.setGraphicsEffect(opacity_effect)
+            elif (
+                len(self._search_results) > i
+                and _item_id(self._search_results[i]) not in self.added
+            ):
+                underlined_widget.widget.setGraphicsEffect(None)  # pyright: ignore[reportArgumentType]
+        self._update_hint_icon()
+
+    def _on_index_updated(self, delta: int) -> None:
+        # Initialize the widget count (non-hidden)
+        widget_count = 0
+        for i in range(0, self.layout().content_layout.count()):
+            widget = self.layout().content_layout.itemAt(i).widget()
+            if not widget.isHidden():
+                widget_count += 1
+
+        # Update the index
+        old_idx = self._selection_index
+        max_idx = widget_count - 1
+        if self._selection_index + delta < 0:
+            # Can't move further left
+            self._selection_index = 0
+        elif self._selection_index + delta > max_idx:
+            self._selection_index = max_idx
+        else:
+            self._selection_index = self._selection_index + delta
+
+        # Don't update the UI if there's no index change
+        if old_idx == self._selection_index:
+            return
+
+        # Draw the correct underline for the selected widget
+        for i in range(0, widget_count):
+            underlined_widget = self.layout().content_layout.itemAt(i).widget()
+            assert isinstance(underlined_widget, UnderlinedWidget)
+            if i == self._selection_index:
+                underlined_widget.toggle_underline(is_hidden=False)
+                self.layout().scroll_area.ensureWidgetVisible(
+                    underlined_widget, xmargin=16, ymargin=0
+                )
+            else:
+                underlined_widget.toggle_underline(is_hidden=True)
+
+        self._on_shift_held(self._is_shift_held)
+        self._update_hint_icon()
+
+    def _clear_search_query(self) -> None:
+        self.layout().search_field.setText("")
+
+    def _get_item_widget(self, index: int, library: Library) -> Any:  # pyright: ignore
+        raise NotImplementedError()
+
+    def _on_search_query_changed(self, query: str) -> None:
+        self._update_items(query.strip())
+        self._update_hint_icon()
+
+    def _on_search_query_submitted(self, query: str, always_create: bool = False) -> None:
+        # Focus search field if no query
+        if not query:
+            self.done.emit(query)
+            return
+        elif not self.isHidden():
+            self.layout().search_field.setFocus()
+
+        # Create and add item if no search results
+        if (len(self._search_results) <= 0) or always_create:
+            self._on_item_create()
+        else:
+            self._on_item_chosen(self._search_results[self._selection_index])
+
+        self._clear_search_query()
+        self._update_items()
+
+    def _on_item_create(self) -> None:
+        raise NotImplementedError()
+
+    def _on_item_edit(self, item: T) -> None:  # pyright: ignore[reportUnusedParameter]
+        raise NotImplementedError()
+
+    def _on_item_chosen(self, item: T) -> None:  # pyright: ignore[reportUnusedParameter]
+        raise NotImplementedError()
+
+    def _is_excluded(self, item: T) -> bool:
+        return _item_id(item) in self.excluded
+
+    def _is_selected_item_added(self) -> bool:
+        return bool(
+            len(self._search_results) > self._selection_index
+            and _item_id(self._search_results[self._selection_index]) in self.added
+        )
+
+    def _update_hint_icon(self) -> None:
+        raise NotImplementedError()
+
+    def _update_items(self, query: str | None = None) -> None:
+        """Update the item list given a search query."""
+        logger.info("[SearchPanel] Updating items", limit=self._limit)
+        self._selection_index = 0
+        if self.layout().content_layout.count() > 0:
+            self.layout().scroll_area.ensureWidgetVisible(
+                self.layout().content_layout.itemAt(0).widget(), xmargin=16, ymargin=0
+            )
+
+        # Get results for the search query
+        query_lower = "" if not query else query.lower()
+        search_results: tuple[list[T], list[T]] = self._search_items(query_lower)
+
+        # Sort and prioritize the results
+        direct_results = list({item for item in search_results[0] if not self._is_excluded(item)})
+        direct_results.sort(key=lambda item: _item_name(item).lower())
+
+        ancestor_results = list({item for item in search_results[1] if not self._is_excluded(item)})
+        ancestor_results.sort(key=lambda item: _item_name(item).lower())
+
+        raw_results = list(direct_results + ancestor_results)
+        priority_results: set[T] = set()
+
+        if query and query.strip():
+            for raw_item in raw_results:
+                if _item_name(raw_item).lower().startswith(query_lower):
+                    priority_results.add(raw_item)
+
+        all_results: list[T] = sorted(list(priority_results), key=lambda i: len(_item_name(i))) + [
+            item for item in raw_results if item not in priority_results
+        ]
+
+        # Target items already added to a selection and move them to the end of the list
+        already_added: list[T] = [i for i in all_results if _item_id(i) in self.added]
+        for item in already_added:
+            if item in all_results:
+                all_results.remove(item)
+        all_results = all_results + already_added
+
+        if self._limit > 0:
+            all_results = all_results[: self._limit]
+
+        self._search_results = all_results
+        logger.info("[SearchPanel] Search results", results=self._search_results)
+
+        for i in range(0, self._limit):
+            item: T | None = all_results[i] if i < len(all_results) else None
+            self._set_item_widget(item=item, index=i)
+
+        if self.layout().content_layout.isEmpty():
+            self.layout().scroll_area.setHidden(True)
+            self.layout().content_layout.setContentsMargins(0, 0, 0, 0)
+            self.layout().search_field.setStyleSheet(autofill_line_edit_style())
+        else:
+            self.layout().scroll_area.setHidden(False)
+            self.layout().content_layout.setContentsMargins(4, 6, 4, 6)
+            self.layout().search_field.setStyleSheet(autofill_line_edit_top_style())
+
+    def _search_items(self, query: str) -> tuple[list[T], list[T]]:  # pyright: ignore[reportUnusedParameter]
+        raise NotImplementedError()
+
+    def _set_item_widget(self, item: T | None, index: int) -> None:  # pyright: ignore[reportUnusedParameter]
+        raise NotImplementedError()
+
+    def _editing_finished_callback(self) -> None:
+        # Only trigger when the search field is clicked off of and there's no query.
+        # NOTE: The search field is already cleared by this point when pressing enter.
+        if self.layout().search_field.text() == "" and not self.layout().search_field.hasFocus():
+            self.done.emit("")
+
+    def _create_item_from_modal(self, edit_item_panel: ModalContent) -> None:  # pyright: ignore[reportUnusedParameter]
+        raise NotImplementedError()
+
+    def _edit_item(self, edit_item_panel: ModalContent) -> None:  # pyright: ignore[reportUnusedParameter]
+        raise NotImplementedError()
+
+    @override
+    def showEvent(self, event: QShowEvent) -> None:
+        self._update_items()
+        self._on_shift_held(held=False)
+        self.layout().search_field.setDisabled(False)
+        self._clear_search_query()
+        self._keep_box_open_action.setChecked(self._settings.keep_suggest_boxes_open)
+        return super().showEvent(event)
+
+    @override
+    def layout(self) -> SuggestBoxView:
+        return super().layout()  # pyright: ignore[reportReturnType]
+
+    @override
+    def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
+        # When Escape is pressed, focus back on the search box.
+        if event.key() in {QtCore.Qt.Key.Key_Enter, QtCore.Qt.Key.Key_Return}:
+            self.done.emit("*")
+        elif event.key() == QtCore.Qt.Key.Key_Escape:
+            self.done.emit("")
@@ -12,8 +12,8 @@ from tagstudio.core.enums import TagClickActionOption
 from tagstudio.core.library.alchemy.enums import BrowsingState
 from tagstudio.core.library.alchemy.models import Tag
 from tagstudio.core.utils.types import unwrap
+from tagstudio.qt.controllers.modal import Modal
 from tagstudio.qt.mixed.build_tag import BuildTagPanel
-from tagstudio.qt.views.panel_modal import PanelModal
 from tagstudio.qt.views.tag_box_view import TagBoxWidgetView

 if TYPE_CHECKING:
@@ -74,7 +74,7 @@ class TagBoxWidget(TagBoxWidgetView):
    def _on_edit(self, tag: Tag) -> None:
        build_tag_panel = BuildTagPanel(self.__driver.lib, tag=tag)

-        edit_modal = PanelModal(
+        edit_modal = Modal(
            build_tag_panel,
            self.__driver.lib.tag_display_name(tag),
            "Edit Tag",
@@ -6,66 +6,44 @@ from typing import override
 from warnings import catch_warnings

 import structlog
-from PySide6.QtWidgets import QMessageBox
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QMessageBox, QWidget

 from tagstudio.core.constants import RESERVED_TAG_END, RESERVED_TAG_START
-from tagstudio.core.library.alchemy.enums import BrowsingState
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import Tag
+from tagstudio.qt.controllers.modal import Modal
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.controllers.search_panel_controller import SearchPanel
 from tagstudio.qt.mixed.tag_widget import TagWidget
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelModal, PanelWidget
-from tagstudio.qt.views.tag_search_panel_view import TagSearchPanelView
+from tagstudio.qt.views.search_panel_view import SearchPanelView

 logger = structlog.get_logger(__name__)


-class TagSearchModal(PanelModal):
-    tsp: "TagSearchPanel"
-
-    def __init__(
-        self,
-        library: Library,
-        title: str,
-        exclude: list[int] | None = None,
-        is_tag_chooser: bool = True,
-        has_save: bool = False,
-    ):
-        self.tsp = TagSearchPanel(
-            library,
-            exclude,
-            is_tag_chooser,
-            view=TagSearchPanelView(is_tag_chooser),
-        )
-        super().__init__(
-            widget=self.tsp,
-            title=title,
-            is_savable=has_save,
-        )
-
-
 class TagSearchPanel(SearchPanel[Tag]):
+    search_for_tag = Signal(int)
+
    def __init__(
        self,
        library: Library,
        exclude: list[int] | None = None,
-        is_tag_chooser: bool = True,
-        view: TagSearchPanelView | None = None,
+        is_chooser: bool = True,
+        view: SearchPanelView | None = None,
    ):
        super().__init__(
-            view=view or TagSearchPanelView(is_tag_chooser),
+            view=view or SearchPanelView(Translations["home.search_tags"], is_chooser=is_chooser),
            exclude=exclude,
-            is_chooser=is_tag_chooser,
+            is_chooser=is_chooser,
        )
-        self.__lib = library
-
+        self._lib = library
        self._unlimited_limit_item_label = Translations["tag.all_tags"]
-        self._create_and_add_button_label_key = "tag.create_add"
+        self._create_and_add_button_key = "tag.create_add"

    @override
    def _get_max_limit(self) -> int:
-        return len(self.__lib.tags)
+        return len(self._lib.tags)

    @override
    def on_item_create(self, add_to_entry: bool = False) -> None:
@@ -80,9 +58,8 @@ class TagSearchPanel(SearchPanel[Tag]):
        from tagstudio.qt.mixed.build_tag import BuildTagPanel  # here due to circular imports

        query: str = self.get_search_query()
-
-        panel: BuildTagPanel = BuildTagPanel(self.__lib)
-        modal: PanelModal = PanelModal(
+        panel: BuildTagPanel = BuildTagPanel(self._lib)
+        modal: Modal = Modal(
            panel,
            Translations["tag.new"],
            Translations["tag.add"] if add_to_entry else Translations["tag.new"],
@@ -100,10 +77,10 @@ class TagSearchPanel(SearchPanel[Tag]):
        # TODO: Move this to a top-level import
        from tagstudio.qt.mixed.build_tag import BuildTagPanel  # here due to circular imports

-        edit_tag_panel: BuildTagPanel = BuildTagPanel(self.__lib, tag=item)
-        edit_tag_modal: PanelModal = PanelModal(
+        edit_tag_panel: BuildTagPanel = BuildTagPanel(self._lib, tag=item)
+        edit_tag_modal: Modal = Modal(
            edit_tag_panel,
-            self.__lib.tag_display_name(item),
+            self._lib.tag_display_name(item),
            Translations["tag.edit"],
            is_savable=True,
        )
@@ -112,7 +89,7 @@ class TagSearchPanel(SearchPanel[Tag]):

    @override
    def _on_item_remove(self, item: Tag) -> None:
-        if self.is_chooser:
+        if self._is_chooser:
            return

        if item.id in range(RESERVED_TAG_START, RESERVED_TAG_END):
@@ -121,7 +98,7 @@ class TagSearchPanel(SearchPanel[Tag]):
        message_box = QMessageBox(
            QMessageBox.Icon.Question,
            Translations["tag.remove"],
-            Translations.format("tag.confirm_delete", tag_name=self.__lib.tag_display_name(item)),
+            Translations.format("tag.confirm_delete", tag_name=self._lib.tag_display_name(item)),
            QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Cancel,
        )

@@ -130,7 +107,7 @@ class TagSearchPanel(SearchPanel[Tag]):
        if result != QMessageBox.StandardButton.Ok:
            return

-        self.__lib.remove_tag(item.id)
+        self._lib.remove_tag(item.id)
        self.update_items(self.get_search_query())

    @override
@@ -139,12 +116,12 @@ class TagSearchPanel(SearchPanel[Tag]):

    @override
    def search_items(self, query: str) -> tuple[list[Tag], list[Tag]]:
-        return self.__lib.search_tags(name=query, limit=self._get_limit()[1])
+        return self._lib.search_tags(name=query, limit=self._get_limit()[1])

    @override
    def set_item_widget(self, item: Tag | None, index: int) -> None:
        """Set the tag of a tag widget at a specific index."""
-        tag_widget: TagWidget = self.get_item_widget(index, self.__lib)
+        tag_widget: TagWidget = self.get_item_widget(index, self._lib)
        tag_widget.set_tag(item)
        tag_widget.setHidden(item is None)

@@ -152,7 +129,7 @@ class TagSearchPanel(SearchPanel[Tag]):
            return
        assert item is not None

-        tag_widget.has_remove = not self.is_chooser and item.id not in range(
+        tag_widget.has_remove = not self._is_chooser and item.id not in range(
            RESERVED_TAG_START, RESERVED_TAG_END
        )

@@ -166,7 +143,7 @@ class TagSearchPanel(SearchPanel[Tag]):
        # Connect callbacks
        tag_widget.on_edit.connect(lambda edit_tag=item: self.on_item_edit(edit_tag))
        tag_widget.on_remove.connect(lambda remove_tag=item: self._on_item_remove(remove_tag))
-        if self.is_chooser:
+        if self._is_chooser:
            tag_widget.bg_button.clicked.connect(
                lambda checked=False, tag=item: self._on_item_chosen(tag)
            )
@@ -176,25 +153,19 @@ class TagSearchPanel(SearchPanel[Tag]):
            )

        # Connect search action
-        if self._driver is not None:
-            tag_widget.search_for_tag_action.triggered.connect(
-                lambda checked=False, tag_id=item.id: self.search_for_tag(tag_id)
-            )
-            tag_widget.search_for_tag_action.setEnabled(True)
-        else:
-            logger.warning(
-                "[TagSearchPanel] No driver was set for this TagSearchPanel. Was this on purpose?"
-            )
-            tag_widget.search_for_tag_action.setEnabled(False)
+        tag_widget.search_for_tag_action.triggered.connect(
+            lambda checked=False, tag_id=item.id: self.search_for_tag.emit(tag_id)
+        )
+        tag_widget.search_for_tag_action.setEnabled(True)

    @override
-    def create_item(self, edit_item_panel: PanelWidget, choose_item: bool = False) -> None:
+    def create_item(self, edit_item_panel: ModalContent, choose_item: bool = False) -> None:
        # TODO: Move this to a top-level import
        from tagstudio.qt.mixed.build_tag import BuildTagPanel  # here due to circular imports

        if isinstance(edit_item_panel, BuildTagPanel):
            tag: Tag = edit_item_panel.build_tag()
-            self.__lib.add_tag(
+            self._lib.add_tag(
                tag, parent_ids=edit_item_panel.parent_ids, aliases=edit_item_panel.aliases
            )

@@ -206,25 +177,32 @@ class TagSearchPanel(SearchPanel[Tag]):
        self.on_search_query_changed(self.get_search_query())

    @override
-    def edit_item(self, edit_item_panel: PanelWidget) -> None:
+    def edit_item(self, edit_item_panel: ModalContent) -> None:
        # TODO: Move this to a top-level import
        from tagstudio.qt.mixed.build_tag import BuildTagPanel  # here due to circular imports

        if not isinstance(edit_item_panel, BuildTagPanel):
            return

-        self.__lib.update_tag(
+        self._lib.update_tag(
            tag=edit_item_panel.build_tag(),
            parent_ids=edit_item_panel.parent_ids,
            aliases=edit_item_panel.aliases,
        )
-        self.update_items(self.search_field.text())
+        self.update_items(self.layout().search_field.text())

-    def search_for_tag(self, tag_id: int) -> None:
-        if self._driver is None:
-            return
+    @override
+    def get_item_widget(self, index: int, library: Library | None) -> TagWidget:
+        """Gets the item widget at a specific index."""
+        # Create any new item widgets needed up to the given index
+        if self.layout().scroll_layout.count() <= index:
+            while self.layout().scroll_layout.count() <= index:
+                pad_tag_widget = TagWidget(
+                    tag=None, has_edit=True, has_remove=True, library=library
+                )
+                pad_tag_widget.setHidden(True)
+                self.layout().scroll_layout.addWidget(pad_tag_widget)

-        self._driver.main_window.search_field.setText(f"tag_id:{tag_id}")
-        self._driver.update_browsing_state(
-            BrowsingState.from_tag_id(tag_id, self._driver.browsing_history.current)
-        )
+        tag_widget: QWidget = self.layout().scroll_layout.itemAt(index).widget()
+        assert isinstance(tag_widget, TagWidget)
+        return tag_widget
@@ -0,0 +1,194 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+from typing import override
+from warnings import catch_warnings
+
+import structlog
+from PySide6.QtCore import Signal
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import QGraphicsOpacityEffect, QWidget
+
+from tagstudio.core.library.alchemy.library import Library
+from tagstudio.core.library.alchemy.models import Tag
+from tagstudio.qt.controllers.modal import Modal
+from tagstudio.qt.controllers.modal_content import ModalContent
+from tagstudio.qt.controllers.suggest_box import SuggestBox
+from tagstudio.qt.controllers.underlined_widget import UnderlinedWidget
+from tagstudio.qt.global_settings import GlobalSettings
+from tagstudio.qt.mixed.build_tag import BuildTagPanel
+from tagstudio.qt.mixed.tag_widget import TagWidget
+from tagstudio.qt.translations import Translations
+
+logger = structlog.get_logger(__name__)
+
+
+class TagSuggestBox(SuggestBox[Tag]):
+    search_for_tag = Signal(int)
+
+    def __init__(
+        self, library: Library, settings: GlobalSettings, placeholder_text: str = ""
+    ) -> None:
+        super().__init__(library, settings, placeholder_text)
+
+        # Context Menu Actions
+
+        edit_tag_on_create_action = QAction(Translations["settings.edit_tag_on_create"], self)
+        edit_tag_on_create_action.setCheckable(True)
+        self.addAction(edit_tag_on_create_action)
+        self.layout().search_field.addAction(edit_tag_on_create_action)
+        edit_tag_on_create_action.setChecked(self._settings.edit_tag_on_create)
+        edit_tag_on_create_action.triggered.connect(
+            lambda checked: self._toggle_edit_on_tag_create(checked)
+        )
+
+    def _toggle_edit_on_tag_create(self, checked: bool) -> None:
+        """Toggle the setting for opening the edit window after creating a tag."""
+        self._settings.edit_tag_on_create = checked
+        self._settings.save()
+
+    @override
+    def _on_item_create(self) -> None:
+        """Creates a new tag and adds it to the currently selected entries.
+
+        Optionally opens up an edit panel after creation and before adding to entries.
+        Populates name field using current search query.
+        """
+        query: str = self.layout().search_field.text()
+
+        if self._settings.edit_tag_on_create:
+            panel: BuildTagPanel = BuildTagPanel(self._lib)
+            modal: Modal = Modal(
+                panel, Translations["tag.new"], Translations["tag.new"], is_savable=True
+            )
+            if query.strip():
+                panel.name_field.setText(query)
+
+            modal.saved.connect(lambda: self._create_item_from_modal(panel))
+            modal.show()
+        else:
+            tag = Tag(name=query)
+            self._lib.add_tag(tag)
+            self._on_item_chosen(tag)
+            self._clear_search_query()
+
+    @override
+    def _on_item_edit(self, item: Tag) -> None:
+        edit_tag_panel: BuildTagPanel = BuildTagPanel(self._lib, tag=item)
+        edit_tag_modal: Modal = Modal(
+            edit_tag_panel,
+            self._lib.tag_display_name(item),
+            Translations["tag.edit"],
+            is_savable=True,
+        )
+        edit_tag_modal.saved.connect(lambda: self._edit_item(edit_tag_panel))
+        edit_tag_modal.show()
+
+    @override
+    def _on_item_chosen(self, item: Tag) -> None:
+        self.item_chosen.emit(item.id)
+        self._clear_search_query()
+        self.done.emit("*")  # The query does not matter
+
+    @override
+    def _update_hint_icon(self) -> None:
+        results = bool(len(self._search_results) > 0)
+
+        if not self._is_shift_held and self._is_selected_item_added():
+            self.set_hint_icon(self._rm.hint_tag_added)
+        elif self._is_shift_held:
+            self.set_hint_icon(self._rm.hint_tag_create)
+        elif results and self._is_selected_item_added():
+            self.set_hint_icon(self._rm.hint_tag_added)
+        elif results:
+            self.set_hint_icon(self._rm.hint_tag_add)
+        elif self.layout().search_field.text():
+            self.set_hint_icon(self._rm.hint_tag_create)
+        else:
+            self.set_hint_icon(None)
+
+    @override
+    def _search_items(self, query: str) -> tuple[list[Tag], list[Tag]]:
+        if query != "":
+            return self._lib.search_tags(name=query, limit=0)
+        else:
+            return ([], [])
+
+    @override
+    def _set_item_widget(self, item: Tag | None, index: int) -> None:
+        """Set the tag of a tag widget at a specific index."""
+        underlined_widget: UnderlinedWidget = self._get_item_widget(index, self._lib)
+        tag_widget = underlined_widget.widget
+        assert isinstance(tag_widget, TagWidget)
+        tag_widget.has_remove = False
+        tag_widget.set_tag(item)
+        underlined_widget.setHidden(item is None)
+        opacity_effect = QGraphicsOpacityEffect(self)
+        opacity_effect.setOpacity(0.3)
+        if item and item.id in self.added:
+            tag_widget.setGraphicsEffect(opacity_effect)
+        else:
+            tag_widget.setGraphicsEffect(None)  # pyright: ignore[reportArgumentType]
+
+        if item is None:
+            return
+
+        # Select first item
+        underlined_widget.toggle_underline(index != 0)
+
+        # Disconnect previous callbacks
+        with catch_warnings(record=True):
+            tag_widget.on_edit.disconnect()
+            tag_widget.bg_button.clicked.disconnect()
+            tag_widget.search_for_tag_action.triggered.disconnect()
+
+        # Connect callbacks
+        tag_widget.on_edit.connect(lambda edit_tag=item: self._on_item_edit(edit_tag))
+        tag_widget.bg_button.clicked.connect(
+            lambda checked=False, tag=item: self._on_item_chosen(tag)
+        )
+        tag_widget.search_for_tag_action.triggered.connect(
+            lambda checked=False, tag_id=item.id: self.search_for_tag.emit(tag_id)
+        )
+        tag_widget.search_for_tag_action.setEnabled(True)
+
+    @override
+    def _create_item_from_modal(self, edit_item_panel: ModalContent) -> None:
+        if isinstance(edit_item_panel, BuildTagPanel):
+            tag: Tag = edit_item_panel.build_tag()
+            self._lib.add_tag(
+                tag, parent_ids=edit_item_panel.parent_ids, aliases=edit_item_panel.aliases
+            )
+            self._on_item_chosen(tag)
+
+        edit_item_panel.hide()
+        self._on_search_query_changed(self.layout().search_field.text())
+
+    @override
+    def _edit_item(self, edit_item_panel: ModalContent) -> None:
+        if not isinstance(edit_item_panel, BuildTagPanel):
+            return
+
+        self._lib.update_tag(
+            tag=edit_item_panel.build_tag(),
+            parent_ids=edit_item_panel.parent_ids,
+            aliases=edit_item_panel.aliases,
+        )
+        self._update_items(self.layout().search_field.text())
+
+    @override
+    def _get_item_widget(self, index: int, library: Library | None) -> UnderlinedWidget:
+        """Gets the item widget at a specific index."""
+        # Create any new item widgets needed up to the given index
+        if self.layout().content_layout.count() <= index:
+            while self.layout().content_layout.count() <= index:
+                tag_widget = TagWidget(tag=None, has_edit=True, has_remove=True, library=library)
+                tag_widget.on_remove.connect(self._update_items)
+                widget = UnderlinedWidget(tag_widget)
+                widget.setHidden(True)
+                self.layout().content_layout.addWidget(widget)
+
+        widget_: QWidget = self.layout().content_layout.itemAt(index).widget()
+        assert isinstance(widget_, UnderlinedWidget)
+        return widget_
@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+from typing import override
+
+from PySide6.QtWidgets import QWidget
+
+from tagstudio.qt.views.underlined_widget_view import UnderlinedWidgetView
+
+
+class UnderlinedWidget(QWidget):
+    def __init__(self, widget: QWidget) -> None:
+        super().__init__()
+        self.setLayout(UnderlinedWidgetView(widget))
+
+    def toggle_underline(self, is_hidden: bool) -> None:
+        self.layout().underline.setHidden(is_hidden)
+
+    @property
+    def widget(self) -> QWidget:
+        return self.layout().itemAt(0).widget()
+
+    @override
+    def layout(self) -> UnderlinedWidgetView:
+        return super().layout()  # pyright: ignore[reportReturnType]
@@ -74,6 +74,9 @@ class GlobalSettings(BaseModel):
    infinite_scroll: bool = Field(default=True)
    show_filepath: ShowFilepathOption = Field(default=ShowFilepathOption.DEFAULT)
    tag_click_action: TagClickActionOption = Field(default=TagClickActionOption.DEFAULT)
+    edit_tag_on_create: bool = Field(default=False)
+    edit_field_on_add: bool = Field(default=True)
+    keep_suggest_boxes_open: bool = Field(default=True)
    theme: Theme = Field(default=Theme.SYSTEM)
    splash: Splash = Field(default=Splash.DEFAULT)
    windows_start_command: bool = Field(default=False)
@@ -6,7 +6,7 @@ from pathlib import Path

 import ffmpeg

-from tagstudio.qt.previews.vendored.probe import probe
+from tagstudio.renderers.vendored.probe import probe


 def is_readable_video(filepath: Path | str):
@@ -23,11 +23,7 @@ def is_readable_video(filepath: Path | str):
            return False
        for stream in result["streams"]:
            # DRM check
-            if stream.get("codec_tag_string") in [
-                "drma",
-                "drms",
-                "drmi",
-            ]:
+            if stream.get("codec_tag_string") in ["drma", "drms", "drmi"]:
                return False
    except ffmpeg.Error:
        return False
@@ -19,13 +19,14 @@ from PySide6.QtWidgets import (
 )

 from tagstudio.core.constants import (
+    BUILD_TYPE,
    COPYRIGHT,
    DISCORD_URL,
    DOCS_URL,
    GITHUB_REPO_URL,
    VERSION,
-    VERSION_BRANCH,
 )
+from tagstudio.core.library.alchemy.constants import DB_VERSION
 from tagstudio.core.ts_core import TagStudioCore
 from tagstudio.core.utils.ffmpeg_status import FfmpegStatus, FfprobeStatus
 from tagstudio.core.utils.ripgrep_status import RipgrepStatus
@@ -42,7 +43,12 @@ from tagstudio.qt.views.stylesheets.stylesheets import form_content_style, heade
 class AboutModal(QWidget):
    """Modal window showing information about the TagStudio application."""

-    VERSION_STR: str = f"{Translations['about.version']} {VERSION} {(' (' + VERSION_BRANCH + ')') if VERSION_BRANCH else ''}"  # noqa: E501
+    VERSION_STR: str = " ".join(
+        [
+            f"{Translations['about.version']}",
+            f"{VERSION} {(' (' + Translations[BUILD_TYPE] + ')') if BUILD_TYPE else ''}",
+        ]
+    )

    def __init__(self, config_path: Path | str):
        super().__init__()
@@ -104,22 +110,28 @@ class AboutModal(QWidget):
        self.system_info_layout.setSpacing(4)
        self.system_info_layout.setLabelAlignment(Qt.AlignmentFlag.AlignRight)

-        # Version
-        version_title = QLabel(Translations["about.version"])
-        latest_version = unwrap(TagStudioCore.get_most_recent_release_version(), "0.0.0")
-        version_content_style = form_content_style()
-        if not is_version_outdated(VERSION, latest_version):
-            version_content = QLabel(f"{VERSION}")
+        # TagStudio Version
+        ts_version_title = QLabel(Translations["about.version"])
+        latest_ts_version = unwrap(TagStudioCore.get_most_recent_release_version(), "0.0.0")
+        ts_version_content_style = form_content_style()
+        if not is_version_outdated(VERSION, latest_ts_version):
+            ts_version_content = QLabel(f"{VERSION}")
        else:
-            version_content = QLabel(
+            ts_version_content = QLabel(
                Translations.format(
-                    "about.version.latest", built_version=VERSION, latest_version=latest_version
+                    "about.version.latest", built_version=VERSION, latest_version=latest_ts_version
                )
            )
-            version_content_style += f"color: {red};"
-        version_content.setStyleSheet(version_content_style)
-        self.system_info_layout.addRow(version_title, version_content)
-        version_content.setMaximumWidth(version_content.sizeHint().width())
+            ts_version_content_style += f"color: {red};"
+        ts_version_content.setStyleSheet(ts_version_content_style)
+        self.system_info_layout.addRow(ts_version_title, ts_version_content)
+        ts_version_content.setMaximumWidth(ts_version_content.sizeHint().width())
+
+        # Library DB Version
+        db_version_title = QLabel(Translations["about.library_version"])
+        db_version_content = QLabel(f"{DB_VERSION}")
+        db_version_content.setStyleSheet(form_content_style())
+        self.system_info_layout.addRow(db_version_title, db_version_content)

        # Config Path
        config_path_title = QLabel(f"{Translations['about.config_path']}")
@@ -196,8 +208,7 @@ class AboutModal(QWidget):

        # ripgrep Status
        ripgrep_path_title = QLabel("ripgrep")  # NOTE: Don't localize
-        ripgrep_path_content = ClickableLabel()
-        ripgrep_path_content.setText(f"{ripgrep_status}")  # TODO: Pass in constructor after #1386
+        ripgrep_path_content = ClickableLabel(f"{ripgrep_status}")
        ripgrep_location = RipgrepStatus.which()
        if ripgrep_location:
            ripgrep_path_content.clicked.connect(
@@ -1,98 +0,0 @@
-# SPDX-FileCopyrightText: (c) TagStudio Contributors
-# SPDX-License-Identifier: GPL-3.0-only
-
-
-from typing import override
-
-import structlog
-from PySide6 import QtCore, QtGui
-from PySide6.QtCore import Qt, Signal
-from PySide6.QtWidgets import (
-    QHBoxLayout,
-    QLabel,
-    QListWidget,
-    QListWidgetItem,
-    QPushButton,
-    QVBoxLayout,
-    QWidget,
-)
-
-from tagstudio.core.library.alchemy.library import Library
-from tagstudio.qt.translations import FIELD_TYPE_KEYS, Translations
-from tagstudio.qt.views.stylesheets.stylesheets import header
-
-logger = structlog.get_logger(__name__)
-
-
-# NOTE: This class doesn't inherit from PanelWidget? Seems like it predates that system?
-class AddFieldModal(QWidget):
-    done = Signal(list)
-
-    def __init__(self, library: Library):
-        # [Done]
-        # - OR -
-        # [Cancel] [Save]
-        super().__init__()
-        self.lib = library
-        self.setWindowTitle(Translations["field.add"])
-        self.setWindowModality(Qt.WindowModality.ApplicationModal)
-        self.setMinimumSize(400, 300)
-        self.root_layout = QVBoxLayout(self)
-        self.root_layout.setContentsMargins(6, 6, 6, 6)
-
-        self.title_widget = QLabel(header(Translations["field.add"], 3))
-        self.title_widget.setObjectName("fieldTitle")
-        self.title_widget.setWordWrap(True)
-        self.title_widget.setAlignment(Qt.AlignmentFlag.AlignCenter)
-
-        self.list_widget = QListWidget()
-
-        self.button_container = QWidget()
-        self.button_layout = QHBoxLayout(self.button_container)
-        self.button_layout.setContentsMargins(6, 6, 6, 6)
-        self.button_layout.addStretch(1)
-
-        self.cancel_button = QPushButton(Translations["generic.cancel"])
-        self.cancel_button.clicked.connect(self.hide)
-        self.button_layout.addWidget(self.cancel_button)
-
-        self.save_button = QPushButton(Translations["generic.add"])
-        self.save_button.setDefault(True)
-        self.save_button.clicked.connect(self.hide)
-        self.save_button.clicked.connect(
-            lambda: (
-                # get userData for each selected item
-                self.done.emit(self.list_widget.selectedItems())
-            )
-        )
-        self.button_layout.addWidget(self.save_button)
-
-        self.root_layout.addWidget(self.title_widget)
-        self.root_layout.addWidget(self.list_widget)
-        self.root_layout.addStretch(1)
-        self.root_layout.addWidget(self.button_container)
-
-    @override
-    def show(self):
-        self.list_widget.clear()
-        for field_template in self.lib.field_templates:
-            field_name_key: str = FIELD_TYPE_KEYS.get(
-                field_template.class_name, "field_type.unknown"
-            )
-            item = QListWidgetItem(f"{field_template.name} ({Translations[field_name_key]})")
-            item.setData(Qt.ItemDataRole.UserRole, field_template)
-            self.list_widget.addItem(item)
-        self.list_widget.setFocus()
-        self.list_widget.setCurrentRow(0)
-
-        super().show()
-
-    @override
-    def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:  # noqa N802
-        if event.key() == QtCore.Qt.Key.Key_Escape:
-            self.cancel_button.click()
-        elif event.key() in (QtCore.Qt.Key.Key_Enter, QtCore.Qt.Key.Key_Return):
-            self.save_button.click()
-        else:  # Other key presses
-            pass
-        return super().keyPressEvent(event)
@@ -24,10 +24,10 @@ from tagstudio.core.library.alchemy.enums import TagColorEnum
 from tagstudio.core.library.alchemy.library import Library, slugify
 from tagstudio.core.library.alchemy.models import TagColorGroup
 from tagstudio.core.utils.types import unwrap
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.mixed.tag_color_preview import TagColorPreview
 from tagstudio.qt.models.palette import ColorType, get_tag_color
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelWidget
 from tagstudio.qt.views.stylesheets.stylesheets import (
    checkbox_style,
    line_edit_style,
@@ -37,7 +37,7 @@ from tagstudio.qt.views.stylesheets.stylesheets import (
 logger = structlog.get_logger(__name__)


-class BuildColorPanel(PanelWidget):
+class BuildColorPanel(ModalContent):
    on_edit = Signal(TagColorGroup)

    def __init__(self, library: Library, color_group: TagColorGroup):
@@ -254,8 +254,8 @@ class BuildColorPanel(PanelWidget):
        self.slug_field.setText(slug)
        self.update_preview_text()

-        if self.panel_save_button is not None:
-            self.panel_save_button.setDisabled(is_name_empty)
+        if self.save_button is not None:
+            self.save_button.setDisabled(is_name_empty)

    def build_color(self) -> tuple[TagColorGroup, TagColorGroup]:
        name = self.name_field.text()
@@ -13,14 +13,14 @@ from PySide6.QtWidgets import QLabel, QLineEdit, QVBoxLayout, QWidget
 from tagstudio.core.constants import RESERVED_NAMESPACE_PREFIX
 from tagstudio.core.library.alchemy.library import Library, ReservedNamespaceError, slugify
 from tagstudio.core.library.alchemy.models import Namespace
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelWidget
 from tagstudio.qt.views.stylesheets.stylesheets import line_edit_style

 logger = structlog.get_logger(__name__)


-class BuildNamespacePanel(PanelWidget):
+class BuildNamespacePanel(ModalContent):
    on_edit = Signal(Namespace)

    def __init__(self, library: Library, namespace: Namespace | None = None):
@@ -118,8 +118,8 @@ class BuildNamespacePanel(PanelWidget):

        self.slug_field.setText(slug)

-        if self.panel_save_button is not None:
-            self.panel_save_button.setDisabled(is_name_empty)
+        if self.save_button is not None:
+            self.save_button.setDisabled(is_name_empty)

    def no_collide(self, slug: str) -> str:
        """Return a slug name that's verified not to collide with other known namespace slugs."""
@@ -28,12 +28,14 @@ from PySide6.QtWidgets import (
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import Tag, TagAlias, TagColorGroup
 from tagstudio.core.utils.types import unwrap
-from tagstudio.qt.controllers.tag_search_panel_controller import TagSearchModal
+from tagstudio.qt.controllers.modal import Modal
+from tagstudio.qt.controllers.modal_content import ModalContent
+from tagstudio.qt.controllers.tag_search_panel_controller import TagSearchPanel
 from tagstudio.qt.mixed.tag_color_preview import TagColorPreview
 from tagstudio.qt.mixed.tag_color_selection import TagColorSelection
 from tagstudio.qt.mixed.tag_widget import TagWidget
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelModal, PanelWidget
+from tagstudio.qt.views.search_panel_view import SearchPanelView
 from tagstudio.qt.views.stylesheets.stylesheets import (
    checkbox_style,
    colored_radio_button_style,
@@ -73,12 +75,12 @@ class CustomTableItem(QLineEdit):
            super().keyPressEvent(arg__1)


-class BuildTagPanel(PanelWidget):
+class BuildTagPanel(ModalContent):
    on_edit = Signal(Tag)

    def __init__(self, library: Library, tag: Tag | None = None) -> None:
        super().__init__()
-        self.lib = library
+        self._lib = library
        self.tag: Tag  # NOTE: This gets set at the end of the init.
        self.tag_color_namespace: str | None
        self.tag_color_slug: str | None
@@ -153,7 +155,6 @@ class BuildTagPanel(PanelWidget):

        self.parent_tags_title = QLabel(Translations["tag.parent_tags"])
        self.parent_tags_layout.addWidget(self.parent_tags_title)
-
        self.scroll_contents = QWidget()
        self.parent_tags_scroll_layout = QVBoxLayout(self.scroll_contents)
        self.parent_tags_scroll_layout.setContentsMargins(6, 6, 6, 0)
@@ -176,10 +177,11 @@ class BuildTagPanel(PanelWidget):
        if tag is not None:
            exclude_ids.append(tag.id)

-        self.add_tag_modal = TagSearchModal(
-            self.lib, title=Translations["tag.add.plural"], exclude=exclude_ids
-        )
-        self.add_tag_modal.tsp.item_chosen.connect(lambda x: self._add_parent_tag_callback(x))
+        tsp_view = SearchPanelView(placeholder_text=Translations["home.search_tags"])
+        tsp = TagSearchPanel(self._lib, exclude=exclude_ids, view=tsp_view)
+        self.add_tag_modal = Modal(tsp, title=Translations["tag.add.plural"])
+        tsp.item_chosen.connect(lambda x: self._add_parent_tag_callback(x))
+
        self.parent_tags_add_button.clicked.connect(self.add_tag_modal.show)

        # Color ----------------------------------------------------------------
@@ -194,14 +196,14 @@ class BuildTagPanel(PanelWidget):
        self.color_button: TagColorPreview
        try:
            assert tag is not None
-            self.color_button = TagColorPreview(self.lib, tag.color)
+            self.color_button = TagColorPreview(self._lib, tag.color)
        except Exception as e:
            # TODO: Investigate why this happens during tests
            logger.error("[BuildTag] Could not access Tag member attributes", error=e)
-            self.color_button = TagColorPreview(self.lib, None)
-        self.tag_color_selection = TagColorSelection(self.lib)
+            self.color_button = TagColorPreview(self._lib, None)
+        self.tag_color_selection = TagColorSelection(self._lib)
        chose_tag_color_title = Translations["tag.choose_color"]
-        self.choose_color_modal = PanelModal(
+        self.choose_color_modal = Modal(
            self.tag_color_selection, chose_tag_color_title, chose_tag_color_title
        )
        self.choose_color_modal.done.connect(
@@ -325,7 +327,7 @@ class BuildTagPanel(PanelWidget):
        next_tab: QWidget = last_tab

        for parent_id in self.parent_ids:
-            tag = self.lib.get_tag(parent_id)
+            tag = self._lib.get_tag(parent_id)
            if not tag:
                continue
            is_disam = parent_id == self.disambiguation_id
@@ -363,7 +365,7 @@ class BuildTagPanel(PanelWidget):
            text_color = get_tag_text_color(primary_color, highlight_color)

        def update_parent_tag_callback(build_tag_panel: BuildTagPanel):
-            self.lib.update_tag(
+            self._lib.update_tag(
                build_tag_panel.build_tag(),
                parent_ids=set(build_tag_panel.parent_ids),
                aliases=set(build_tag_panel.aliases),
@@ -371,10 +373,10 @@ class BuildTagPanel(PanelWidget):
            self.set_parent_tags()

        def on_parent_tag_edit(tag: Tag) -> None:
-            build_tag_panel = BuildTagPanel(self.lib, tag=tag)
-            edit_modal = PanelModal(
+            build_tag_panel = BuildTagPanel(self._lib, tag=tag)
+            edit_modal = Modal(
                build_tag_panel,
-                self.lib.tag_display_name(tag),
+                self._lib.tag_display_name(tag),
                "Edit Tag",
                is_savable=True,
            )
@@ -382,7 +384,7 @@ class BuildTagPanel(PanelWidget):
            edit_modal.show()

        # Add Tag Widget
-        tag_widget = TagWidget(tag, library=self.lib, has_edit=True, has_remove=True)
+        tag_widget = TagWidget(tag, library=self._lib, has_edit=True, has_remove=True)
        tag_widget.on_remove.connect(lambda t=parent_id: self._remove_parent_tag_callback(t))
        tag_widget.on_edit.connect(partial(on_parent_tag_edit, tag))

@@ -422,7 +424,7 @@ class BuildTagPanel(PanelWidget):
        while self.aliases_table.rowCount() > 0:
            self.aliases_table.removeRow(0)

-        last: QWidget | None = self.panel_save_button
+        last: QWidget | None = self.save_button
        aliases = list(self.aliases)
        alias_names = [a.name for a in aliases]
        sorted_aliases = sorted(aliases, key=lambda x: alias_names[aliases.index(x)])
@@ -493,8 +495,8 @@ class BuildTagPanel(PanelWidget):
        is_empty = not self.name_field.text().strip()
        self.name_field.setStyleSheet(line_edit_style() if is_empty else "")

-        if self.panel_save_button is not None:
-            self.panel_save_button.setDisabled(is_empty)
+        if self.save_button is not None:
+            self.save_button.setDisabled(is_empty)

    def build_tag(self) -> Tag:
        tag = self.tag
@@ -515,8 +517,8 @@ class BuildTagPanel(PanelWidget):
        self.setTabOrder(self.shorthand_field, self.aliases_add_button)
        self.setTabOrder(self.aliases_add_button, self.parent_tags_add_button)
        self.setTabOrder(self.parent_tags_add_button, self.color_button)
-        self.setTabOrder(self.color_button, unwrap(self.panel_cancel_button))
-        self.setTabOrder(unwrap(self.panel_cancel_button), unwrap(self.panel_save_button))
-        self.setTabOrder(unwrap(self.panel_save_button), self.aliases_table.cellWidget(0, 1))
+        self.setTabOrder(self.color_button, unwrap(self.cancel_button))
+        self.setTabOrder(unwrap(self.cancel_button), unwrap(self.save_button))
+        self.setTabOrder(unwrap(self.save_button), self.aliases_table.cellWidget(0, 1))
        self.name_field.selectAll()
        self.name_field.setFocus()
@@ -1,133 +0,0 @@
-# SPDX-FileCopyrightText: (c) TagStudio Contributors
-# SPDX-License-Identifier: GPL-3.0-only
-
-
-import math
-from pathlib import Path
-
-import cv2
-import structlog
-from PIL import Image, ImageChops, UnidentifiedImageError
-from PIL.Image import DecompressionBombError
-from PySide6.QtCore import QObject, Signal
-
-from tagstudio.core.library.alchemy.library import Library
-from tagstudio.core.media_types import MediaCategories
-from tagstudio.core.utils.types import unwrap
-from tagstudio.qt.helpers.file_tester import is_readable_video
-
-logger = structlog.get_logger(__name__)
-
-
-class CollageIconRenderer(QObject):
-    rendered = Signal(Image.Image)
-    done = Signal()
-
-    def __init__(self, library: Library):
-        QObject.__init__(self)
-        self.lib = library
-
-    def render(
-        self,
-        entry_id: int,
-        size: tuple[int, int],
-        data_tint_mode: bool,
-        data_only_mode: bool,
-        keep_aspect: bool,
-    ):
-        entry = unwrap(self.lib.get_entry(entry_id))
-        filepath = unwrap(self.lib.library_dir) / entry.path
-        color: str = ""
-
-        try:
-            if data_tint_mode or data_only_mode:
-                color = "#28bb48" if entry.tags else "#e22c3c"
-
-                if data_only_mode:
-                    pic = Image.new("RGB", size, color)
-                    # collage.paste(pic, (y*thumb_size, x*thumb_size))
-                    self.rendered.emit(pic)
-            if not data_only_mode:
-                logger.info(
-                    "Combining icons",
-                    entry=entry,
-                    color=self.get_file_color(filepath.suffix.lower()),
-                )
-
-                ext: str = filepath.suffix.lower()
-                if MediaCategories.is_ext_in_category(ext, MediaCategories.IMAGE_TYPES):
-                    try:
-                        with Image.open(filepath) as pic:
-                            if keep_aspect:
-                                pic.thumbnail(size)
-                            else:
-                                pic = pic.resize(size)
-                            if data_tint_mode and color:
-                                pic = pic.convert(mode="RGB")
-                                pic = ImageChops.hard_light(pic, Image.new("RGB", size, color))
-                            self.rendered.emit(pic)
-                    except DecompressionBombError as e:
-                        logger.info(f"[ERROR] One of the images was too big ({e})")
-                elif MediaCategories.is_ext_in_category(
-                    ext, MediaCategories.VIDEO_TYPES
-                ) and is_readable_video(filepath):
-                    video = cv2.VideoCapture(str(filepath), cv2.CAP_FFMPEG)
-                    video.set(
-                        cv2.CAP_PROP_POS_FRAMES,
-                        (video.get(cv2.CAP_PROP_FRAME_COUNT) // 2),
-                    )
-                    success, frame = video.read()
-                    # NOTE: Depending on the video format, compression, and
-                    # frame count, seeking halfway does not work and the thumb
-                    # must be pulled from the earliest available frame.
-                    max_frame_seek: int = 10
-                    for i in range(
-                        0,
-                        min(
-                            max_frame_seek,
-                            math.floor(video.get(cv2.CAP_PROP_FRAME_COUNT)),
-                        ),
-                    ):
-                        success, frame = video.read()
-                        if not success:
-                            video.set(cv2.CAP_PROP_POS_FRAMES, i)
-                        else:
-                            break
-                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                    with Image.fromarray(frame, mode="RGB") as pic:
-                        if keep_aspect:
-                            pic.thumbnail(size)
-                        else:
-                            pic = pic.resize(size)
-                        if data_tint_mode and color:
-                            pic = ImageChops.hard_light(pic, Image.new("RGB", size, color))
-                        self.rendered.emit(pic)
-        except (UnidentifiedImageError, FileNotFoundError):
-            logger.error("Couldn't read entry", entry=entry.path)
-            with Image.open(
-                str(Path(__file__).parents[1] / "resources/qt/images/thumb_broken_512.png")
-            ) as pic:
-                pic.thumbnail(size)
-                if data_tint_mode and color:
-                    pic = pic.convert(mode="RGB")
-                    pic = ImageChops.hard_light(pic, Image.new("RGB", size, color))
-                # collage.paste(pic, (y*thumb_size, x*thumb_size))
-                self.rendered.emit(pic)
-        except KeyboardInterrupt:
-            logger.info("Collage operation cancelled.")
-        except Exception:
-            logger.exception("render failed", entry=entry.path)
-
-        self.done.emit()
-
-    def get_file_color(self, ext: str):
-        if ext.lower() == "gif":
-            return "\033[93m"
-        if MediaCategories.is_ext_in_category(ext, MediaCategories.IMAGE_TYPES):
-            return "\033[37m"
-        elif MediaCategories.is_ext_in_category(ext, MediaCategories.VIDEO_TYPES):
-            return "\033[96m"
-        elif MediaCategories.is_ext_in_category(ext, MediaCategories.PLAINTEXT_TYPES):
-            return "\033[92m"
-        else:
-            return "\033[97m"
@@ -12,12 +12,12 @@ from PySide6.QtWidgets import QMessageBox, QPushButton
 from tagstudio.core.constants import RESERVED_NAMESPACE_PREFIX
 from tagstudio.core.library.alchemy.models import TagColorGroup
 from tagstudio.core.utils.types import unwrap
+from tagstudio.qt.controllers.modal import Modal
 from tagstudio.qt.mixed.build_color import BuildColorPanel
 from tagstudio.qt.mixed.field_widget import FieldWidget
 from tagstudio.qt.mixed.tag_color_label import TagColorLabel
 from tagstudio.qt.translations import Translations
 from tagstudio.qt.views.layouts.flow_layout import FlowLayout
-from tagstudio.qt.views.panel_modal import PanelModal
 from tagstudio.qt.views.stylesheets.stylesheets import add_button_style

 if typing.TYPE_CHECKING:
@@ -102,7 +102,7 @@ class ColorBoxWidget(FieldWidget):
    def edit_color(self, color_group: TagColorGroup):
        build_color_panel = BuildColorPanel(self.lib, color_group)

-        self.edit_modal = PanelModal(
+        self.edit_modal = Modal(
            build_color_panel,
            "Edit Color",
            is_savable=True,
@@ -9,7 +9,7 @@ from typing import cast, override
 from PySide6.QtCore import QDateTime
 from PySide6.QtWidgets import QDateTimeEdit, QLineEdit, QVBoxLayout

-from tagstudio.qt.views.panel_modal import PanelWidget
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.views.stylesheets.stylesheets import title_line_edit_style

 if typing.TYPE_CHECKING:
@@ -39,7 +39,7 @@ def qdtf2dtf(dtf: str) -> str:
    return out


-class DatetimePicker(PanelWidget):
+class DatetimePicker(ModalContent):
    def __init__(self, driver: "QtDriver", name: str, datetime: dt | str):
        super().__init__()
        self.setMinimumSize(300, 60)
@@ -9,8 +9,7 @@ from functools import partial
 from warnings import catch_warnings

 import structlog
-from PySide6.QtCore import Qt
-from PySide6.QtGui import QGuiApplication
+from PySide6.QtCore import Qt, Signal
 from PySide6.QtWidgets import (
    QFrame,
    QHBoxLayout,
@@ -21,7 +20,6 @@ from PySide6.QtWidgets import (
    QWidget,
 )

-from tagstudio.core.enums import Theme
 from tagstudio.core.library.alchemy.fields import (
    BaseField,
    BaseFieldTemplate,
@@ -32,12 +30,13 @@ from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import Entry, Tag
 from tagstudio.core.utils.types import unwrap
 from tagstudio.qt.controllers.edit_text_controller import EditText
+from tagstudio.qt.controllers.modal import Modal
 from tagstudio.qt.controllers.tag_box_controller import TagBoxWidget
 from tagstudio.qt.mixed.datetime_picker import DatetimePicker
 from tagstudio.qt.mixed.field_widget import FieldContainer
 from tagstudio.qt.mixed.text_field import TextContainerWidget
 from tagstudio.qt.translations import FIELD_TYPE_KEYS, Translations
-from tagstudio.qt.views.panel_modal import PanelModal
+from tagstudio.qt.views.stylesheets.stylesheets import inset_container_style

 if typing.TYPE_CHECKING:
    from tagstudio.qt.ts_qt import QtDriver
@@ -48,6 +47,8 @@ logger = structlog.get_logger(__name__)
 class FieldContainers(QWidget):
    """Widget for the tag and field containers displayed inside the Preview Panel."""

+    on_tags_update = Signal()
+
    def __init__(self, library: Library, driver: "QtDriver") -> None:
        super().__init__()

@@ -58,18 +59,12 @@ class FieldContainers(QWidget):
        self.common_fields: list = []
        self.mixed_fields: list = []
        self.cached_entries: list[Entry] = []
-        self.containers: list[FieldContainer] = []
-
-        self.panel_bg_color = (
-            Theme.COLOR_BG_DARK.value
-            if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
-            else Theme.COLOR_BG_LIGHT.value
-        )
+        self._containers: list[FieldContainer] = []

        self.scroll_layout = QVBoxLayout()
        self.scroll_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
        self.scroll_layout.setContentsMargins(3, 3, 3, 3)
-        self.scroll_layout.setSpacing(0)
+        self.scroll_layout.setSpacing(6)

        scroll_container: QWidget = QWidget()
        scroll_container.setObjectName("entryScrollContainer")
@@ -92,9 +87,7 @@ class FieldContainers(QWidget):
        # background and NOT the scroll container background, so that the
        # rounded corners are maintained when scrolling. I was unable to
        # find the right trick to only select that particular element.
-        self.scroll_area.setStyleSheet(
-            f"QWidget#entryScrollContainer{{background:{self.panel_bg_color};border-radius:6px;}}"
-        )
+        self.scroll_area.setStyleSheet(inset_container_style("entryScrollContainer"))
        self.scroll_area.setWidget(scroll_container)

        root_layout = QHBoxLayout(self)
@@ -137,8 +130,8 @@ class FieldContainers(QWidget):
            self.write_field_container(index, field, is_mixed=False)

        # Hide leftover container(s)
-        if len(self.containers) > container_len:
-            for i, c in enumerate(self.containers):
+        if len(self._containers) > container_len:
+            for i, c in enumerate(self._containers):
                if i > (container_len - 1):
                    c.setHidden(True)

@@ -157,7 +150,7 @@ class FieldContainers(QWidget):

    def hide_containers(self) -> None:
        """Hide all field and tag containers."""
-        for c in self.containers:
+        for c in self._containers:
            c.setHidden(True)

    def get_tag_categories(self, tags: set[Tag]) -> dict[Tag | None, set[Tag]]:
@@ -251,6 +244,27 @@ class FieldContainers(QWidget):
        )
        self.driver.add_tags_to_selected_callback(tag_ids)

+    def update_text_field_callback(
+        self, field: TextField, entry_id: int, content: dict[str, str | bool]
+    ) -> None:
+        """Callback called when a text field has updated data."""
+        self._update_text_field(
+            field, str(content["name"]), str(content["value"]), bool(content["is_multiline"])
+        )
+        self.update_from_entry(entry_id)
+
+    def update_datetime_field_callback(
+        self, field: DatetimeField, entry_id: int, content: dict[str, str]
+    ) -> None:
+        """Callback called when a datetime field has updated data."""
+        self.update_datetime_field(field, str(content["name"]), str(content["value"]))
+        self.update_from_entry(entry_id)
+
+    def remove_field_callback(self, field: BaseField, entry_id: int) -> None:
+        """Callback called when a field needs to be removed from an entry."""
+        self._remove_field(field)
+        self.update_from_entry(entry_id)
+
    def write_field_container(self, index: int, field: BaseField, is_mixed: bool = False) -> None:
        """Update/Create data for a field FieldContainer.

@@ -261,27 +275,6 @@ class FieldContainers(QWidget):
                If True, field is not present in all selected items.
        """

-        def update_text_field_callback(
-            field: TextField, entry_id: int, content: dict[str, str | bool]
-        ) -> None:
-            """Callback called when a text field has updated data."""
-            self._update_text_field(
-                field, str(content["name"]), str(content["value"]), bool(content["is_multiline"])
-            )
-            self.update_from_entry(entry_id)
-
-        def update_datetime_field_callback(
-            field: DatetimeField, entry_id: int, content: dict[str, str]
-        ) -> None:
-            """Callback called when a datetime field has updated data."""
-            self.update_datetime_field(field, str(content["name"]), str(content["value"]))
-            self.update_from_entry(entry_id)
-
-        def remove_field_callback(field: BaseField, entry_id: int) -> None:
-            """Callback called when a field needs to be removed from an entry."""
-            self._remove_field(field)
-            self.update_from_entry(entry_id)
-
        def write_text_container(
            container: FieldContainer, field: TextField, title: str, is_mixed: bool
        ):
@@ -298,21 +291,21 @@ class FieldContainers(QWidget):
            container.set_inner_widget(inner_widget)

            if not is_mixed:
-                edit_modal = PanelModal(
+                edit_modal = Modal(
                    EditText(field.name, field.value, field.is_multiline),
                    window_title=f"{Translations['field.edit']} ({Translations[field_name_key]})",
                    is_savable=True,
                    inline_title=False,
                )
                edit_modal.saved_data.connect(
-                    partial(update_text_field_callback, field, self.top_entry_id)
+                    partial(self.update_text_field_callback, field, self.top_entry_id)
                )

                container.set_edit_callback(edit_modal.show)
                container.set_remove_callback(
                    lambda: self.remove_message_box(
                        prompt=self.remove_field_prompt(title),
-                        callback=partial(remove_field_callback, field, self.top_entry_id),
+                        callback=partial(self.remove_field_callback, field, self.top_entry_id),
                    )
                )

@@ -336,21 +329,21 @@ class FieldContainers(QWidget):
            container.set_inner_widget(inner_widget)

            if not is_mixed:
-                edit_modal = PanelModal(
+                edit_modal = Modal(
                    DatetimePicker(self.driver, field.name, field.value or dt.now()),
                    window_title=f"{Translations['field.edit']} ({Translations[field_name_key]})",
                    is_savable=True,
                    inline_title=False,
                )
                edit_modal.saved_data.connect(
-                    partial(update_datetime_field_callback, field, self.top_entry_id)
+                    partial(self.update_datetime_field_callback, field, self.top_entry_id)
                )

                container.set_edit_callback(edit_modal.show)
                container.set_remove_callback(
                    lambda: self.remove_message_box(
                        prompt=self.remove_field_prompt(field.name),
-                        callback=partial(remove_field_callback, field, self.top_entry_id),
+                        callback=partial(self.remove_field_callback, field, self.top_entry_id),
                    )
                )

@@ -361,7 +354,7 @@ class FieldContainers(QWidget):
            container.set_remove_callback(
                lambda: self.remove_message_box(
                    prompt=self.remove_field_prompt(field.name),
-                    callback=partial(remove_field_callback, field, self.top_entry_id),
+                    callback=partial(self.remove_field_callback, field, self.top_entry_id),
                )
            )

@@ -373,12 +366,12 @@ class FieldContainers(QWidget):
        )

        # Create new containers if necessary
-        if len(self.containers) < (index + 1):
+        if len(self._containers) < (index + 1):
            container = FieldContainer()
-            self.containers.append(container)
+            self._containers.append(container)
            self.scroll_layout.addWidget(container)
        else:
-            container = self.containers[index]
+            container = self._containers[index]

        # Set field title
        field_name_key: str = FIELD_TYPE_KEYS.get(field.class_name, "field_type.unknown")
@@ -407,12 +400,12 @@ class FieldContainers(QWidget):
                If True, field is not present in all selected items.
        """
        logger.info("[FieldContainers][write_tag_container]", index=index)
-        if len(self.containers) < (index + 1):
+        if len(self._containers) < (index + 1):
            container = FieldContainer()
-            self.containers.append(container)
+            self._containers.append(container)
            self.scroll_layout.addWidget(container)
        else:
-            container = self.containers[index]
+            container = self._containers[index]

        container.set_title(Translations["entries.tags"] if not category_tag else category_tag.name)

@@ -430,7 +423,10 @@ class FieldContainers(QWidget):
            inner_widget.set_tags(tags)

            inner_widget.on_update.connect(
-                lambda: self.update_from_entry(self.cached_entries[0].id, update_badges=True)
+                lambda: (
+                    self.update_from_entry(self.cached_entries[0].id, update_badges=True),
+                    self.on_tags_update.emit(),
+                )
            )
        else:
            text = f"<i>{Translations['field.mixed_data']}</i>"
@@ -480,3 +476,13 @@ class FieldContainers(QWidget):
        result = remove_mb.exec_()
        if result == QMessageBox.ButtonRole.ActionRole.value:
            callback()
+
+    @property
+    def tags(self) -> list[int]:
+        if len(self.cached_entries) <= 0:
+            return []
+        entry = self.cached_entries[0]
+        entry_ = self.lib.get_entry_full(entry.id, with_fields=False)
+        if not entry_:
+            return []
+        return [tag.id for tag in entry_.tags]
@@ -34,7 +34,9 @@ class FieldContainer(QWidget):
        self.copy_callback: Callable[[], None] | None = None
        self.edit_callback: Callable[[], None] | None = None
        self.remove_callback: Callable[[], None] | None = None
-        button_size = 24
+        button_size = 22
+        icon_margins = 4
+        icon_size = button_size - icon_margins

        self.root_layout = QVBoxLayout(self)
        self.root_layout.setObjectName("baseLayout")
@@ -42,7 +44,7 @@ class FieldContainer(QWidget):

        self.inner_layout = QVBoxLayout()
        self.inner_layout.setObjectName("innerLayout")
-        self.inner_layout.setContentsMargins(6, 0, 6, 6)
+        self.inner_layout.setContentsMargins(3, 0, 0, 3)
        self.inner_layout.setSpacing(0)
        self.field_container = QWidget()
        self.field_container.setObjectName("fieldContainer")
@@ -82,7 +84,7 @@ class FieldContainer(QWidget):
        self.edit_button.setMaximumSize(button_size, button_size)
        self.edit_button.setFlat(True)
        self.edit_button.setIcon(QPixmap.fromImage(ImageQt.ImageQt(FieldContainer.edit_icon)))
-        self.edit_button.setIconSize(QSize(20, 20))
+        self.edit_button.setIconSize(QSize(icon_size, icon_size))
        self.edit_button.setCursor(Qt.CursorShape.PointingHandCursor)
        self.title_layout.addWidget(self.edit_button)
        self.edit_button.setHidden(True)
@@ -93,7 +95,7 @@ class FieldContainer(QWidget):
        self.remove_button.setMaximumSize(button_size, button_size)
        self.remove_button.setFlat(True)
        self.remove_button.setIcon(QPixmap.fromImage(ImageQt.ImageQt(FieldContainer.trash_icon)))
-        self.remove_button.setIconSize(QSize(20, 20))
+        self.remove_button.setIconSize(QSize(icon_size, icon_size))
        self.remove_button.setCursor(Qt.CursorShape.PointingHandCursor)
        self.title_layout.addWidget(self.remove_button)
        self.remove_button.setHidden(True)
@@ -7,7 +7,6 @@ import platform
 import typing
 from dataclasses import dataclass
 from datetime import datetime as dt
-from datetime import timedelta
 from pathlib import Path

 import structlog
@@ -20,6 +19,7 @@ from tagstudio.core.enums import ShowFilepathOption
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.ignore import Ignore
 from tagstudio.core.media_types import MediaCategories
+from tagstudio.core.utils.str_formatting import format_duration
 from tagstudio.core.utils.types import unwrap
 from tagstudio.qt.models.palette import ColorType, UiColor, get_ui_color
 from tagstudio.qt.translations import Translations
@@ -224,15 +224,7 @@ class FileAttributes(QWidget):

            if stats.duration is not None:
                stats_label_text = add_newline(stats_label_text)
-                try:
-                    dur_str = str(timedelta(seconds=float(stats.duration)))[:-7]
-                    if dur_str.startswith("0:"):
-                        dur_str = dur_str[2:]
-                    if dur_str.startswith("0"):
-                        dur_str = dur_str[1:]
-                except OverflowError:
-                    dur_str = "-:--"
-                stats_label_text += f"{dur_str}"
+                stats_label_text += format_duration(stats.duration)

            if font_family:
                stats_label_text = add_newline(stats_label_text)
@@ -500,7 +500,7 @@ class ItemThumb(FlowWidget):
    ):
        selected = self.driver._selected
        if len(selected) == 1 and entry_id in selected:
-            self.driver.main_window.preview_panel.field_containers_widget.update_toggled_tag(
+            self.driver.main_window.preview_panel.containers.update_toggled_tag(
                tag_id, toggle_value
            )

@@ -395,14 +395,15 @@ class JsonMigrationModal(QObject):
            # Convert JSON Library to SQLite
            yield Translations["json_migration.creating_database_tables"]
            self.sql_lib = SqliteLibrary()
-            self.temp_path: Path = (
-                self.json_lib.library_dir / TS_FOLDER_NAME / "migration_ts_library.sqlite"
-            )
+            temp_filename = "migration_ts_library.sqlite"
+            self.temp_path: Path = self.json_lib.library_dir / TS_FOLDER_NAME / temp_filename
            if self.temp_path.exists():
                logger.info('Temporary migration file "temp_path" already exists. Removing...')
                self.temp_path.unlink()
-            self.sql_lib.open_sqlite_library(
-                self.json_lib.library_dir, is_new=True, storage_path=str(self.temp_path)
+            self.sql_lib.create_sqlite_library(
+                self.json_lib.library_dir,
+                in_memory=False,
+                sql_filename=temp_filename,
            )
            yield Translations.format(
                "json_migration.migrating_files_entries", entries=len(self.json_lib.entries)
@@ -20,6 +20,8 @@ from PySide6.QtWidgets import (
 )

 from tagstudio.core.enums import ShowFilepathOption, TagClickActionOption
+from tagstudio.qt.controllers.modal import Modal
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.global_settings import (
    DEFAULT_CACHED_THUMB_RES,
    DEFAULT_THUMB_CACHE_SIZE,
@@ -30,7 +32,6 @@ from tagstudio.qt.global_settings import (
    Theme,
 )
 from tagstudio.qt.translations import DEFAULT_TRANSLATION, LANGUAGES, Translations
-from tagstudio.qt.views.panel_modal import PanelModal, PanelWidget

 if TYPE_CHECKING:
    from tagstudio.qt.ts_qt import QtDriver
@@ -38,7 +39,7 @@ if TYPE_CHECKING:
 logger = structlog.get_logger(__name__)


-class SettingsPanel(PanelWidget):
+class SettingsPanel(ModalContent):
    driver: "QtDriver"

    filepath_option_map: dict[ShowFilepathOption, str] = {
@@ -216,6 +217,29 @@ class SettingsPanel(PanelWidget):
            Translations["settings.tag_click_action.label"], self.tag_click_action_combobox
        )

+        # Open Edit Window When Creating a Tag
+        self.edit_tag_on_create_checkbox = QCheckBox()
+        self.edit_tag_on_create_checkbox.setChecked(self.driver.settings.edit_tag_on_create)
+        form_layout.addRow(
+            Translations["settings.edit_tag_on_create"], self.edit_tag_on_create_checkbox
+        )
+
+        # Open Edit Window When Adding a Field
+        self.edit_field_on_add_checkbox = QCheckBox()
+        self.edit_field_on_add_checkbox.setChecked(self.driver.settings.edit_field_on_add)
+        form_layout.addRow(
+            Translations["settings.edit_field_on_add"], self.edit_field_on_add_checkbox
+        )
+
+        # Keep Tag/Field Suggest Boxes Open After Adding Items
+        self.keep_suggest_boxes_open_checkbox = QCheckBox()
+        self.keep_suggest_boxes_open_checkbox.setChecked(
+            self.driver.settings.keep_suggest_boxes_open
+        )
+        form_layout.addRow(
+            Translations["settings.keep_suggest_boxes_open"], self.keep_suggest_boxes_open_checkbox
+        )
+
    # TODO: Implement Library Settings
    def __build_library_settings(self):  # pyright: ignore[reportUnusedFunction]
        form_layout = QFormLayout(self.library_settings_container)
@@ -366,6 +390,9 @@ class SettingsPanel(PanelWidget):
            "show_filepath": self.filepath_combobox.currentData(),
            "theme": self.theme_combobox.currentData(),
            "tag_click_action": self.tag_click_action_combobox.currentData(),
+            "edit_tag_on_create": self.edit_tag_on_create_checkbox.isChecked(),
+            "edit_field_on_add": self.edit_field_on_add_checkbox.isChecked(),
+            "keep_suggest_boxes_open": self.keep_suggest_boxes_open_checkbox.isChecked(),
            "date_format": self.dateformat_combobox.currentData(),
            "hour_format": self.hourformat_checkbox.isChecked(),
            "zero_padding": self.zeropadding_checkbox.isChecked(),
@@ -388,6 +415,9 @@ class SettingsPanel(PanelWidget):
        driver.settings.show_filepath = settings["show_filepath"]
        driver.settings.theme = settings["theme"]
        driver.settings.tag_click_action = settings["tag_click_action"]
+        driver.settings.edit_tag_on_create = settings["edit_tag_on_create"]
+        driver.settings.edit_field_on_add = settings["edit_field_on_add"]
+        driver.settings.keep_suggest_boxes_open = settings["keep_suggest_boxes_open"]
        driver.settings.date_format = settings["date_format"]
        driver.settings.hour_format = settings["hour_format"]
        driver.settings.zero_padding = settings["zero_padding"]
@@ -409,15 +439,15 @@ class SettingsPanel(PanelWidget):
        )

    @classmethod
-    def build_modal(cls, driver: "QtDriver") -> PanelModal:
+    def build_modal(cls, driver: "QtDriver") -> Modal:
        settings_panel = cls(driver)

-        modal = PanelModal(
-            widget=settings_panel,
+        modal = Modal(
+            content_widget=settings_panel,
            window_title=Translations["settings.title"],
            is_savable=True,
        )
        modal.saved.connect(lambda: settings_panel.update_settings(driver))
-        modal.title_widget.setVisible(False)
+        modal.layout().title_label.setVisible(False)

        return modal
@@ -23,11 +23,11 @@ from PySide6.QtWidgets import (

 from tagstudio.core.constants import RESERVED_NAMESPACE_PREFIX
 from tagstudio.core.enums import Theme
+from tagstudio.qt.controllers.modal import Modal
 from tagstudio.qt.mixed.build_namespace import BuildNamespacePanel
 from tagstudio.qt.mixed.color_box import ColorBoxWidget
 from tagstudio.qt.mixed.field_widget import FieldContainer
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelModal
 from tagstudio.qt.views.stylesheets.stylesheets import header

 logger = structlog.get_logger(__name__)
@@ -38,7 +38,7 @@ if TYPE_CHECKING:


 class TagColorManager(QWidget):
-    create_namespace_modal: PanelModal | None = None
+    create_namespace_modal: Modal | None = None

    def __init__(
        self,
@@ -68,7 +68,7 @@ class TagColorManager(QWidget):
        self.scroll_layout = QVBoxLayout()
        self.scroll_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
        self.scroll_layout.setContentsMargins(3, 3, 3, 3)
-        self.scroll_layout.setSpacing(0)
+        self.scroll_layout.setSpacing(6)

        scroll_container: QWidget = QWidget()
        scroll_container.setObjectName("entryScrollContainer")
@@ -125,7 +125,7 @@ class TagColorManager(QWidget):
                        self.setup_color_groups(),
                        ()
                        if len(self.driver.selected) < 1
-                        else self.driver.main_window.preview_panel.field_containers_widget.update_from_entry(  # noqa: E501
+                        else self.driver.main_window.preview_panel.containers.update_from_entry(  # noqa: E501
                            self.driver.selected[0], update_badges=False
                        ),
                    )
@@ -142,7 +142,7 @@ class TagColorManager(QWidget):
                                self.setup_color_groups(),
                                ()
                                if len(self.driver.selected) < 1
-                                else self.driver.main_window.preview_panel.field_containers_widget.update_from_entry(  # noqa: E501
+                                else self.driver.main_window.preview_panel.containers.update_from_entry(  # noqa: E501
                                    self.driver.selected[0], update_badges=False
                                ),
                            ),
@@ -174,7 +174,7 @@ class TagColorManager(QWidget):
    def create_namespace(self):
        build_namespace_panel = BuildNamespacePanel(self.lib)

-        self.create_namespace_modal = PanelModal(
+        self.create_namespace_modal = Modal(
            build_namespace_panel,
            Translations["namespace.create.title"],
            is_savable=True,
@@ -20,21 +20,22 @@ from PySide6.QtWidgets import (
 from tagstudio.core.library.alchemy.enums import TagColorEnum
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import TagColorGroup
-from tagstudio.qt.mixed.tag_widget import (
-    get_tag_border_color,
-    get_tag_highlight_color,
-    get_tag_text_color,
-)
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.models.palette import ColorType, get_tag_color
 from tagstudio.qt.translations import Translations
 from tagstudio.qt.views.layouts.flow_layout import FlowLayout
-from tagstudio.qt.views.panel_modal import PanelWidget
-from tagstudio.qt.views.stylesheets.stylesheets import color_swatch_style, header
+from tagstudio.qt.views.stylesheets.stylesheets import (
+    color_swatch_style,
+    get_tag_border_color,
+    get_tag_highlight_color,
+    get_tag_text_color,
+    header,
+)

 logger = structlog.get_logger(__name__)


-class TagColorSelection(PanelWidget):
+class TagColorSelection(ModalContent):
    def __init__(self, library: Library):
        super().__init__()
        self.lib = library
@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, override
 import structlog
 from PySide6.QtCore import QEvent, Qt, Signal
 from PySide6.QtGui import QAction, QColor, QEnterEvent, QFontMetrics
-from PySide6.QtWidgets import QHBoxLayout, QLineEdit, QPushButton, QVBoxLayout, QWidget
+from PySide6.QtWidgets import QHBoxLayout, QLineEdit, QPushButton, QSizePolicy, QVBoxLayout, QWidget

 from tagstudio.core.library.alchemy.enums import TagColorEnum
 from tagstudio.core.library.alchemy.models import Tag
@@ -141,30 +141,27 @@ class TagWidget(QWidget):
        self.search_for_tag_action = QAction(self)
        self.search_for_tag_action.setText(Translations["tag.search_for_tag"])
        self.bg_button.addAction(self.search_for_tag_action)
-        # add_to_search_action = QAction(self)
-        # add_to_search_action.setText(Translations.translate_formatted("tag.add_to_search"))
-        # self.bg_button.addAction(add_to_search_action)

        self.inner_layout = QHBoxLayout()
        self.inner_layout.setObjectName("innerLayout")
        self.inner_layout.setContentsMargins(0, 0, 0, 0)
+        self.inner_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)

        self._delete_button = QPushButton(self)
        self._delete_button.setFlat(True)
        self._delete_button.setText("–")
        self._delete_button.setHidden(True)
-        self._delete_button.setMinimumSize(22, 22)
-        self._delete_button.setMaximumSize(22, 22)
+        self._delete_button.setFixedSize(22, 22)
        self._delete_button.clicked.connect(self.on_remove.emit)
        self._delete_button.setHidden(True)
        self.inner_layout.addWidget(self._delete_button)
-        self.inner_layout.addStretch(1)

        self.bg_button.setLayout(self.inner_layout)
        self.bg_button.setMinimumSize(44, 22)

-        self.bg_button.setMinimumHeight(22)
-        self.bg_button.setMaximumHeight(22)
+        self.bg_button.setFixedHeight(22)
+
+        self.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)

        self.base_layout.addWidget(self.bg_button)

@@ -2,17 +2,44 @@
 # SPDX-License-Identifier: GPL-3.0-only


+import platform
 import traceback
 from enum import IntEnum
 from typing import Any

 import structlog
+from PySide6.QtGui import QColor, QPalette

 from tagstudio.core.library.alchemy.enums import TagColorEnum
+from tagstudio.core.utils.singleton import Singleton

 logger = structlog.get_logger(__name__)


+class Palette(metaclass=Singleton):
+    _palette: QPalette | None = None
+
+    @staticmethod
+    def set_palette(palette: QPalette) -> None:
+        Palette._palette = palette
+
+    @staticmethod
+    def accent() -> QColor:
+        # NOTE: As of PySide 6.8.0.1, the QPalette.ColorRole.Accent role no longer works on Windows.
+        # The QPalette.ColorRole.Highlight does for some reason, but is faded on macOS.
+
+        if not Palette._palette:
+            logger.error("[Style] No QPalette set!")
+            return QColor.fromString(get_ui_color(ColorType.PRIMARY, UiColor.BLUE))
+        role = (
+            QPalette.ColorRole.Highlight
+            if platform.system() == "Windows"
+            else QPalette.ColorRole.Accent
+        )
+
+        return QPalette.color(Palette._palette, role)
+
+
 class ColorType(IntEnum):
    PRIMARY = 0
    TEXT = 1
@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+from pathlib import Path
+
+from PIL import ImageQt
+from PySide6.QtCore import QObject, QSize, Signal
+from PySide6.QtGui import QGuiApplication, QPixmap, Qt
+
+from tagstudio.core.library.alchemy.library import Library
+from tagstudio.qt.cache_manager import CacheManager
+from tagstudio.qt.global_settings import GlobalSettings, Theme
+from tagstudio.qt.previews.renderer import FileRenderer
+
+
+class QtFileRenderer(QObject):
+    """A Qt-specific wrapper for rendering image previews and thumbnails from files."""
+
+    updated = Signal(float, QPixmap, QSize, Path)
+    updated_ratio = Signal(float)
+
+    def __init__(self, library: Library, settings: GlobalSettings) -> None:
+        super().__init__()
+        self.renderer = FileRenderer(library, settings)
+        self.theme = (
+            Theme.DARK
+            if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+            else Theme.LIGHT
+        )
+
+    def render(
+        self,
+        cache: CacheManager | None,
+        timestamp: float,
+        filepath: Path | str,
+        size: tuple[int, int],
+        pixel_ratio: float,
+        is_loading: bool = False,
+        is_thumb: bool = False,
+    ):
+
+        image, size, timestamp = self.renderer.render(
+            cache=cache,
+            timestamp=timestamp,
+            filepath=filepath,
+            size=size,
+            dpi_scale=pixel_ratio,
+            theme=self.theme,
+            is_loading=is_loading,
+            is_thumb=is_thumb,
+        )
+        qim = ImageQt.ImageQt(image)
+        pixmap = QPixmap.fromImage(qim)
+        pixmap.setDevicePixelRatio(pixel_ratio)
+
+        self.updated_ratio.emit(image.size[0] / image.size[1])
+        if pixmap:
+            self.updated.emit(timestamp, pixmap, QSize(size[0], size[1]), filepath)
+        else:
+            self.updated.emit(timestamp, QPixmap(), QSize(*size), filepath)
@@ -36,6 +36,11 @@ class ResourceManager:
    edit: Image.Image
    file_generic: Image.Image
    font: Image.Image
+    hint_field_add: Image.Image
+    hint_field_create: Image.Image
+    hint_tag_add: Image.Image
+    hint_tag_added: Image.Image
+    hint_tag_create: Image.Image
    icon: Image.Image
    ignored_stat: Image.Image
    ignored: Image.Image
@@ -71,6 +71,26 @@
        "mode": "pil",
        "path": "qt/images/file_icons/font.png"
    },
+    "hint_field_add": {
+        "mode": "pil",
+        "path": "qt/images/hint_field_add.png"
+    },
+    "hint_field_create": {
+        "mode": "pil",
+        "path": "qt/images/hint_field_create.png"
+    },
+    "hint_tag_add": {
+        "mode": "pil",
+        "path": "qt/images/hint_tag_add.png"
+    },
+    "hint_tag_added": {
+        "mode": "pil",
+        "path": "qt/images/hint_tag_added.png"
+    },
+    "hint_tag_create": {
+        "mode": "pil",
+        "path": "qt/images/hint_tag_create.png"
+    },
    "icon": {
        "mode": "pil",
        "path": "icon.png"
@@ -17,7 +17,7 @@ from tagstudio.core.library.alchemy.enums import ItemType
 from tagstudio.core.library.alchemy.models import Entry
 from tagstudio.core.utils.types import unwrap
 from tagstudio.qt.mixed.item_thumb import BadgeType, ItemThumb
-from tagstudio.qt.previews.renderer import ThumbRenderer
+from tagstudio.qt.qt_file_renderer import QtFileRenderer

 if TYPE_CHECKING:
    from tagstudio.qt.ts_qt import QtDriver
@@ -44,7 +44,7 @@ class ThumbGridLayout(QLayout):
        self._entry_items: dict[int, int] = {}

        self._render_results: dict[Path, Any] = {}
-        self._renderer: ThumbRenderer = ThumbRenderer(self.driver)
+        self._renderer: QtFileRenderer = QtFileRenderer(self.driver.lib, self.driver.settings)
        self._renderer.updated.connect(self._on_rendered)
        self._render_cutoff: float = 0.0

@@ -77,6 +77,7 @@ class ThumbGridLayout(QLayout):
            (
                self._renderer.render,
                (
+                    self.driver.cache_manager,
                    self._render_cutoff,
                    Path(),
                    base_size,
@@ -300,7 +301,15 @@ class ThumbGridLayout(QLayout):
                    self.driver.thumb_job_queue.put(
                        (
                            self._renderer.render,
-                            (timestamp, file_path, base_size, ratio, False, True),
+                            (
+                                self.driver.cache_manager,
+                                timestamp,
+                                file_path,
+                                base_size,
+                                ratio,
+                                False,
+                                True,
+                            ),
                        )
                    )

@@ -40,7 +40,7 @@ from PySide6.QtGui import (
 from PySide6.QtWidgets import QApplication, QFileDialog, QMessageBox, QPushButton, QScrollArea

 import tagstudio.qt.resources_rc  # noqa: F401  # pyright: ignore[reportUnusedImport]
-from tagstudio.core.constants import TAG_ARCHIVED, TAG_FAVORITE, VERSION, VERSION_BRANCH
+from tagstudio.core.constants import BUILD_TYPE, TAG_ARCHIVED, TAG_FAVORITE, VERSION
 from tagstudio.core.driver import DriverMixin
 from tagstudio.core.enums import AppCacheItems, MacroID, ShowFilepathOption
 from tagstudio.core.library.alchemy.enums import BrowsingState, SortingModeEnum
@@ -51,8 +51,6 @@ from tagstudio.core.library.refresh import RefreshTracker
 from tagstudio.core.media_types import MediaCategories
 from tagstudio.core.query_lang.util import ParsingError
 from tagstudio.core.ts_core import TagStudioCore
-
-# This import has side-effect of importing PySide resources
 from tagstudio.core.utils.ffmpeg_status import FfmpegStatus, FfprobeStatus
 from tagstudio.core.utils.module_status import ModuleStatus
 from tagstudio.core.utils.ripgrep_status import RipgrepStatus
@@ -63,7 +61,8 @@ from tagstudio.qt.controllers.field_template_search_panel_controller import Fiel
 from tagstudio.qt.controllers.fix_ignored_modal_controller import FixIgnoredEntriesModal
 from tagstudio.qt.controllers.ignore_modal_controller import IgnoreModal
 from tagstudio.qt.controllers.library_info_window_controller import LibraryInfoWindow
-from tagstudio.qt.controllers.tag_search_panel_controller import TagSearchModal
+from tagstudio.qt.controllers.modal import Modal
+from tagstudio.qt.controllers.tag_search_panel_controller import TagSearchPanel
 from tagstudio.qt.controllers.update_available_message_box import UpdateAvailableMessageBox
 from tagstudio.qt.global_settings import DEFAULT_GLOBAL_SETTINGS_PATH, GlobalSettings, Theme
 from tagstudio.qt.mixed.about_modal import AboutModal
@@ -77,16 +76,15 @@ from tagstudio.qt.mixed.migration_modal import JsonMigrationModal
 from tagstudio.qt.mixed.progress_bar import ProgressWidget
 from tagstudio.qt.mixed.settings_panel import SettingsPanel
 from tagstudio.qt.mixed.tag_color_manager import TagColorManager
-from tagstudio.qt.models.palette import ColorType, UiColor, get_ui_color
+from tagstudio.qt.models.palette import ColorType, Palette, UiColor, get_ui_color
 from tagstudio.qt.platform_strings import trash_term
 from tagstudio.qt.resource_manager import ResourceManager
 from tagstudio.qt.translations import Translations
 from tagstudio.qt.utils.custom_runnable import CustomRunnable
 from tagstudio.qt.utils.file_deleter import delete_file
 from tagstudio.qt.utils.function_iterator import FunctionIterator
-from tagstudio.qt.views.field_template_search_panel_view import FieldTemplateSearchPanelView
 from tagstudio.qt.views.main_window import MainWindow
-from tagstudio.qt.views.panel_modal import PanelModal
+from tagstudio.qt.views.search_panel_view import SearchPanelView
 from tagstudio.qt.views.splash import SplashScreen
 from tagstudio.qt.views.stylesheets.stylesheets import header

@@ -169,12 +167,12 @@ class QtDriver(DriverMixin, QObject):
    favorite_updated = Signal(bool)
    archived_updated = Signal(bool)

-    tag_manager_panel: PanelModal | None = None
+    tag_manager: Modal | None = None
    color_manager_panel: TagColorManager | None = None
-    field_template_manager_panel: PanelModal | None = None
-    ignore_modal: PanelModal | None = None
-    add_tag_modal: PanelModal | None = None
-    add_field_modal: PanelModal | None = None
+    field_template_manager: Modal | None = None
+    ignore_modal: Modal | None = None
+    add_tag_modal: Modal | None = None
+    add_field_modal: Modal | None = None
    folders_modal: FoldersToTagsModal
    about_modal: AboutModal
    unlinked_modal: FixUnlinkedEntriesModal
@@ -185,7 +183,7 @@ class QtDriver(DriverMixin, QObject):
    applied_theme: Theme

    lib: Library
-    cache_manager: CacheManager | None
+    cache_manager: CacheManager | None = None

    browsing_history: History[BrowsingState]

@@ -203,7 +201,7 @@ class QtDriver(DriverMixin, QObject):
        self.scrollbar_pos = 0
        self.spacing = None

-        self.branch: str = (" (" + VERSION_BRANCH + ")") if VERSION_BRANCH else ""
+        self.branch: str = (" (" + Translations[BUILD_TYPE] + ")") if BUILD_TYPE else ""
        self.base_title: str = f"TagStudio Alpha {VERSION}{self.branch}"
        # self.title_text: str = self.base_title
        # self.buffer = {}
@@ -274,7 +272,7 @@ class QtDriver(DriverMixin, QObject):
        dir = QFileDialog.getExistingDirectory(
            parent=None,
            caption=Translations["window.title.open_create_library"],
-            dir="/",
+            dir=str(Path.home()),
            options=QFileDialog.Option.ShowDirsOnly,
        )
        if dir not in (None, ""):
@@ -303,19 +301,35 @@ class QtDriver(DriverMixin, QObject):
        elif self.settings.theme == Theme.LIGHT:
            self.app.styleHints().setColorScheme(Qt.ColorScheme.Light)

+        pal: QPalette = self.app.palette()
+        # BUG: Changing the palette in any way here seems to affect the accent colors of certain
+        # widgets, like QLineEdit focused borders and QComboBox highlighted items and borders.
+        # Need to figure out the cause of this.
        if (
            platform.system() == "Darwin" or platform.system() == "Windows"
        ) and QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark:
-            pal: QPalette = self.app.palette()
            pal.setColor(QPalette.ColorGroup.Normal, QPalette.ColorRole.Window, QColor("#1e1e1e"))
            pal.setColor(QPalette.ColorGroup.Normal, QPalette.ColorRole.Button, QColor("#1e1e1e"))
+            pal.setColor(
+                QPalette.ColorGroup.Inactive, QPalette.ColorRole.ToolTipBase, QColor("#1e1e1e")
+            )
+            pal.setColor(
+                QPalette.ColorGroup.Inactive, QPalette.ColorRole.ToolTipText, QColor("#FFFFFF")
+            )
            pal.setColor(QPalette.ColorGroup.Inactive, QPalette.ColorRole.Window, QColor("#232323"))
            pal.setColor(QPalette.ColorGroup.Inactive, QPalette.ColorRole.Button, QColor("#232323"))
            pal.setColor(
                QPalette.ColorGroup.Inactive, QPalette.ColorRole.ButtonText, QColor("#666666")
            )
-
-            self.app.setPalette(pal)
+        # BUG: PySide isn't properly setting the link colors on Windows, so this is a fallback.
+        if platform.system() == "Windows":
+            pal.setColor(
+                QPalette.ColorGroup.Normal,
+                QPalette.ColorRole.Link,
+                QColor.fromString(get_ui_color(ColorType.PRIMARY, UiColor.BLUE)),
+            )
+        Palette.set_palette(pal)
+        self.app.setPalette(pal)

        # Handle OS signals
        self.setup_signals()
@@ -357,15 +371,15 @@ class QtDriver(DriverMixin, QObject):
            if platform.system() != "Windows":
                self.app.setDesktopFileName("tagstudio")

-        # Initialize the Tag Manager panel
-        self.tag_manager_panel = TagSearchModal(
-            self.lib,
-            title=Translations["tag_manager.title"],
-            is_tag_chooser=False,
+        tsp_view = SearchPanelView(
+            placeholder_text=Translations["home.search_tags"],
+            create_text=Translations["tag.create"],
+            is_chooser=False,
        )
-        self.tag_manager_panel.tsp.set_driver(self)
-
-        self.tag_manager_panel.done.connect(
+        tsp = TagSearchPanel(self.lib, is_chooser=False, view=tsp_view)
+        tsp.search_for_tag.connect(self.search_for_tag_callback)
+        self.tag_manager = Modal(tsp, Translations["tag_manager.title"])
+        self.tag_manager.done.connect(
            lambda checked=False: self.main_window.preview_panel.set_selection(
                self.selected, update_preview=False
            )
@@ -375,30 +389,33 @@ class QtDriver(DriverMixin, QObject):
        self.color_manager_panel = TagColorManager(self)

        # Initialize the Field Template Manager panel
-        self.field_template_manager_panel = PanelModal(
-            widget=FieldTemplateSearchPanel(
+        self.field_template_manager = Modal(
+            content_widget=FieldTemplateSearchPanel(
                self.lib,
-                is_field_template_chooser=False,
-                view=FieldTemplateSearchPanelView(is_field_template_chooser=False),
+                is_chooser=False,
+                view=SearchPanelView(Translations["home.search_field_templates"], is_chooser=False),
            ),
            title=Translations["field_template_manager.title"],
            is_savable=False,
        )
-        self.field_template_manager_panel.done.connect(
+        self.field_template_manager.done.connect(
            lambda checked=False: self.main_window.preview_panel.set_selection(
                self.selected, update_preview=False
            )
        )

+        # TODO: Remove/replace this with a suite of persistently visible tagging panels, including
+        # tag search. These will be docked on the left-hand side of the main window.
+
        # Initialize the "Add Tag" panel
-        self.add_tag_modal = TagSearchModal(
-            self.lib, title=Translations["tag.add.plural"], is_tag_chooser=True
-        )
-        self.add_tag_modal.tsp.set_driver(self)
-        self.add_tag_modal.tsp.item_chosen.connect(
+        add_tag_tsp_view = SearchPanelView(placeholder_text=Translations["home.search_tags"])
+        add_tag_tsp = TagSearchPanel(self.lib, view=add_tag_tsp_view)
+        add_tag_tsp.search_for_tag.connect(self.search_for_tag_callback)
+        self.add_tag_modal = Modal(add_tag_tsp, Translations["tag.add.plural"])
+        add_tag_tsp.item_chosen.connect(
            lambda chosen_tag: (
                self.add_tags_to_selected_callback([chosen_tag]),
-                self.main_window.preview_panel.set_selection(self.selected),
+                self.main_window.preview_panel.set_selection(self.selected, update_preview=False),
            )
        )

@@ -479,14 +496,14 @@ class QtDriver(DriverMixin, QObject):
            lambda f="": self.delete_files_callback(f)
        )

-        self.main_window.menu_bar.tag_manager_action.triggered.connect(self.tag_manager_panel.show)
+        self.main_window.menu_bar.tag_manager_action.triggered.connect(self.tag_manager.show)

        self.main_window.menu_bar.color_manager_action.triggered.connect(
            self.color_manager_panel.show
        )

        self.main_window.menu_bar.field_template_manager_action.triggered.connect(
-            self.field_template_manager_panel.show
+            self.field_template_manager.show
        )

        # endregion
@@ -627,6 +644,8 @@ class QtDriver(DriverMixin, QObject):
            if path_result.success and path_result.library_path:
                self.open_library(path_result.library_path)

+        self.main_window.search_field.setFocus()
+
        self.check_for_update()
        self.app.exec()
        self.shutdown()
@@ -724,7 +743,7 @@ class QtDriver(DriverMixin, QObject):
            self.ignore_modal = None

        panel = IgnoreModal(self.lib)
-        self.ignore_modal = PanelModal(
+        self.ignore_modal = Modal(
            panel,
            Translations["menu.edit.ignore_files"],
            is_savable=True,
@@ -837,7 +856,7 @@ class QtDriver(DriverMixin, QObject):
        logger.info("Backing Up Library...")
        self.main_window.status_bar.showMessage(Translations["status.library_backup_in_progress"])
        start_time = time.time()
-        target_path = self.lib.save_library_backup_to_disk()
+        target_path = Library.save_library_backup_to_disk(unwrap(self.lib.library_dir))
        end_time = time.time()
        self.main_window.status_bar.showMessage(
            Translations.format(
@@ -862,7 +881,7 @@ class QtDriver(DriverMixin, QObject):

    def add_tag_action_callback(self):
        panel = BuildTagPanel(self.lib)
-        self.modal = PanelModal(
+        self.modal = Modal(
            panel,
            Translations["tag.new"],
            Translations["tag.create"],
@@ -881,6 +900,11 @@ class QtDriver(DriverMixin, QObject):
        )
        self.modal.show()

+    def search_for_tag_callback(self, tag_id: int) -> None:
+        """Callback to search for a given Tag ID."""
+        self.main_window.search_field.setText(f"tag_id:{tag_id}")
+        self.update_browsing_state(BrowsingState.from_tag_id(tag_id, self.browsing_history.current))
+
    def select_all_action_callback(self):
        """Set the selection to all visible items."""
        self.select_all()
@@ -954,7 +978,7 @@ class QtDriver(DriverMixin, QObject):
                for i, tup in enumerate(pending):
                    e_id, f = tup
                    if (origin_path == f) or (not origin_path):
-                        self.main_window.preview_panel.preview_thumb.media_player.stop()
+                        self.main_window.preview_panel.stop_media_playback()

                    msg = Translations.format(
                        "status.deleting_file", i=i, count=len(pending), path=f
@@ -1775,4 +1799,4 @@ class QtDriver(DriverMixin, QObject):
            if sc.which():
                logger.info(f"[QtDriver] {name} found", which=sc.which(), version=sc.version())
            else:
-                logger.warning(f"[QtDriver] {sc} not found")
+                logger.warning(f"[QtDriver] {name} not found")
@@ -15,14 +15,14 @@ from PySide6.QtWidgets import (
 )

 from tagstudio.qt.controllers.clickable_label import ClickableLabel
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelWidget
 from tagstudio.qt.views.stylesheets.stylesheets import checkbox_style

 logger = structlog.get_logger(__name__)


-class EditFieldTemplateModalView(PanelWidget):
+class EditFieldTemplateModalView(ModalContent):
    def __init__(self) -> None:
        super().__init__()

@@ -14,12 +14,12 @@ from PySide6.QtWidgets import (
 )

 from tagstudio.qt.controllers.clickable_label import ClickableLabel
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelWidget
 from tagstudio.qt.views.stylesheets.stylesheets import checkbox_style, title_line_edit_style


-class EditTextView(PanelWidget):
+class EditTextView(ModalContent):
    def __init__(self):
        super().__init__()
        self.setMinimumSize(480, 240)
@@ -1,33 +0,0 @@
-# SPDX-FileCopyrightText: (c) TagStudio Contributors
-# SPDX-License-Identifier: GPL-3.0-only
-
-from typing import override
-
-from PySide6.QtWidgets import QWidget
-
-from tagstudio.core.library.alchemy.library import Library
-from tagstudio.qt.controllers.field_template_widget_controller import FieldTemplateWidget
-from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.search_panel_view import SearchPanelView
-
-
-class FieldTemplateSearchPanelView(SearchPanelView):
-    def __init__(self, is_field_template_chooser: bool) -> None:
-        super().__init__(is_field_template_chooser)
-
-        self.search_field.setPlaceholderText(Translations["home.search_field_templates"])
-        self.create_button.setText(Translations["field_template.create"])
-
-    @override
-    def get_item_widget(self, index: int, library: Library | None) -> FieldTemplateWidget:
-        """Gets the item widget at a specific index."""
-        # Create any new item widgets needed up to the given index
-        if self._scroll_layout.count() <= index:
-            while self._scroll_layout.count() <= index:
-                pad_field_template_widget = FieldTemplateWidget()
-                pad_field_template_widget.setHidden(True)
-                self._scroll_layout.addWidget(pad_field_template_widget)
-
-        field_template_widget: QWidget = self._scroll_layout.itemAt(index).widget()
-        assert isinstance(field_template_widget, FieldTemplateWidget)
-        return field_template_widget
@@ -2,8 +2,8 @@
 # SPDX-License-Identifier: GPL-3.0-only

 from PySide6.QtCore import Signal
-from PySide6.QtGui import QColor
-from PySide6.QtWidgets import QHBoxLayout, QPushButton, QVBoxLayout, QWidget
+from PySide6.QtGui import QColor, Qt
+from PySide6.QtWidgets import QHBoxLayout, QPushButton, QSizePolicy, QVBoxLayout, QWidget

 from tagstudio.core.library.alchemy.enums import TagColorEnum
 from tagstudio.qt.models.palette import ColorType, get_tag_color
@@ -12,8 +12,10 @@ from tagstudio.qt.views.stylesheets.stylesheets import (
    get_tag_highlight_color,
    get_tag_text_color,
    list_button_style,
+    tag_remove_button_style,
 )

+# TODO: These colors and logic should be moved to and reworked in the stylesheets file.
 primary_color: QColor = QColor(get_tag_color(ColorType.PRIMARY, TagColorEnum.DEFAULT))
 border_color: QColor = get_tag_border_color(primary_color)
 highlight_color: QColor = get_tag_highlight_color(primary_color)
@@ -30,7 +32,6 @@ class FieldTemplateWidgetView(QWidget):

        self.__root_layout = QVBoxLayout(self)
        self.__root_layout.setObjectName("root_layout")
-
        self.__root_layout.setContentsMargins(0, 0, 0, 0)

        # Background button
@@ -47,6 +48,8 @@ class FieldTemplateWidgetView(QWidget):
        self.__inner_layout.setObjectName("inner_layout")
        self._bg_button.setLayout(self.__inner_layout)

+        self.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
+
        self.__inner_layout.setContentsMargins(0, 0, 0, 0)

        # Remove button
@@ -56,9 +59,12 @@ class FieldTemplateWidgetView(QWidget):
        self._delete_button.setHidden(True)
        self._delete_button.setMinimumSize(22, 22)
        self._delete_button.setMaximumSize(22, 22)
+        self._delete_button.setStyleSheet(
+            tag_remove_button_style(primary_color, text_color, border_color, highlight_color)
+        )

        self.__inner_layout.addWidget(self._delete_button)
-        self.__inner_layout.addStretch(1)
+        self.__inner_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)

        self.__connect_callbacks()

@@ -14,13 +14,13 @@ from PySide6.QtWidgets import (
 from tagstudio.core.constants import IGNORE_NAME
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import Tag
+from tagstudio.qt.controllers.modal_content import ModalContent
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelWidget

 logger = structlog.get_logger(__name__)


-class IgnoreModalView(PanelWidget):
+class IgnoreModalView(ModalContent):
    on_edit = Signal(Tag)

    def __init__(self, library: Library) -> None:
@@ -5,10 +5,11 @@
 import typing
 from collections.abc import Callable
 from pathlib import Path
+from typing import override

 import structlog
 from PIL import Image, ImageQt
-from PySide6 import QtCore
+from PySide6 import QtCore, QtGui
 from PySide6.QtCore import QMetaObject, QSize, QStringListModel, Qt
 from PySide6.QtGui import QAction, QPixmap
 from PySide6.QtWidgets import (
@@ -182,10 +183,10 @@ class MainMenuBar(QMenuBar):
        self.new_tag_action.setShortcut(
            QtCore.QKeyCombination(
                QtCore.Qt.KeyboardModifier(QtCore.Qt.KeyboardModifier.ControlModifier),
-                QtCore.Qt.Key.Key_T,
+                QtCore.Qt.Key.Key_N,
            )
        )
-        self.new_tag_action.setToolTip("Ctrl+T")
+        self.new_tag_action.setToolTip("Ctrl+N")
        self.new_tag_action.setEnabled(False)
        self.edit_menu.addAction(self.new_tag_action)

@@ -220,9 +221,8 @@ class MainMenuBar(QMenuBar):

        # Clear Selection
        self.clear_select_action = QAction(Translations["select.clear"], self)
-        self.clear_select_action.setShortcut(QtCore.Qt.Key.Key_Escape)
-        self.clear_select_action.setToolTip("Esc")
        self.clear_select_action.setEnabled(False)
+        self.clear_select_action.setToolTip("Esc")
        self.edit_menu.addAction(self.clear_select_action)

        # Copy Fields
@@ -700,10 +700,12 @@ class MainWindow(QMainWindow):
        self.content_splitter.addWidget(self.entry_list_container)

    def setup_preview_panel(self, driver: "QtDriver"):
-        self.preview_panel = PreviewPanel(driver.lib, driver)
+        self.preview_panel = PreviewPanel(driver)
        self.content_splitter.addWidget(self.preview_panel)

    def setup_status_bar(self):
+        # BUG: Clicking the status bar does not count as losing focus on other widgets
+        # (for example, the "Add Tag" line edit). Can this be fixed?
        self.status_bar = QStatusBar(self)
        self.status_bar.setObjectName("status_bar")
        status_bar_size_policy = QSizePolicy(
@@ -746,3 +748,9 @@ class MainWindow(QMainWindow):
    def show_hidden_entries(self) -> bool:
        """Whether to show entries tagged with hidden tags."""
        return self.show_hidden_entries_checkbox.isChecked()
+
+    @override
+    def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
+        if event.key() == QtCore.Qt.Key.Key_Escape:
+            self.menu_bar.clear_select_action.trigger()
+        return super().keyPressEvent(event)
@@ -0,0 +1,64 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import structlog
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QHBoxLayout, QLabel, QPushButton, QVBoxLayout, QWidget
+
+from tagstudio.qt.controllers.modal_content import ModalContent
+from tagstudio.qt.translations import Translations
+from tagstudio.qt.views.stylesheets.stylesheets import header
+
+logger = structlog.get_logger(__name__)
+
+
+class ModalView(QVBoxLayout):
+    """A generic reusable modal panel widget."""
+
+    def __init__(
+        self,
+        content_widget: ModalContent,
+        title: str = "",
+        is_savable: bool = False,
+        inline_title: bool = True,
+    ):
+        super().__init__()
+        self.content_widget = content_widget
+        self.setContentsMargins(6, 6 if inline_title else 12, 6, 6)
+
+        self.button_container = QWidget()
+        self.button_layout = QHBoxLayout(self.button_container)
+        self.button_layout.setContentsMargins(6, 6, 6, 6)
+        self.button_layout.addStretch(1)
+
+        # [Done]
+        # - OR -
+        # [Cancel] [Save]
+        if not is_savable:
+            done_button = QPushButton(Translations["generic.done"])
+            done_button.setAutoDefault(True)
+            self.content_widget.done_button = done_button
+            self.button_layout.addWidget(done_button)
+        else:
+            cancel_button = QPushButton(Translations["generic.cancel"])
+            self.content_widget.cancel_button = cancel_button
+            self.button_layout.addWidget(cancel_button)
+
+            save_button = QPushButton(Translations["generic.save"])
+            save_button.setAutoDefault(True)
+            self.content_widget.save_button = save_button
+            self.button_layout.addWidget(save_button)
+
+        if inline_title:
+            self.title_label = QLabel()
+            self.title_label.setObjectName("fieldTitle")
+            self.title_label.setWordWrap(True)
+            self.title_label.setText(header(title, 3))
+            self.title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.addWidget(self.title_label)
+
+        self.addWidget(content_widget)
+        self.setStretch(1, 2)
+        self.addWidget(self.button_container)
+        content_widget.parent_post_init()
@@ -1,127 +0,0 @@
-# SPDX-FileCopyrightText: (c) TagStudio Contributors
-# SPDX-License-Identifier: GPL-3.0-only
-
-
-import contextlib
-from typing import Any, override
-
-import structlog
-from PySide6 import QtCore, QtGui
-from PySide6.QtCore import Qt, Signal
-from PySide6.QtWidgets import QHBoxLayout, QLabel, QPushButton, QVBoxLayout, QWidget
-
-from tagstudio.qt.translations import Translations
-
-logger = structlog.get_logger(__name__)
-
-
-class PanelModal(QWidget):
-    """A generic reusable modal panel widget."""
-
-    done = Signal()
-    saved = Signal()
-    saved_data = Signal(type(Any))
-
-    def __init__(
-        self,
-        widget: "PanelWidget",
-        title: str = "",
-        window_title: str | None = None,
-        is_savable: bool = False,
-        inline_title: bool = True,
-    ):
-        # [Done]
-        # - OR -
-        # [Cancel] [Save]
-        super().__init__()
-        self.widget = widget
-        self.setWindowTitle(title if window_title is None else window_title)
-        self.setWindowModality(Qt.WindowModality.ApplicationModal)
-        self.root_layout = QVBoxLayout(self)
-        self.root_layout.setContentsMargins(6, 0 if inline_title else 12, 6, 6)
-
-        self.button_container = QWidget()
-        self.button_layout = QHBoxLayout(self.button_container)
-        self.button_layout.setContentsMargins(6, 6, 6, 6)
-        self.button_layout.addStretch(1)
-
-        if not is_savable:
-            self.done_button = QPushButton(Translations["generic.done"])
-            self.done_button.setAutoDefault(True)
-            self.done_button.clicked.connect(self.hide)
-            self.done_button.clicked.connect(self.done.emit)
-            self.widget.panel_done_button = self.done_button
-            self.button_layout.addWidget(self.done_button)
-        else:
-            self.cancel_button = QPushButton(Translations["generic.cancel"])
-            self.cancel_button.clicked.connect(self.hide)
-            self.cancel_button.clicked.connect(widget.reset)
-            self.widget.panel_cancel_button = self.cancel_button
-            self.button_layout.addWidget(self.cancel_button)
-
-            self.save_button = QPushButton(Translations["generic.save"])
-            self.save_button.setAutoDefault(True)
-            self.save_button.clicked.connect(self.hide)
-            self.save_button.clicked.connect(self.saved.emit)
-            self.save_button.clicked.connect(lambda: self.saved_data.emit(widget.saved_data()))
-            self.widget.panel_save_button = self.save_button
-            self.button_layout.addWidget(self.save_button)
-
-        if inline_title:
-            self.title_widget = QLabel()
-            self.title_widget.setObjectName("fieldTitle")
-            self.title_widget.setWordWrap(True)
-            self.title_widget.setStyleSheet("font-weight:bold;font-size:14px;padding-top:6px")
-            self.title_widget.setText(title)
-            self.title_widget.setAlignment(Qt.AlignmentFlag.AlignCenter)
-            self.root_layout.addWidget(self.title_widget)
-
-        self.root_layout.addWidget(widget)
-        widget.parent_modal = self
-        self.root_layout.setStretch(1, 2)
-        self.root_layout.addWidget(self.button_container)
-        widget.parent_post_init()
-
-    @override
-    def closeEvent(self, event: QtGui.QCloseEvent) -> None:
-        with contextlib.suppress(AttributeError):
-            self.cancel_button.click()
-        with contextlib.suppress(AttributeError):
-            self.done_button.click()
-        event.accept()
-
-
-class PanelWidget(QWidget):
-    """Used for widgets that go in a modal panel, ex. for editing or searching."""
-
-    parent_modal: PanelModal | None = None
-    panel_save_button: QPushButton | None = None
-    panel_cancel_button: QPushButton | None = None
-    panel_done_button: QPushButton | None = None
-
-    def __init__(self):
-        super().__init__()
-
-    def saved_data(self) -> Any:  # pyright: ignore[reportExplicitAny]
-        return None
-
-    def reset(self) -> None:
-        pass
-
-    def parent_post_init(self) -> None:
-        pass
-
-    @override
-    def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
-        if event.key() == QtCore.Qt.Key.Key_Escape:
-            if self.panel_cancel_button:
-                self.panel_cancel_button.click()
-            elif self.panel_done_button:
-                self.panel_done_button.click()
-        elif event.key() == Qt.Key.Key_Return or event.key() == Qt.Key.Key_Enter:
-            if self.panel_save_button:
-                self.panel_save_button.click()
-            elif self.panel_done_button:
-                self.panel_done_button.click()
-        else:  # Other key presses
-            super().keyPressEvent(event)
@@ -3,29 +3,20 @@


 import math
-import traceback
 import typing
-from pathlib import Path

 import structlog
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QDesktopServices
-from PySide6.QtWidgets import (
-    QHBoxLayout,
-    QLabel,
-    QPushButton,
-    QSplitter,
-    QVBoxLayout,
-    QWidget,
-)
+from PySide6.QtWidgets import QHBoxLayout, QLabel, QSplitter, QVBoxLayout, QWidget

 from tagstudio.core.constants import FFMPEG_HELP_URL
-from tagstudio.core.library.alchemy.library import Library
-from tagstudio.core.library.alchemy.models import Entry
-from tagstudio.core.utils.types import unwrap
+from tagstudio.qt.controllers.field_suggest_box import FieldSuggestBox
 from tagstudio.qt.controllers.preview_thumb_controller import PreviewThumb
+from tagstudio.qt.controllers.return_button import ReturnButton
+from tagstudio.qt.controllers.tag_suggest_box import TagSuggestBox
 from tagstudio.qt.mixed.field_containers import FieldContainers
-from tagstudio.qt.mixed.file_attributes import FileAttributeData, FileAttributes
+from tagstudio.qt.mixed.file_attributes import FileAttributes
 from tagstudio.qt.resource_manager import ResourceManager
 from tagstudio.qt.translations import Translations
 from tagstudio.qt.views.stylesheets.stylesheets import button_style, preview_warning_style
@@ -36,32 +27,40 @@ if typing.TYPE_CHECKING:
 logger = structlog.get_logger(__name__)


-class PreviewPanelView(QWidget):
-    lib: Library
-
-    _selected: list[int]
-
-    def __init__(self, library: Library, driver: "QtDriver") -> None:
+class PreviewPanelView(QVBoxLayout):
+    def __init__(self, driver: "QtDriver", pixel_ratio: float) -> None:
        super().__init__()
-        self.lib = library
+        self.setContentsMargins(0, 0, 0, 0)
+        self.setSpacing(6)
        rm = ResourceManager()

-        self._thumb = PreviewThumb(self.lib, driver)
-        self._file_attrs = FileAttributes(self.lib, driver)
-        self._containers = FieldContainers(
-            self.lib, driver
-        )  # TODO: this should be name mangled, but is still needed on the controller side atm
+        # Search/Create Boxes
+        def ph_text(key: str) -> str:
+            return " ".join([Translations[key], Translations["home.search.how_to_exit"]])

+        self.field_search_box = FieldSuggestBox(
+            driver.lib, driver.settings, ph_text("home.search_or_create_fields")
+        )
+        self.tag_search_box = TagSuggestBox(
+            driver.lib, driver.settings, ph_text("home.search_or_create_tags")
+        )
+
+        self.preview_thumb = PreviewThumb(driver.lib, driver)
+        self.file_attrs = FileAttributes(driver.lib, driver)
+        self.containers = FieldContainers(driver.lib, driver)
+
+        # Visual Preview
        preview_section = QWidget()
        preview_layout = QVBoxLayout(preview_section)
        preview_layout.setContentsMargins(0, 0, 0, 0)
        preview_layout.setSpacing(6)

-        self._ffmpeg_warning_widget = QWidget()
-        self._ffmpeg_warning_widget.setObjectName("ffmpeg_widget")
-        ffmpeg_warning_layout = QHBoxLayout(self._ffmpeg_warning_widget)
+        # Warning Banner (Missing FFmpeg, etc.)
+        self.warning_banner = QWidget()
+        self.warning_banner.setObjectName("ffmpeg_widget")
+        ffmpeg_warning_layout = QHBoxLayout(self.warning_banner)
        ffmpeg_warning_layout.setContentsMargins(3, 3, 3, 3)
-        self._ffmpeg_warning_widget.setStyleSheet(preview_warning_style())
+        self.warning_banner.setStyleSheet(preview_warning_style())
        ffmpeg_warning_label = QLabel(
            Translations.format(
                "preview.missing_module.multimedia",
@@ -74,16 +73,16 @@ class PreviewPanelView(QWidget):
        )
        warning_icon = QLabel()
        warning_icon_pixmap = rm.alert.scaled(
-            math.floor(20 * self.devicePixelRatio()), math.floor(20 * self.devicePixelRatio())
+            math.floor(20 * pixel_ratio), math.floor(20 * pixel_ratio)
        )
-        warning_icon_pixmap.setDevicePixelRatio(self.devicePixelRatio())
+        warning_icon_pixmap.setDevicePixelRatio(pixel_ratio)
        warning_icon.setPixmap(warning_icon_pixmap)
        ffmpeg_warning_layout.addWidget(warning_icon)
        ffmpeg_warning_layout.addWidget(ffmpeg_warning_label)
        ffmpeg_warning_layout.setStretch(1, 1)
+        self.warning_banner.hide()

-        self._ffmpeg_warning_widget.hide()
-
+        # File Information
        info_section = QWidget()
        info_layout = QVBoxLayout(info_section)
        info_layout.setContentsMargins(0, 0, 0, 0)
@@ -93,129 +92,38 @@ class PreviewPanelView(QWidget):
        splitter.setOrientation(Qt.Orientation.Vertical)
        splitter.setHandleWidth(12)

+        # Add Tag/Field Buttons
        add_buttons_container = QWidget()
        add_buttons_layout = QHBoxLayout(add_buttons_container)
        add_buttons_layout.setContentsMargins(0, 0, 0, 0)
        add_buttons_layout.setSpacing(6)

-        self.__add_tag_button = QPushButton(Translations["tag.add"])
-        self.__add_tag_button.setEnabled(False)
-        self.__add_tag_button.setCursor(Qt.CursorShape.PointingHandCursor)
-        self.__add_tag_button.setMinimumHeight(28)
-        self.__add_tag_button.setStyleSheet(button_style())
+        self.add_tag_button = ReturnButton(Translations["tag.add"])
+        self.add_tag_button.setEnabled(False)
+        self.add_tag_button.setCursor(Qt.CursorShape.PointingHandCursor)
+        self.add_tag_button.setMinimumHeight(30)
+        self.add_tag_button.setStyleSheet(button_style())

-        self.__add_field_button = QPushButton(Translations["field.add"])
-        self.__add_field_button.setEnabled(False)
-        self.__add_field_button.setCursor(Qt.CursorShape.PointingHandCursor)
-        self.__add_field_button.setMinimumHeight(28)
-        self.__add_field_button.setStyleSheet(button_style())
+        self.add_field_button = ReturnButton(Translations["field.add"])
+        self.add_field_button.setEnabled(False)
+        self.add_field_button.setCursor(Qt.CursorShape.PointingHandCursor)
+        self.add_field_button.setMinimumHeight(30)
+        self.add_field_button.setStyleSheet(button_style())

-        add_buttons_layout.addWidget(self.__add_tag_button)
-        add_buttons_layout.addWidget(self.__add_field_button)
+        add_buttons_layout.addWidget(self.add_tag_button)
+        add_buttons_layout.addWidget(self.add_field_button)
+        add_buttons_layout.addWidget(self.tag_search_box)
+        add_buttons_layout.addWidget(self.field_search_box)

-        preview_layout.addWidget(self._thumb)
-        info_layout.addWidget(self._ffmpeg_warning_widget)
-        info_layout.addWidget(self._file_attrs)
-        info_layout.addWidget(self._containers)
+        # Finalize Layout
+        preview_layout.addWidget(self.preview_thumb)
+        info_layout.addWidget(self.warning_banner)
+        info_layout.addWidget(self.file_attrs)
+        info_layout.addWidget(self.containers)

        splitter.addWidget(preview_section)
        splitter.addWidget(info_section)
        splitter.setStretchFactor(1, 2)

-        root_layout = QVBoxLayout(self)
-        root_layout.setContentsMargins(0, 0, 0, 0)
-        root_layout.addWidget(splitter)
-        root_layout.addWidget(add_buttons_container)
-
-        self.__connect_callbacks()
-
-    def __connect_callbacks(self) -> None:
-        self.__add_field_button.clicked.connect(self._add_field_button_callback)
-        self.__add_tag_button.clicked.connect(self._add_tag_button_callback)
-
-    def _add_field_button_callback(self) -> None:
-        raise NotImplementedError()
-
-    def _add_tag_button_callback(self) -> None:
-        raise NotImplementedError()
-
-    def _set_selection_callback(self) -> None:
-        raise NotImplementedError()
-
-    def set_selection(self, selected: list[int], update_preview: bool = True) -> None:
-        """Render the panel widgets with the newest data from the Library.
-
-        Args:
-            selected  (list[int]): List of the IDs of the selected entries.
-            update_preview (bool): Should the file preview be updated?
-            (Only works with one or more items selected)
-        """
-        self._selected = selected
-        try:
-            # No Items Selected
-            if len(selected) == 0:
-                self._thumb.hide_preview()
-                self._file_attrs.update_stats()
-                self._file_attrs.update_date_label()
-                self._containers.hide_containers()
-
-                self.add_buttons_enabled = False
-
-            # One Item Selected
-            elif len(selected) == 1:
-                entry_id = selected[0]
-                entry: Entry = unwrap(self.lib.get_entry(entry_id))
-
-                filepath: Path = unwrap(self.lib.library_dir) / entry.path
-
-                if update_preview:
-                    stats: FileAttributeData = self._thumb.display_file(filepath)
-                    self._file_attrs.update_stats(filepath, stats)
-                self._file_attrs.update_date_label(filepath)
-                self._containers.update_from_entry(entry_id)
-
-                self._set_selection_callback()
-
-                self.add_buttons_enabled = True
-
-            # Multiple Selected Items
-            elif len(selected) > 1:
-                # items: list[Entry] = [self.lib.get_entry_full(x) for x in self.driver.selected]
-                self._thumb.hide_preview()  # TODO: Render mixed selection
-                self._file_attrs.update_multi_selection(len(selected))
-                self._file_attrs.update_date_label()
-                self._containers.hide_containers()  # TODO: Allow for mixed editing
-
-                self._set_selection_callback()
-
-                self.add_buttons_enabled = True
-
-        except Exception as e:
-            logger.error("[Preview Panel] Error updating selection", error=e)
-            traceback.print_exc()
-
-    @property
-    def add_buttons_enabled(self) -> bool:  # needed for the tests
-        field = self.__add_field_button.isEnabled()
-        tag = self.__add_tag_button.isEnabled()
-        assert field == tag
-        return field
-
-    @add_buttons_enabled.setter
-    def add_buttons_enabled(self, enabled: bool) -> None:
-        self.__add_field_button.setEnabled(enabled)
-        self.__add_tag_button.setEnabled(enabled)
-
-    @property
-    def _file_attributes_widget(self) -> FileAttributes:  # needed for the tests
-        """Getter for the file attributes widget."""
-        return self._file_attrs
-
-    @property
-    def field_containers_widget(self) -> FieldContainers:  # needed for the tests
-        """Getter for the field containers widget."""
-        return self._containers
-
-    @property
-    def preview_thumb(self) -> PreviewThumb:
-        return self._thumb
+        self.addWidget(splitter)
+        self.addWidget(add_buttons_container)
@@ -17,7 +17,7 @@ from tagstudio.core.media_types import MediaType
 from tagstudio.qt.mixed.file_attributes import FileAttributeData
 from tagstudio.qt.mixed.media_player import MediaPlayer
 from tagstudio.qt.platform_strings import open_file_str, trash_term
-from tagstudio.qt.previews.renderer import ThumbRenderer
+from tagstudio.qt.qt_file_renderer import QtFileRenderer
 from tagstudio.qt.translations import Translations
 from tagstudio.qt.views.stylesheets.rounded_pixmap_style import RoundedPixmapStyle

@@ -34,19 +34,24 @@ class PreviewThumbView(QWidget):
    """The Preview Panel Widget."""

    check_ffmpeg = Signal(bool)
+    stats_updated = Signal(Path, FileAttributeData)

    __img_button_size: tuple[int, int]
    __image_ratio: float

-    __filepath: Path | None
+    _current_file: Path | None
+    __should_render_on_resize: bool
    __rendered_res: tuple[int, int]

    def __init__(self, library: Library, driver: "QtDriver") -> None:
        super().__init__()
+        self._driver = driver

        self.__img_button_size = (266, 266)
        self.__image_ratio = 1.0

+        self.__should_render_on_resize = False
+
        self.__image_layout = QStackedLayout(self)
        self.__image_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.__image_layout.setStackingMode(QStackedLayout.StackingMode.StackAll)
@@ -92,6 +97,10 @@ class PreviewThumbView(QWidget):
        self.__media_player.addAction(open_file_action)
        self.__media_player.addAction(open_explorer_action)
        self.__media_player.addAction(delete_action)
+        # QMediaPlayer loads duration asynchronously after setSource().
+        self.__media_player.player.durationChanged.connect(
+            self.__media_player_duration_changed_callback
+        )

        # Need to watch for this to resize the player appropriately.
        self.__media_player.player.hasVideoChanged.connect(
@@ -101,7 +110,7 @@ class PreviewThumbView(QWidget):
        self.__media_player_page = QWidget()
        self.__stacked_page_setup(self.__media_player_page, self.__media_player)

-        self.__thumb_renderer = ThumbRenderer(driver)
+        self.__thumb_renderer = QtFileRenderer(driver.lib, driver.settings)
        self.__thumb_renderer.updated.connect(self.__thumb_renderer_updated_callback)
        self.__thumb_renderer.updated_ratio.connect(self.__thumb_renderer_updated_ratio_callback)

@@ -128,6 +137,16 @@ class PreviewThumbView(QWidget):
    def __media_player_video_changed_callback(self, video: bool) -> None:
        self.__update_image_size((self.size().width(), self.size().height()))

+    def __media_player_duration_changed_callback(self, duration_ms: int) -> None:
+        filepath = self.__media_player.filepath
+        if filepath is None or duration_ms <= 0:
+            return
+
+        self.stats_updated.emit(
+            filepath,
+            FileAttributeData(duration=duration_ms // 1000),
+        )
+
    def __thumb_renderer_updated_callback(
        self, _timestamp: float, img: QPixmap, _size: QSize, _path: Path
    ) -> None:
@@ -142,6 +161,7 @@ class PreviewThumbView(QWidget):
        layout.addWidget(widget)
        layout.setAlignment(widget, Qt.AlignmentFlag.AlignCenter)
        layout.setContentsMargins(0, 0, 0, 0)
+        widget.setCursor(Qt.CursorShape.PointingHandCursor)
        page.setLayout(layout)

    def __update_image_size(self, size: tuple[int, int]) -> None:
@@ -207,31 +227,32 @@ class PreviewThumbView(QWidget):
            self.__preview_gif.hide()

    def __render_thumb(self, filepath: Path) -> None:
-        self.__filepath = filepath
+        self.__should_render_on_resize = True
+
        self.__rendered_res = (
            math.ceil(self.__img_button_size[0] * THUMB_SIZE_FACTOR),
            math.ceil(self.__img_button_size[1] * THUMB_SIZE_FACTOR),
        )

+        # TODO: Make driver update the cache manager reference here instead of passing the driver.
        self.__thumb_renderer.render(
+            self._driver.cache_manager,
            time.time(),
            filepath,
            self.__rendered_res,
            self.devicePixelRatio(),
-            update_on_ratio_change=True,
        )

-    def __update_media_player(self, filepath: Path) -> int:
-        """Display either audio or video.
-
-        Returns the duration of the audio / video.
-        """
+    def __update_media_player(self, filepath: Path) -> None:
+        """Display either audio or video."""
        self.__media_player.play(filepath)
-        return self.__media_player.player.duration() * 1000

    def _display_video(self, filepath: Path, size: QSize | None) -> FileAttributeData:
+        self.__should_render_on_resize = False
+
        self.__switch_preview(MediaType.VIDEO)
-        stats = FileAttributeData(duration=self.__update_media_player(filepath))
+        self.__update_media_player(filepath)
+        stats = FileAttributeData()

        if size is not None:
            stats.width = size.width()
@@ -250,10 +271,13 @@ class PreviewThumbView(QWidget):
    def _display_audio(self, filepath: Path) -> FileAttributeData:
        self.__switch_preview(MediaType.AUDIO)
        self.__render_thumb(filepath)
-        return FileAttributeData(duration=self.__update_media_player(filepath))
+        self.__update_media_player(filepath)
+        return FileAttributeData()

    def _display_gif(self, gif_data: bytes, size: tuple[int, int]) -> FileAttributeData | None:
        """Update the animated image preview from a filepath."""
+        self.__should_render_on_resize = False
+
        stats = FileAttributeData()

        # Ensure that any movie and buffer from previous animations are cleared.
@@ -296,17 +320,26 @@ class PreviewThumbView(QWidget):
    def hide_preview(self) -> None:
        """Completely hide the file preview."""
        self.__switch_preview(None)
-        self.__filepath = None
+        self._current_file = None
+        self.__should_render_on_resize = False

    @override
    def resizeEvent(self, event: QResizeEvent) -> None:
        self.__update_image_size((self.size().width(), self.size().height()))

-        if self.__filepath is not None and self.__rendered_res < self.__img_button_size:
-            self.__render_thumb(self.__filepath)
+        if (
+            self._current_file is not None
+            and self.__should_render_on_resize
+            and self.__rendered_res < self.__img_button_size
+        ):
+            self.__render_thumb(self._current_file)

        return super().resizeEvent(event)

    @property
    def media_player(self) -> MediaPlayer:
        return self.__media_player
+
+    @property
+    def current_file(self) -> Path | None:
+        return self._current_file
@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: (c) TagStudio Contributors
 # SPDX-License-Identifier: GPL-3.0-only

-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING

 from PySide6.QtCore import QSize, Qt
 from PySide6.QtWidgets import (
@@ -16,144 +16,65 @@ from PySide6.QtWidgets import (
    QWidget,
 )

-from tagstudio.core.library.alchemy.library import Library
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelWidget
 from tagstudio.qt.views.stylesheets.stylesheets import list_button_style

 if TYPE_CHECKING:
-    from tagstudio.qt.controllers.search_panel_controller import SearchPanel
+    pass


-class SearchPanelView(PanelWidget):
-    def __init__(self, is_chooser: bool) -> None:
+class SearchPanelView(QVBoxLayout):
+    def __init__(
+        self, placeholder_text: str, create_text: str = "", is_chooser: bool = True
+    ) -> None:
        self.is_chooser: bool = is_chooser
        super().__init__()
-
-        self.__root_layout = QVBoxLayout(self)
-        self.__root_layout.setContentsMargins(6, 0, 6, 0)
-        self.setMinimumSize(300, 400)
+        self.setContentsMargins(6, 0, 6, 0)

        # Limit container
-        self.__limit_container = QWidget()
-        self.__root_layout.addWidget(self.__limit_container)
-
-        self.__limit_layout = QHBoxLayout(self.__limit_container)
-        self.__limit_layout.setContentsMargins(0, 0, 0, 0)
-        self.__limit_layout.setSpacing(12)
-        self.__limit_layout.addStretch(1)
-
-        self.__limit_title = QLabel(Translations["home.search.view_limit"])
-        self.__limit_layout.addWidget(self.__limit_title)
+        self.limit_container = QWidget()
+        self.limit_layout = QHBoxLayout(self.limit_container)
+        self.limit_layout.setContentsMargins(0, 0, 0, 0)
+        self.limit_layout.setSpacing(12)
+        self.limit_layout.addStretch(1)
+        self.limit_title = QLabel(Translations["home.search.view_limit"])
+        self.limit_layout.addWidget(self.limit_title)
+        self.addWidget(self.limit_container)

        # Limit dropdown
        self.limit_combobox = QComboBox()
-        self.__limit_layout.addWidget(self.limit_combobox)
-        self.__limit_layout.addStretch(1)
-
+        self.limit_layout.addWidget(self.limit_combobox)
+        self.limit_layout.addStretch(1)
        self.limit_combobox.setEditable(False)

        # Search field
        self.search_field = QLineEdit()
+        self.search_field.setPlaceholderText(placeholder_text)
        self.search_field.setObjectName("search_field")
-        self.__root_layout.addWidget(self.search_field)
-
        self.search_field.setMinimumSize(QSize(0, 32))
+        self.addWidget(self.search_field)

        # Scroll area
-        self.__scroll_contents = QWidget()
-
-        self._scroll_layout = QVBoxLayout(self.__scroll_contents)
-        self._scroll_layout.setContentsMargins(6, 0, 6, 0)
-        self._scroll_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
-
-        self.__scroll_area = QScrollArea()
-        self.__scroll_area.setWidget(self.__scroll_contents)
-        self.__root_layout.addWidget(self.__scroll_area)
-
-        self.__scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOn)
-        self.__scroll_area.setWidgetResizable(True)
-        self.__scroll_area.setFrameShadow(QFrame.Shadow.Plain)
-        self.__scroll_area.setFrameShape(QFrame.Shape.NoFrame)
+        self.scroll_contents = QWidget()
+        self.scroll_layout = QVBoxLayout(self.scroll_contents)
+        self.scroll_layout.setContentsMargins(6, 0, 6, 0)
+        self.scroll_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
+        self.scroll_area = QScrollArea()
+        self.scroll_area.setWidget(self.scroll_contents)
+        self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOn)
+        self.scroll_area.setWidgetResizable(True)
+        self.scroll_area.setFrameShadow(QFrame.Shadow.Plain)
+        self.scroll_area.setFrameShape(QFrame.Shape.NoFrame)
+        self.addWidget(self.scroll_area)

        # Create button
-        self.create_button = QPushButton("")
-
+        self.create_button = QPushButton(create_text)
        if not self.is_chooser:
-            self.__root_layout.addWidget(self.create_button)
+            self.addWidget(self.create_button)

        # Create and add button
        self.create_and_add_button_in_layout: bool = False
-
        self.create_and_add_button = QPushButton()
        self.create_and_add_button.setFlat(True)
        self.create_and_add_button.setMinimumSize(22, 22)
        self.create_and_add_button.setStyleSheet(list_button_style(border_style="dashed"))
-
-    @property
-    def scroll_layout(self) -> QVBoxLayout:
-        return self._scroll_layout
-
-    @property
-    def scroll_area(self) -> QScrollArea:
-        return self.__scroll_area
-
-    def connect_callbacks(self, controller: "SearchPanel[Any]") -> None:  # pyright: ignore[reportExplicitAny]
-        self.limit_combobox.currentIndexChanged.connect(controller.on_limit_changed)
-
-        self.search_field.textChanged.connect(controller.on_search_query_changed)
-        self.search_field.returnPressed.connect(
-            lambda: controller.on_search_query_submitted(self.get_search_query())
-        )
-
-        self.create_button.clicked.connect(controller.on_item_create)
-        self.create_and_add_button.clicked.connect(
-            lambda: controller.on_item_create(add_to_entry=True)
-        )
-
-    def set_limit_items(self, limit_items: list[tuple[str, int]]) -> None:
-        # Remove existing limit items
-        for i in reversed(range(self.limit_combobox.count())):
-            self.limit_combobox.removeItem(i)
-
-        # Add new limit items
-        self.limit_combobox.addItems([limit_item[0] for limit_item in limit_items])
-
-    def get_limit_index(self) -> int:
-        return self.limit_combobox.currentIndex()
-
-    def set_limit_index(self, index: int) -> None:
-        self.limit_combobox.setCurrentIndex(index)
-
-    def focus_search_box(self, select_all: bool = False) -> None:
-        self.search_field.setFocus()
-        if select_all:
-            self.search_field.selectAll()
-
-    def get_search_query(self) -> str:
-        return self.search_field.text()
-
-    def clear_search_query(self) -> None:
-        self.search_field.setText("")
-        self.focus_search_box()
-
-    # Item list
-    def scroll_to(self, position: int) -> None:
-        self.__scroll_area.verticalScrollBar().setValue(position)
-
-    def get_item_widget(self, index: int, library: Library | None) -> Any:  # pyright: ignore[reportUnusedParameter, reportExplicitAny]
-        raise NotImplementedError()
-
-    def add_create_and_add_button(self) -> None:
-        if self.create_and_add_button_in_layout:
-            return
-        self._scroll_layout.addWidget(self.create_and_add_button)
-        self.create_and_add_button.show()
-        self.create_and_add_button_in_layout = True
-
-    def remove_create_and_add_button(self) -> None:
-        if not self.create_and_add_button_in_layout:
-            return
-        self._scroll_layout.removeWidget(self.create_and_add_button)
-        self.create_and_add_button.hide()
-        self.create_and_add_button_in_layout = False
@@ -10,7 +10,7 @@ from PySide6.QtCore import QRect, Qt
 from PySide6.QtGui import QColor, QFont, QPainter, QPen, QPixmap
 from PySide6.QtWidgets import QSplashScreen, QWidget

-from tagstudio.core.constants import COPYRIGHT, COPYRIGHT_COMPACT, VERSION, VERSION_BRANCH
+from tagstudio.core.constants import BUILD_TYPE, COPYRIGHT, COPYRIGHT_COMPACT, VERSION
 from tagstudio.qt.global_settings import Splash
 from tagstudio.qt.resource_manager import ResourceManager
 from tagstudio.qt.translations import Translations
@@ -21,7 +21,12 @@ logger = structlog.get_logger(__name__)
 class SplashScreen:
    """The custom splash screen widget for TagStudio."""

-    VERSION_STR: str = f"{Translations['about.version']} {VERSION} {(' (' + VERSION_BRANCH + ')') if VERSION_BRANCH else ''}"  # noqa: E501
+    VERSION_STR: str = " ".join(
+        [
+            f"{Translations['about.version']}",
+            f"{VERSION} {(' (' + Translations[BUILD_TYPE] + ')') if BUILD_TYPE else ''}",
+        ]
+    )
    DEFAULT_SPLASH = Splash.AURORA

    def __init__(
@@ -8,7 +8,7 @@ from PySide6.QtGui import QColor, QGuiApplication
 from tagstudio.core.enums import Theme
 from tagstudio.core.library.alchemy.enums import TagColorEnum
 from tagstudio.core.library.alchemy.models import Tag
-from tagstudio.qt.models.palette import ColorType, UiColor, get_tag_color, get_ui_color
+from tagstudio.qt.models.palette import ColorType, Palette, UiColor, get_tag_color, get_ui_color

 # TODO: There's plenty of good opportunities here to consolidate similar styles.
 # Work should be done to more closely use Qt's theming systems rather than override them.
@@ -53,18 +53,29 @@ def button_style() -> str:
        border-radius: 6px;
        font-weight: 500;
        text-align: center;
+        padding: 0px 12px;
    }}
    QPushButton::hover{{
        background-color: {Theme.COLOR_HOVER.value};
-        border-color: {get_ui_color(ColorType.BORDER, UiColor.THEME_DARK)};
        border-style: solid;
        border-width: 2px;
+        border-color: {get_ui_color(ColorType.BORDER, UiColor.THEME_DARK)};
+        padding: 0px 8px;
    }}
    QPushButton::pressed{{
-        background-color: {Theme.COLOR_PRESSED.value};
-        border-color: {get_ui_color(ColorType.LIGHT_ACCENT, UiColor.THEME_DARK)};
+        outline: none;
+        background-color: palette(light);
        border-style: solid;
        border-width: 2px;
+        border-color: {get_ui_color(ColorType.BORDER, UiColor.THEME_DARK)};
+        padding: 0px 8px;
+    }}
+    QPushButton::focus{{
+        outline: none;
+        border: solid;
+        border-width: 2px;
+        border-color: rgba{Palette.accent().toTuple()};
+        padding: 0px 8px;
    }}
    QPushButton::disabled{{
        background-color: {Theme.COLOR_DISABLED_BG.value};
@@ -72,6 +83,40 @@ def button_style() -> str:
 """


+def line_edit_style_main() -> str:
+    """Style used for common QLineEdits."""
+    bg_color = (
+        Theme.COLOR_BG_DARK.value
+        if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+        else Theme.COLOR_BG_LIGHT.value
+    )
+
+    return f"""
+    QLineEdit{{
+        background: {bg_color};
+        border-radius: 6px;
+        font-weight: 500;
+        text-align: center;
+        padding: 0px 4px;
+    }}
+    QLineEdit::hover{{
+        border-style: solid;
+        border-width: 2px;
+        border-color: {get_ui_color(ColorType.BORDER, UiColor.THEME_DARK)};
+        padding: 0px 2px;
+    }}
+    QLineEdit::focus{{
+        border-style: solid;
+        border-width: 2px;
+        border-color: rgba{Palette.accent().toTuple()};
+        padding: 0px 2px;
+    }}
+    QLineEdit::disabled{{
+        background-color: {Theme.COLOR_DISABLED_BG.value};
+    }}
+"""
+
+
 def checkbox_style() -> str:
    """Style used for QCheckBoxes."""
    primary_color = QColor(get_tag_color(ColorType.PRIMARY, TagColorEnum.DEFAULT))
@@ -229,6 +274,7 @@ def line_edit_style() -> str:
 def list_button_style(
    color: QColor | None = None,
    border_style: str = "solid",
+    italic: bool = False,
 ) -> str:
    """Style used for special QPushButtons found in lists."""
    if color is None:
@@ -243,6 +289,7 @@ def list_button_style(
        background: rgba{color.toTuple()};
        color: rgba{text_color.toTuple()};
        font-weight: 600;
+        {"font: italic;" if italic else ""}
        border-color: rgba{border_color.toTuple()};
        border-radius: 6px;
        border-style: {border_style};
@@ -310,9 +357,9 @@ def tag_style(
        border-radius: 6px;
        border-style: {border_style};
        border-width: 2px;
+        font-size: 13px;
        padding-right: 4px;
        padding-left: 4px;
-        font-size: 13px
    }}
    QPushButton::hover{{
        border-color: rgba{highlight_color.toTuple()};
@@ -323,12 +370,9 @@ def tag_style(
        border-color: rgba{primary_color.toTuple()};
    }}
    QPushButton::focus{{
-        padding-right: 0px;
-        padding-left: 0px;
-        outline-style: solid;
-        outline-width: 1px;
-        outline-radius: 4px;
-        outline-color: rgba{text_color.toTuple()};
+        outline: none;
+        border-width: 3px;
+        border-color: rgba{text_color.toTuple()};
    }}
    """

@@ -366,6 +410,13 @@ def tag_remove_button_style(
    """


+def widget_underline_style() -> str:
+    return f"""
+        background: rgba{Palette.accent().toTuple()};
+        border-radius: 2px;
+    """
+
+
 def title_line_edit_style() -> str:
    """Used to mimic an H3-like header style inside a QLineEdit."""
    return """
@@ -374,6 +425,110 @@ def title_line_edit_style() -> str:
    """


+def inset_container_style(object_name: str = "") -> str:
+    """Used for darkened inset areas."""
+    bg_color = (
+        Theme.COLOR_BG_DARK.value
+        if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+        else Theme.COLOR_BG_LIGHT.value
+    )
+
+    return f"""
+    QWidget{"#" + object_name if object_name else ""}{{
+        background: {bg_color};
+        border-radius: 6px;
+        }}
+    """
+
+
+# TODO: Combine the autofill styles into one method?
+def autofill_scroll_top_style(object_name: str = "") -> str:
+    """Used autofill lists positioned on top of line edits."""
+    bg_color = (
+        Theme.COLOR_BG_DARK.value
+        if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+        else Theme.COLOR_BG_LIGHT.value
+    )
+
+    return f"""
+    QWidget{"#" + object_name if object_name else ""}{{
+        background: {bg_color};
+        border-top-left-radius: 6px;
+        border-top-right-radius: 6px;
+        border: none;
+        }}
+    """
+
+
+def autofill_scroll_top_focus_style(object_name: str = "") -> str:
+    """Used autofill lists positioned on top of line edits."""
+    bg_color = (
+        Theme.COLOR_BG_DARK.value
+        if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+        else Theme.COLOR_BG_LIGHT.value
+    )
+
+    return f"""
+    QWidget{"#" + object_name if object_name else ""}{{
+        background: {bg_color};
+        border-top-left-radius: 6px;
+        border-top-right-radius: 6px;
+        border: solid;
+        border-width: 2px 2px 0px 2px;
+        border-color: rgba{Palette.accent().toTuple()};
+        }}
+    """
+
+
+def autofill_line_edit_style() -> str:
+    """Used for QLineEdits."""
+    bg_color = (
+        Theme.COLOR_BG_DARK.value
+        if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+        else Theme.COLOR_BG_LIGHT.value
+    )
+
+    return f"""
+    QLineEdit{{
+        background: {bg_color};
+        border-radius: 6px;
+        padding: 3px 6px;
+        }}
+    QLineEdit::focus{{
+        padding: 4px 4px;
+        border: solid;
+        border-width: 2px;
+        border-color: rgba{Palette.accent().toTuple()};
+        }}
+    """
+
+
+def autofill_line_edit_top_style() -> str:
+    """Used for QLineEdits when there's a top autofill section present."""
+    bg_color = (
+        Theme.COLOR_BG_DARK.value
+        if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+        else Theme.COLOR_BG_LIGHT.value
+    )
+
+    return f"""
+    QLineEdit{{
+        background: {bg_color};
+        border-top-left-radius: 0px;
+        border-top-right-radius: 0px;
+        border-bottom-left-radius: 6px;
+        border-bottom-right-radius: 6px;
+        padding: 0px 0px 2px 6px;
+        }}
+    QLineEdit::focus{{
+        padding: 4px 4px;
+        border: solid;
+        border-width: 0px 2px 2px 2px;
+        border-color: rgba{Palette.accent().toTuple()};
+        }}
+    """
+
+
 def preview_warning_style() -> str:
    return f"""
    QWidget#ffmpeg_widget {{
@@ -0,0 +1,80 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import structlog
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QPixmap
+from PySide6.QtWidgets import QFrame, QHBoxLayout, QSizePolicy, QVBoxLayout, QWidget
+
+from tagstudio.qt.controllers.autofill_line_edit import AutofillLineEdit
+from tagstudio.qt.controllers.horizontal_scroll_area import HorizontalScrollArea
+from tagstudio.qt.views.stylesheets.stylesheets import (
+    autofill_line_edit_style,
+    autofill_scroll_top_style,
+)
+
+logger = structlog.get_logger(__name__)
+
+
+class SuggestBoxView(QVBoxLayout):
+    def __init__(self, placeholder_text: str = "") -> None:
+        super().__init__()
+
+        self.setContentsMargins(0, 0, 0, 0)
+        self.setSpacing(0)
+
+        scroll_area_style = """
+        QScrollArea{
+            background: transparent;
+            }
+        QScrollArea > QWidget > QWidget{
+            background: transparent;
+            }
+        """
+
+        # Autocomplete ScrollArea
+        contents = QWidget()
+        self.content_layout = QHBoxLayout(contents)
+        self.content_layout.setSpacing(6)
+        self.content_layout.setAlignment(Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignLeft)
+        self.content_layout.setContentsMargins(0, 0, 0, 0)
+        scroll_area_container = QWidget()
+        scroll_area_container.setObjectName("container")
+        scroll_area_container_layout = QHBoxLayout(scroll_area_container)
+        scroll_area_container_layout.setContentsMargins(0, 0, 0, 0)
+        scroll_area_container_layout.setSpacing(0)
+        scroll_area_container.setStyleSheet(autofill_scroll_top_style("container"))
+        self.scroll_area = HorizontalScrollArea()
+        self.scroll_area.setStyleSheet(scroll_area_style)
+        self.scroll_area.setViewportMargins(2, 0, 2, 0)
+        scroll_area_container_layout.addWidget(self.scroll_area)
+        self.scroll_area.setWidget(contents)
+        search_bar_height = 28
+        underline_padding = 7
+        self.scroll_area.setMaximumHeight(search_bar_height + underline_padding)
+        self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.scroll_area.verticalScrollBar().setEnabled(False)
+        self.scroll_area.setContentsMargins(0, 0, 0, 0)
+        self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.scroll_area.setWidgetResizable(True)
+        self.scroll_area.setFrameShadow(QFrame.Shadow.Plain)
+        self.scroll_area.setFrameShape(QFrame.Shape.NoFrame)
+        self.scroll_area.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
+
+        # Search Field
+        self.search_field = AutofillLineEdit(scroll_area_container)
+        self.search_field.setStyleSheet(autofill_line_edit_style())
+        self.search_field.setObjectName("search_field")
+        self.search_field.setMinimumHeight(search_bar_height)
+        self.search_field.setPlaceholderText(placeholder_text)
+        self.hint_icon_action = self.search_field.addAction(
+            QPixmap(), AutofillLineEdit.ActionPosition.TrailingPosition
+        )
+        self.scroll_area.setFocusProxy(self.search_field)
+        self.search_field.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.search_field.customContextMenuRequested.connect(self.search_field.show_action_menu)
+
+        # Finalize Layout
+        self.addWidget(scroll_area_container)
+        self.addWidget(self.search_field)
@@ -39,17 +39,12 @@ class TagBoxWidgetView(FieldWidget):

        for tag in tags_:
            tag_widget = TagWidget(tag, library=self.__lib, has_edit=True, has_remove=True)
-
            tag_widget.on_click.connect(lambda t=tag: self._on_click(t))
-
            tag_widget.on_remove.connect(lambda t=tag: self._on_remove(t))
-
            tag_widget.on_edit.connect(lambda t=tag: self._on_edit(t))
-
            tag_widget.search_for_tag_action.triggered.connect(
                lambda checked=False, t=tag: self._on_search(t)
            )
-
            self.__root_layout.addWidget(tag_widget)

    def _on_click(self, tag: Tag) -> None:
@@ -1,32 +0,0 @@
-# SPDX-FileCopyrightText: (c) TagStudio Contributors
-# SPDX-License-Identifier: GPL-3.0-only
-
-from PySide6.QtWidgets import QWidget
-
-from tagstudio.core.library.alchemy.library import Library
-from tagstudio.qt.mixed.tag_widget import TagWidget
-from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.search_panel_view import SearchPanelView
-
-
-class TagSearchPanelView(SearchPanelView):
-    def __init__(self, is_tag_chooser: bool) -> None:
-        super().__init__(is_tag_chooser)
-
-        self.search_field.setPlaceholderText(Translations["home.search_tags"])
-        self.create_button.setText(Translations["tag.create"])
-
-    def get_item_widget(self, index: int, library: Library | None) -> TagWidget:
-        """Gets the item widget at a specific index."""
-        # Create any new item widgets needed up to the given index
-        if self._scroll_layout.count() <= index:
-            while self._scroll_layout.count() <= index:
-                pad_tag_widget = TagWidget(
-                    tag=None, has_edit=True, has_remove=True, library=library
-                )
-                pad_tag_widget.setHidden(True)
-                self._scroll_layout.addWidget(pad_tag_widget)
-
-        tag_widget: QWidget = self._scroll_layout.itemAt(index).widget()
-        assert isinstance(tag_widget, TagWidget)
-        return tag_widget
@@ -2,7 +2,6 @@
 # SPDX-License-Identifier: GPL-3.0-only


-import sys
 from typing import override

 from PySide6 import QtCore
@@ -13,11 +12,12 @@ from PySide6.QtGui import (
    QPainter,
    QPainterPath,
    QPaintEvent,
-    QPalette,
    QPen,
 )
 from PySide6.QtWidgets import QPushButton, QWidget

+from tagstudio.qt.models.palette import Palette
+

 class ThumbButton(QPushButton):
    def __init__(self, parent: QWidget, thumb_size: tuple[int, int]) -> None:
@@ -25,30 +25,9 @@ class ThumbButton(QPushButton):
        self.thumb_size: tuple[int, int] = thumb_size
        self.hovered = False
        self.selected = False
+        self.select_color = Palette.accent()

-        # NOTE: As of PySide 6.8.0.1, the QPalette.ColorRole.Accent role no longer works on Windows.
-        # The QPalette.ColorRole.AlternateBase does for some reason, but not on macOS.
-        self.select_color: QColor
-        if sys.platform == "win32":
-            self.select_color = QPalette.color(
-                self.palette(),
-                QPalette.ColorGroup.Active,
-                QPalette.ColorRole.AlternateBase,
-            )
-            self.select_color.setHsl(
-                self.select_color.hslHue(),
-                self.select_color.hslSaturation(),
-                max(self.select_color.lightness(), 100),
-                255,
-            )
-        else:
-            self.select_color = QPalette.color(
-                self.palette(),
-                QPalette.ColorGroup.Active,
-                QPalette.ColorRole.Accent,
-            )
-
-        self.select_color_faded: QColor = QColor(self.select_color)
+        self.select_color_faded = Palette.accent()
        self.select_color_faded.setHsl(
            self.select_color_faded.hslHue(),
            self.select_color_faded.hslSaturation(),
@@ -56,26 +35,7 @@ class ThumbButton(QPushButton):
            127,
        )

-        self.hover_color: QColor
-        if sys.platform == "win32":
-            self.hover_color = QPalette.color(
-                self.palette(),
-                QPalette.ColorGroup.Active,
-                QPalette.ColorRole.AlternateBase,
-            )
-            self.hover_color.setHsl(
-                self.hover_color.hslHue(),
-                self.hover_color.hslSaturation(),
-                max(self.hover_color.lightness(), 100),
-                255,
-            )
-        else:
-            self.hover_color = QPalette.color(
-                self.palette(),
-                QPalette.ColorGroup.Active,
-                QPalette.ColorRole.Accent,
-            )
-
+        self.hover_color = Palette.accent()
        self.hover_color.setHsl(
            self.hover_color.hslHue(),
            self.hover_color.hslSaturation(),
--- a/Show More
+++ b/Show More