Bump version

Add Authelia OIDC example to docs (#675 )
Replace django-background-tasks with huey (#657 )
2025-08-15 06:29:21 +02:00 · 2024-04-07 13:06:51 +02:00 · 2024-04-07 11:12:12 +02:00 · 2024-04-07 11:11:14 +02:00 · 2024-04-07 11:05:48 +02:00 · 2024-04-01 16:04:40 +02:00
289 changed files with 19621 additions and 7048 deletions
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,29 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/python
+{
+	"name": "Python 3",
+	"image": "mcr.microsoft.com/devcontainers/python:0-3.10",
+	"features": {
+		"ghcr.io/devcontainers/features/node:1": {}
+	},
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	"forwardPorts": [8000],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "pip3 install --user -r requirements.txt -r requirements.dev.txt && npm install && mkdir -p data && python3 manage.py migrate",
+
+	// Configure tool-specific properties.
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"ms-python.python"
+			]
+		}
+	},
+
+	"remoteUser": "vscode"
+}
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,31 +1,21 @@
-# Remove project files, data, tmp files, build files
-/.env
-/.idea
-/data
-/node_modules
-/tmp
-/docs
-/static
-/build
-/out
-/.git
+# Ignore everything
+*

-/.dockerignore
-/.gitignore
-/Dockerfile
-/docker-compose.yml
-/*.sh
-/*.iml
-/*.patch
-/*.md
-/*.js
-/*.log
-/*.pid
+# Include files required for build or at runtime
+!/bookmarks
+!/siteroot

-# Whitelist files needed in build or prod image
-!/rollup.config.js
 !/bootstrap.sh
-!/background-tasks-wrapper.sh
+!/LICENSE.txt
+!/manage.py
+!/package.json
+!/package-lock.json
+!/requirements.dev.txt
+!/requirements.txt
+!/rollup.config.mjs
+!/supervisord.conf
+!/uwsgi.ini
+!/version.txt

-# Remove development settings
+ # Remove dev settings
 /siteroot/settings/dev.py
--- a/.gitattributes
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+* text=auto
+*.sh text eol=lf
--- a/.github/workflows/main.yaml
+++ b/.github/workflows/main.yaml
@@ -1,47 +1,59 @@
 name: linkding CI

-on: [push]
+on:
+  pull_request:
+  push:
+    branches:
+      - master

 jobs:
  unit_tests:
    name: Unit Tests
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
        with:
          python-version: "3.10"
      - name: Set up Node
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
        with:
-          node-version: 18
+          node-version: 20
+          cache: 'npm'
      - name: Install Node dependencies
-        run: npm install
+        run: npm ci
      - name: Setup Python environment
-        run: pip install -r requirements.txt
+        run: |
+          pip install -r requirements.txt -r requirements.dev.txt
+          mkdir data
      - name: Run tests
        run: python manage.py test bookmarks.tests
  e2e_tests:
    name: E2E Tests
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
        with:
          python-version: "3.10"
      - name: Set up Node
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
        with:
-          node-version: 18
+          node-version: 20
+          cache: 'npm'
      - name: Install Node dependencies
-        run: npm install
+        run: npm ci
      - name: Setup Python environment
        run: |
-          pip install -r requirements.txt
+          pip install -r requirements.txt -r requirements.dev.txt
          playwright install chromium
+          mkdir data
+      - name: Run build
+        run: |
+          npm run build
          python manage.py compilescss
          python manage.py collectstatic --ignore=*.scss
      - name: Run tests
-        run: python manage.py test bookmarks.e2e
+        run: python manage.py test bookmarks.e2e --pattern="e2e_test_*.py"
--- a/.grenrc.js
+++ b/.grenrc.js
@@ -1,6 +0,0 @@
-module.exports = {
-    ignoreIssuesWith: [
-        "wontfix",
-        "duplicate"
-    ]
-}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,267 @@
 # Changelog

+## v1.27.0 (01/04/2024)
+
+### What's Changed
+* Archive snapshots of websites locally by @sissbruecker in https://github.com/sissbruecker/linkding/pull/672
+* Add Railway hosting option by @tianheg in https://github.com/sissbruecker/linkding/pull/661
+* Add how to for increasing the font size by @sissbruecker in https://github.com/sissbruecker/linkding/pull/667
+
+### New Contributors
+* @tianheg made their first contribution in https://github.com/sissbruecker/linkding/pull/661
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.26.0...v1.27.0
+
+---
+
+## v1.26.0 (30/03/2024)
+
+### What's Changed
+* Add option for showing bookmark description as separate block by @sissbruecker in https://github.com/sissbruecker/linkding/pull/663
+* Add bookmark details view by @sissbruecker in https://github.com/sissbruecker/linkding/pull/665
+* Make bookmark list actions configurable by @sissbruecker in https://github.com/sissbruecker/linkding/pull/666
+* Bump black from 24.1.1 to 24.3.0 by @dependabot in https://github.com/sissbruecker/linkding/pull/662
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.25.0...v1.26.0
+
+---
+
+## v1.25.0 (18/03/2024)
+
+### What's Changed
+* Improve PWA capabilities by @hugo-vrijswijk in https://github.com/sissbruecker/linkding/pull/630
+* build improvements by @hugo-vrijswijk in https://github.com/sissbruecker/linkding/pull/649
+* Add support for oidc by @Nighmared in https://github.com/sissbruecker/linkding/pull/389
+* Add option for custom CSS by @sissbruecker in https://github.com/sissbruecker/linkding/pull/652
+* Update backup location to safe directory by @bphenriques in https://github.com/sissbruecker/linkding/pull/653
+* Include web archive link in /api/bookmarks/ by @sissbruecker in https://github.com/sissbruecker/linkding/pull/655
+* Add RSS feeds for shared bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/656
+* Bump django from 5.0.2 to 5.0.3 by @dependabot in https://github.com/sissbruecker/linkding/pull/658
+
+### New Contributors
+* @hugo-vrijswijk made their first contribution in https://github.com/sissbruecker/linkding/pull/630
+* @Nighmared made their first contribution in https://github.com/sissbruecker/linkding/pull/389
+* @bphenriques made their first contribution in https://github.com/sissbruecker/linkding/pull/653
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.24.2...v1.25.0
+
+---
+
+## v1.24.2 (16/03/2024)
+
+### What's Changed
+* Fix logout button by @sissbruecker in https://github.com/sissbruecker/linkding/pull/648
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.24.1...v1.24.2
+
+---
+
+## v1.24.1 (16/03/2024)
+
+### What's Changed
+* Bump dependencies by @sissbruecker in https://github.com/sissbruecker/linkding/pull/618
+* Persist secret key in data folder by @sissbruecker in https://github.com/sissbruecker/linkding/pull/620
+* Group ideographic characters in tag cloud by @jonathan-s in https://github.com/sissbruecker/linkding/pull/613
+* Bump django from 5.0.1 to 5.0.2 by @dependabot in https://github.com/sissbruecker/linkding/pull/625
+* Add k8s setup to community section by @jzck in https://github.com/sissbruecker/linkding/pull/633
+* Added a new Linkding client to community section by @JGeek00 in https://github.com/sissbruecker/linkding/pull/638
+
+### New Contributors
+* @jzck made their first contribution in https://github.com/sissbruecker/linkding/pull/633
+* @JGeek00 made their first contribution in https://github.com/sissbruecker/linkding/pull/638
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.24.0...v1.24.1
+
+---
+
+## v1.24.0 (27/01/2024)
+
+### What's Changed
+* Support Open Graph description by @jonathan-s in https://github.com/sissbruecker/linkding/pull/602
+* Add tooltip to truncated bookmark titles by @jonathan-s in https://github.com/sissbruecker/linkding/pull/607
+* Improve bulk tag performance by @sissbruecker in https://github.com/sissbruecker/linkding/pull/612
+* Increase tag limit in tag autocomplete by @hypebeast in https://github.com/sissbruecker/linkding/pull/581
+* Add CapRover as managed hosting option by @adamshand in https://github.com/sissbruecker/linkding/pull/585
+* Bump playwright dependencies by @jonathan-s in https://github.com/sissbruecker/linkding/pull/601
+* Adjust archive.org donation link in general.html by @JnsDornbusch in https://github.com/sissbruecker/linkding/pull/603
+
+### New Contributors
+* @hypebeast made their first contribution in https://github.com/sissbruecker/linkding/pull/581
+* @adamshand made their first contribution in https://github.com/sissbruecker/linkding/pull/585
+* @jonathan-s made their first contribution in https://github.com/sissbruecker/linkding/pull/601
+* @JnsDornbusch made their first contribution in https://github.com/sissbruecker/linkding/pull/603
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.23.1...v1.24.0
+
+---
+
+## v1.23.1 (08/12/2023)
+
+### What's Changed
+* Properly encode search query param by @sissbruecker in https://github.com/sissbruecker/linkding/pull/587
+
+> [!WARNING] 
+> *This resolves a security vulnerability in linkding. Everyone is encouraged to upgrade to the latest version as soon as possible.*
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.23.0...v1.23.1
+
+---
+
+## v1.23.0 (24/11/2023)
+
+### What's Changed
+* Add Alpine based Docker image (experimental) by @sissbruecker in https://github.com/sissbruecker/linkding/pull/570
+* Add backup CLI command by @sissbruecker in https://github.com/sissbruecker/linkding/pull/571
+* Update browser extension links by @OPerepadia in https://github.com/sissbruecker/linkding/pull/574
+* Include archived bookmarks in export by @sissbruecker in https://github.com/sissbruecker/linkding/pull/579
+
+### New Contributors
+* @OPerepadia made their first contribution in https://github.com/sissbruecker/linkding/pull/574
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.3...v1.23.0
+
+---
+
+## v1.22.3 (04/11/2023)
+
+### What's Changed
+* Fix RSS feed not handling None values  by @vitormarcal in https://github.com/sissbruecker/linkding/pull/569
+* Bump django from 4.1.10 to 4.1.13 by @dependabot in https://github.com/sissbruecker/linkding/pull/567
+
+### New Contributors
+* @vitormarcal made their first contribution in https://github.com/sissbruecker/linkding/pull/569
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.2...v1.22.3
+
+---
+
+## v1.22.2 (27/10/2023)
+
+### What's Changed
+* Fix search options not opening on iOS by @sissbruecker in https://github.com/sissbruecker/linkding/pull/549
+* Bump urllib3 from 1.26.11 to 1.26.17 by @dependabot in https://github.com/sissbruecker/linkding/pull/542
+* Add iOS shortcut to community section by @andrewdolphin in https://github.com/sissbruecker/linkding/pull/550
+* Disable editing of search preferences in user admin by @sissbruecker in https://github.com/sissbruecker/linkding/pull/555
+* Add feed2linkding to community section by @Strubbl in https://github.com/sissbruecker/linkding/pull/544
+* Sanitize RSS feed to remove control characters by @sissbruecker in https://github.com/sissbruecker/linkding/pull/565
+* Bump urllib3 from 1.26.17 to 1.26.18 by @dependabot in https://github.com/sissbruecker/linkding/pull/560
+
+### New Contributors
+* @andrewdolphin made their first contribution in https://github.com/sissbruecker/linkding/pull/550
+* @Strubbl made their first contribution in https://github.com/sissbruecker/linkding/pull/544
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.1...v1.22.2
+
+---
+
+## v1.22.1 (06/10/2023)
+
+### What's Changed
+* Fix memory leak with SQLite by @sissbruecker in https://github.com/sissbruecker/linkding/pull/548
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.0...v1.22.1
+
+---
+
+## v1.22.0 (01/10/2023)
+
+### What's Changed
+* Fix case-insensitive search for unicode characters in SQLite by @sissbruecker in https://github.com/sissbruecker/linkding/pull/520
+* Add sort option to bookmark list by @sissbruecker in https://github.com/sissbruecker/linkding/pull/522
+* Add button to show tags on smaller screens by @sissbruecker in https://github.com/sissbruecker/linkding/pull/529
+* Make code blocks in notes scrollable by @sissbruecker in https://github.com/sissbruecker/linkding/pull/530
+* Add filter for shared state by @sissbruecker in https://github.com/sissbruecker/linkding/pull/531
+* Add support for exporting/importing bookmark notes by @sissbruecker in https://github.com/sissbruecker/linkding/pull/532
+* Add filter for unread state by @sissbruecker in https://github.com/sissbruecker/linkding/pull/535
+* Allow saving search preferences by @sissbruecker in https://github.com/sissbruecker/linkding/pull/540
+* Add user profile endpoint by @sissbruecker in https://github.com/sissbruecker/linkding/pull/541
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.21.0...v1.22.0
+
+---
+
+## v1.21.1 (26/09/2023)
+
+### What's Changed
+* Fix bulk edit to respect searched tags by @sissbruecker in https://github.com/sissbruecker/linkding/pull/537
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.21.0...v1.21.1
+
+---
+
+## v1.21.0 (25/08/2023)
+
+### What's Changed
+* Make search autocomplete respect link target setting by @sissbruecker in https://github.com/sissbruecker/linkding/pull/513
+* Various CSS improvements by @sissbruecker in https://github.com/sissbruecker/linkding/pull/514
+* Display shared state in bookmark list by @sissbruecker in https://github.com/sissbruecker/linkding/pull/515
+* Allow bulk editing unread and shared state of bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/517
+* Bump uwsgi from 2.0.20 to 2.0.22 by @dependabot in https://github.com/sissbruecker/linkding/pull/516
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.20.1...v1.21.0
+
+---
+
+## v1.20.1 (23/08/2023)
+
+### What's Changed
+* Update cached styles and scripts after version change by @sissbruecker in https://github.com/sissbruecker/linkding/pull/510
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.20.0...v1.20.1
+
+---
+
+## v1.20.0 (22/08/2023)
+
+### What's Changed
+* Add option to share bookmarks publicly by @sissbruecker in https://github.com/sissbruecker/linkding/pull/503
+* Various improvements to favicons by @sissbruecker in https://github.com/sissbruecker/linkding/pull/504
+* Add support for PRIVATE flag in import and export by @sissbruecker in https://github.com/sissbruecker/linkding/pull/505
+* Avoid page reload when triggering actions in bookmark list by @sissbruecker in https://github.com/sissbruecker/linkding/pull/506
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.19.1...v1.20.0
+
+---
+
+## v1.19.1 (29/07/2023)
+
+### What's Changed
+* Add Postman Collection to Community section of README by @gingerbeardman in https://github.com/sissbruecker/linkding/pull/476
+* Added Dev Container support by @acbgbca in https://github.com/sissbruecker/linkding/pull/474
+* Added Apple web-app meta tag #358 by @acbgbca in https://github.com/sissbruecker/linkding/pull/359
+* Bump requests from 2.28.1 to 2.31.0 by @dependabot in https://github.com/sissbruecker/linkding/pull/478
+* Allow passing title and description to new bookmark form by @acbgbca in https://github.com/sissbruecker/linkding/pull/479
+* Enable WAL to avoid locked database lock errors by @sissbruecker in https://github.com/sissbruecker/linkding/pull/480
+* Fix website loader content encoding detection by @sissbruecker in https://github.com/sissbruecker/linkding/pull/482
+* Bump certifi from 2022.12.7 to 2023.7.22 by @dependabot in https://github.com/sissbruecker/linkding/pull/497
+* Bump django from 4.1.9 to 4.1.10 by @dependabot in https://github.com/sissbruecker/linkding/pull/494
+
+### New Contributors
+* @gingerbeardman made their first contribution in https://github.com/sissbruecker/linkding/pull/476
+* @acbgbca made their first contribution in https://github.com/sissbruecker/linkding/pull/474
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.19.0...v1.19.1
+
+---
+
+## v1.19.0 (20/05/2023)
+
+### What's Changed
+* Add notes to bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/472
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.18.0...v1.19.0
+
+---
+
 ## v1.18.0 (18/05/2023)

 ### What's Changed
--- a/58
+++ b/58
@@ -1,58 +0,0 @@
-FROM node:18.13.0-alpine AS node-build
-WORKDIR /etc/linkding
-# install build dependencies
-COPY package.json package-lock.json ./
-RUN npm install -g npm && \
-    npm install
-# compile JS components
-COPY . .
-RUN npm run build
-
-
-FROM python:3.10.6-slim-buster AS python-base
-RUN apt-get update && apt-get -y install build-essential libpq-dev
-WORKDIR /etc/linkding
-
-
-FROM python-base AS python-build
-# install build dependencies
-COPY requirements.txt requirements.txt
-RUN pip install -U pip && pip install -Ur requirements.txt
-# run Django part of the build
-COPY --from=node-build /etc/linkding .
-RUN python manage.py compilescss && \
-    python manage.py collectstatic --ignore=*.scss && \
-    python manage.py compilescss --delete-files
-
-
-FROM python-base AS prod-deps
-COPY requirements.prod.txt ./requirements.txt
-RUN mkdir /opt/venv && \
-    python -m venv --upgrade-deps --copies /opt/venv && \
-    /opt/venv/bin/pip install --upgrade pip wheel && \
-    /opt/venv/bin/pip install -Ur requirements.txt
-
-
-FROM python:3.10.6-slim-buster as final
-RUN apt-get update && apt-get -y install mime-support libpq-dev curl
-WORKDIR /etc/linkding
-# copy prod dependencies
-COPY --from=prod-deps /opt/venv /opt/venv
-# copy output from build stage
-COPY --from=python-build /etc/linkding/static static/
-# copy application code
-COPY . .
-# Expose uwsgi server at port 9090
-EXPOSE 9090
-# Activate virtual env
-ENV VIRTUAL_ENV /opt/venv
-ENV PATH /opt/venv/bin:$PATH
-# Allow running containers as an an arbitrary user in the root group, to support deployment scenarios like OpenShift, Podman
-RUN ["chmod", "g+w", "."]
-# Run bootstrap logic
-RUN ["chmod", "+x", "./bootstrap.sh"]
-
-HEALTHCHECK --interval=30s --retries=3 --timeout=1s \
-CMD curl -f http://localhost:${LD_SERVER_PORT:-9090}/${LD_CONTEXT_PATH}health || exit 1
-
-CMD ["./bootstrap.sh"]
--- a/15
+++ b/15
@@ -0,0 +1,15 @@
+.PHONY: serve
+
+serve:
+	python manage.py runserver
+
+tasks:
+	python manage.py process_tasks
+
+test:
+	pytest
+
+format:
+	black bookmarks
+	black siteroot
+	npx prettier bookmarks/frontend --write
--- a/README.md
+++ b/README.md
@@ -9,19 +9,20 @@
 ## Overview
 - [Introduction](#introduction)
 - [Installation](#installation)
-    - [Using Docker](#using-docker)
-    - [Using Docker Compose](#using-docker-compose)
-    - [User Setup](#user-setup)
-    - [Reverse Proxy Setup](#reverse-proxy-setup)
-    - [Managed Hosting Options](#managed-hosting-options)
+  - [Using Docker](#using-docker)
+  - [Using Docker Compose](#using-docker-compose)
+  - [User Setup](#user-setup)
+  - [Reverse Proxy Setup](#reverse-proxy-setup)
+  - [Managed Hosting Options](#managed-hosting-options)
 - [Documentation](#documentation)
 - [Browser Extension](#browser-extension)
 - [Community](#community)
+- [Acknowledgements + Donations](#acknowledgements--donations)
 - [Development](#development)

 ##  Introduction

-linkding is a simple bookmark service that you can host yourself.
+linkding is a bookmark manager that you can host yourself.
 It's designed be to be minimal, fast, and easy to set up using Docker.

 The name comes from:
@@ -30,22 +31,21 @@ The name comes from:
 - ...so basically something for managing your links

 **Feature Overview:**
+- Clean UI optimized for readability
 - Organize bookmarks with tags
- Read it later functionality
- Share bookmarks with other users
- Bulk editing
- Bookmark archive
- Automatically provides titles and descriptions of bookmarked websites
- Automatically creates snapshots of bookmarked websites on [the Internet Archive Wayback Machine](https://archive.org/web/)
+- Bulk editing, Markdown notes, read it later functionality
+- Share bookmarks with other users or guests
+- Automatically provides titles, descriptions and icons of bookmarked websites
+- Automatically archive websites, either as local HTML file or on Internet Archive
 - Import and export bookmarks in Netscape HTML format
- Extensions for [Firefox](https://addons.mozilla.org/de/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), as well as a bookmarklet
- Light and dark themes
+- Installable as a Progressive Web App (PWA)
+- Extensions for [Firefox](https://addons.mozilla.org/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), as well as a bookmarklet
+- SSO support via OIDC or authentication proxies
 - REST API for developing 3rd party apps
 - Admin panel for user self-service and raw data access
- Easy setup using Docker, uses SQLite as database


-**Demo:** https://demo.linkding.link/ (configured with open registration)
+**Demo:** https://demo.linkding.link/ ([see here](https://github.com/sissbruecker/linkding/issues/408) if you have trouble accessing it)

 **Screenshot:**

@@ -56,22 +56,56 @@ The name comes from:
 linkding is designed to be run with container solutions like [Docker](https://docs.docker.com/get-started/).
 The Docker image is compatible with ARM platforms, so it can be run on a Raspberry Pi.

-By default, linkding uses SQLite as a database.
+linkding uses an SQLite database by default.
 Alternatively linkding supports PostgreSQL, see the [database options](docs/Options.md#LD_DB_ENGINE) for more information.

 ###  Using Docker

-To install linkding using Docker you can just run the [latest image](https://hub.docker.com/repository/docker/sissbruecker/linkding) from Docker Hub:
-```shell
-docker run --name linkding -p 9090:9090 -d sissbruecker/linkding:latest
-```
-By default, the application runs on port `9090`, you can map it to a different host port by modifying the port mapping in the command above. If everything completed successfully, the application should now be running and can be accessed at http://localhost:9090, provided you did not change the port mapping.
+The Docker image comes in several variants. To use a different image than the default, replace `latest` with the desired tag in the commands below, or in the docker-compose file.

-Note that the command above will store the linkding SQLite database in the container, which means that deleting the container, for example when upgrading the installation, will also remove the database. For hosting an actual installation you usually want to store the database on the host system, rather than in the container. To do so, run the following command, and replace the `{host-data-folder}` placeholder with an absolute path to a folder on your host system where you want to store the linkding database:
+<table>
+  <thead>
+    <tr>
+      <th>Tag</th>
+      <th>Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><code>latest</code></td>
+      <td>Provides the basic functionality of linkding</td>
+    </tr>
+    <tr>
+      <td><code>latest-plus</code></td>
+      <td>
+        Includes feature for archiving websites as HTML snapshots
+        <ul>
+          <li>Significantly larger image size as it includes a Chromium installation</li>
+          <li>Requires more runtime memory to run Chromium</li>
+          <li>Requires more disk space for storing HTML snapshots</li>
+        </ul>            
+      </td>
+    </tr>
+    <tr>
+      <td><code>latest-alpine</code></td>
+      <td><code>latest</code>, but based on Alpine Linux. 🧪 Experimental</td>
+    </tr>    
+    <tr>
+      <td><code>latest-plus-alpine</code></td>
+      <td><code>latest-plus</code>, but based on Alpine Linux. 🧪 Experimental</td>
+    </tr>    
+  </tbody>
+</table>
+
+To install linkding using Docker you can just run the image from [Docker Hub](https://hub.docker.com/repository/docker/sissbruecker/linkding):
 ```shell
 docker run --name linkding -p 9090:9090 -v {host-data-folder}:/etc/linkding/data -d sissbruecker/linkding:latest
 ```

+In the command above, replace the `{host-data-folder}` placeholder with an absolute path to a folder on your host system where you want to store the linkding database.
+
+If everything completed successfully, the application should now be running and can be accessed at http://localhost:9090.
+
 To upgrade the installation to a new version, remove the existing container, pull the latest version of the linkding Docker image, and then start a new container using the same command that you used above. There is a [shell script](https://github.com/sissbruecker/linkding/blob/master/install-linkding.sh) available to automate these steps. The script can be configured using environment variables, or you can just modify it.

 To complete the setup, you still have to [create an initial user](#user-setup), so that you can access your installation.
@@ -85,7 +119,7 @@ docker-compose up -d

 To complete the setup, you still have to [create an initial user](#user-setup), so that you can access your installation.

-### User setup
+### User Setup

 For security reasons, the linkding Docker image does not provide an initial user, so you have to create one after setting up an installation. To do so, replace the credentials in the following command and run it:

@@ -101,6 +135,8 @@ docker-compose exec linkding python manage.py createsuperuser --username=joe --e

 The command will prompt you for a secure password. After the command has completed you can start using the application by logging into the UI with your credentials.

+Alternatively you can automatically create an initial superuser on startup using the [`LD_SUPERUSER_NAME` option](docs/Options.md#LD_SUPERUSER_NAME).
+
 ### Reverse Proxy Setup

 When using a reverse proxy, such as Nginx or Apache, you may need to configure your proxy to correctly forward the `Host` header to linkding, otherwise certain requests, such as login, might fail.
@@ -158,10 +194,12 @@ Instead of configuring header forwarding in your proxy, you can also configure t

 ### Managed Hosting Options

-Self-hosting web applications on your own hardware (unfortunately) still requires a lot of technical know-how, and commitment to maintenance, with regard to keeping everything up-to-date and secure. This can be a huge entry barrier for people who are interested in self-hosting linkding, but lack the technical knowledge to do so. This section is intended to provide alternatives in form of managed hosting solutions. Note that these options are usually commercial offerings, that require paying a (usually monthly) fee for the convenience of being managed by another party. The technical knowledge required to make use of individual options is going to vary, and no guarantees can be made that every option is accessible for everyone. That being said, I hope this section helps in making the application accessible to a wider audience.
+Self-hosting web applications still requires a lot of technical know-how and commitment to maintenance, in order to keep everything up-to-date and secure. This section is intended to provide simple alternatives in form of managed hosting solutions.

 - [linkding on fly.io](https://github.com/fspoettel/linkding-on-fly) - Guide for hosting a linkding installation on [fly.io](https://fly.io). By [fspoettel](https://github.com/fspoettel)
- [PikaPods.com](https://www.pikapods.com/) - Managed hosting for linkding, EU and US regions available. [1-click setup link](https://www.pikapods.com/pods?run=linkding)
+- [PikaPods.com](https://www.pikapods.com/) - Managed hosting for linkding, EU and US regions available. [1-click setup link](https://www.pikapods.com/pods?run=linkding) ([Disclosure](#pikapods))
+- [CapRover](https://caprover.com/) - Linkding is included as a default one-click app
+- [linkding on railway.app](https://github.com/tianheg/linkding-on-railway) - Guide for hosting a linkding installation on [railway.app](https://railway.app/). By [tianheg](https://github.com/tianheg)

 ## Documentation

@@ -171,13 +209,14 @@ Self-hosting web applications on your own hardware (unfortunately) still require
 | [Backups](https://github.com/sissbruecker/linkding/blob/master/docs/backup.md)                  | How to backup the linkding database                      |
 | [Troubleshooting](https://github.com/sissbruecker/linkding/blob/master/docs/troubleshooting.md) | Advice for troubleshooting common problems               |
 | [How To](https://github.com/sissbruecker/linkding/blob/master/docs/how-to.md)                   | Tips and tricks around using linking                     |
+| [Keyboard shortcuts](https://github.com/sissbruecker/linkding/blob/master/docs/shortcuts.md)    | List of available keyboard shortcuts                     |
 | [Admin documentation](https://github.com/sissbruecker/linkding/blob/master/docs/Admin.md)       | User documentation for the Admin UI                      |
 | [API documentation](https://github.com/sissbruecker/linkding/blob/master/docs/API.md)           | Documentation for the REST API                           |

 ## Browser Extension

 linkding comes with an official browser extension that allows to quickly add bookmarks, and search bookmarks through the browser's address bar. You can get the extension here:
- [Mozilla Addon Store](https://addons.mozilla.org/de/firefox/addon/linkding-extension/)
+- [Mozilla Addon Store](https://addons.mozilla.org/firefox/addon/linkding-extension/)
 - [Chrome Web Store](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe)

 The extension is open-source as well, and can be found [here](https://github.com/sissbruecker/linkding-extension).
@@ -186,18 +225,35 @@ The extension is open-source as well, and can be found [here](https://github.com

 This section lists community projects around using linkding, in alphabetical order. If you have a project that you want to share with the linkding community, feel free to submit a PR to add your project to this section.

+- [aiolinkding](https://github.com/bachya/aiolinkding) A Python3, async library to interact with the linkding REST API. By [bachya](https://github.com/bachya)
+- [feed2linkding](https://codeberg.org/strubbl/feed2linkding) A commandline utility to add all web feed item links to linkding via API call. By [Strubbl](https://github.com/Strubbl)
 - [Helm Chart](https://charts.pascaliske.dev/charts/linkding/) Helm Chart for deploying linkding inside a Kubernetes cluster. By [pascaliske](https://github.com/pascaliske)
+- [iOS Shortcut using API and Tagging](https://gist.github.com/andrewdolphin/a7dff49505e588d940bec55132fab8ad) An iOS shortcut using the Linkding API (no extra logins required) that pulls previously used tags and allows tagging at the time of link creation.
+- [k8s + s3](https://github.com/jzck/linkding-k8s-s3) - Setup for hosting stateless linkding on k8s with sqlite replicated to s3. By [jzck](https://github.com/jzck)
 - [Linka!](https://github.com/cmsax/linka) Web app (also a PWA) for quickly searching & opening bookmarks in linkding, support multi keywords, exclude mode and other advance options. By [cmsax](https://github.com/cmsax)
+- [linkding-cli](https://github.com/bachya/linkding-cli) A command-line interface (CLI) to interact with the linkding REST API. Powered by [aiolinkding](https://github.com/bachya/aiolinkding). By [bachya](https://github.com/bachya)
 - [linkding-extension](https://github.com/jeroenpardon/linkding-extension) Chromium compatible extension that wraps the linkding bookmarklet. Tested with Chrome, Edge, Brave. By [jeroenpardon](https://github.com/jeroenpardon)
 - [linkding-injector](https://github.com/Fivefold/linkding-injector) Injects search results from linkding into the sidebar of search pages like google and duckduckgo. Tested with Firefox and Chrome. By [Fivefold](https://github.com/Fivefold)
- [aiolinkding](https://github.com/bachya/aiolinkding) A Python3, async library to interact with the linkding REST API. By [bachya](https://github.com/bachya)
- [linkding-cli](https://github.com/bachya/linkding-cli) A command-line interface (CLI) to interact with the linkding REST API. Powered by [aiolinkding](https://github.com/bachya/aiolinkding). By [bachya](https://github.com/bachya)
- [Open all links bookmarklet](https://gist.github.com/ukcuddlyguy/336dd7339e6d35fc64a75ccfc9323c66) A browser bookmarklet to open all links on the current Linkding page in new tabs. By [ukcuddlyguy](https://github.com/ukcuddlyguy)
+- [Linkdy](https://github.com/JGeek00/linkdy): An open source mobile and desktop (not yet) client created with Flutter. Available at the [Google Play Store](https://play.google.com/store/apps/details?id=com.jgeek00.linkdy). By [JGeek00](https://github.com/JGeek00).
 - [LinkThing](https://apps.apple.com/us/app/linkthing/id1666031776) An iOS client for linkding. By [amoscardino](https://github.com/amoscardino)
+- [Open all links bookmarklet](https://gist.github.com/ukcuddlyguy/336dd7339e6d35fc64a75ccfc9323c66) A browser bookmarklet to open all links on the current Linkding page in new tabs. By [ukcuddlyguy](https://github.com/ukcuddlyguy)
+- [Postman collection](https://gist.github.com/gingerbeardman/f0b42502f3bc9344e92ce63afd4360d3) a group of saved request templates for API testing. By [gingerbeardman](https://github.com/gingerbeardman)

-## Acknowledgements
+## Acknowledgements + Donations

-JetBrains provides an open-source license of [IntelliJ IDEA](https://www.jetbrains.com/idea/) for the development of linkding.
+### PikaPods
+
+[PikaPods](https://www.pikapods.com/) has a revenue sharing agreement with this project, sharing some of their revenue from hosting linkding instances. I do not intend to profit from this project financially, so I am in turn donating that revenue. Big thanks to PikaPods for making this possible.
+
+See the table below for a list of donations.
+
+| Source                                | Description                                 | Amount  | Donated to                                                          |
+|---------------------------------------|---------------------------------------------|---------|---------------------------------------------------------------------|
+| [PikaPods](https://www.pikapods.com/) | Linkding hosting June 2022 - September 2023 | $163.50 | [Internet Archive](/docs/donations/2023-10-11-internet-archive.png) |
+
+### JetBrains
+
+JetBrains has previously provided an open-source license of [IntelliJ IDEA](https://www.jetbrains.com/idea/) for the development of linkding.

 ## Development

@@ -219,7 +275,7 @@ source ~/environments/linkding/bin/activate[.csh|.fish]
 ```
 Within the active environment install the application dependencies from the application folder:
 ```
-pip3 install -Ur requirements.txt
+pip3 install -r requirements.txt -r requirements.dev.txt
 ```
 Install frontend dependencies:
 ```
@@ -243,3 +299,37 @@ Start the Django development server with:
 python3 manage.py runserver
 ```
 The frontend is now available under http://localhost:8000
+
+### Tests
+
+Run all tests with pytest:
+```
+pytest
+```
+
+### Formatting
+
+Format Python code with black, and JavaScript code with prettier:
+```
+make format
+```
+
+### DevContainers
+
+This repository also supports DevContainers: [![Open in Remote - Containers](https://img.shields.io/static/v1?label=Remote%20-%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=git@github.com:sissbruecker/linkding.git)
+
+Once checked out, only the following commands are required to get started:
+
+Create a user for the frontend:
+```
+python3 manage.py createsuperuser --username=joe --email=joe@example.com
+```
+Start the Node.js development server (used for compiling JavaScript components like tag auto-completion) with:
+```
+npm run dev
+```
+Start the Django development server with:
+```
+python3 manage.py runserver
+```
+The frontend is now available under http://localhost:8000
--- a/background-tasks-wrapper.sh
+++ b/background-tasks-wrapper.sh
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Wrapper script used by supervisord to first clear task locks before starting the background task processor
-
-python manage.py clean_tasks
-exec python manage.py process_tasks
--- a/bookmarks/admin.py
+++ b/bookmarks/admin.py
@@ -1,93 +1,219 @@
-from background_task.admin import TaskAdmin, CompletedTaskAdmin
-from background_task.models import Task, CompletedTask
 from django.contrib import admin, messages
 from django.contrib.admin import AdminSite
 from django.contrib.auth.admin import UserAdmin
 from django.contrib.auth.models import User
+from django.core.paginator import Paginator
 from django.db.models import Count, QuerySet
+from django.shortcuts import render
+from django.urls import path
 from django.utils.translation import ngettext, gettext
+from huey.contrib.djhuey import HUEY as huey
 from rest_framework.authtoken.admin import TokenAdmin
 from rest_framework.authtoken.models import TokenProxy

-from bookmarks.models import Bookmark, Tag, UserProfile, Toast, FeedToken
+from bookmarks.models import Bookmark, BookmarkAsset, Tag, UserProfile, Toast, FeedToken
 from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark


+# Custom paginator to paginate through Huey tasks
+class TaskPaginator(Paginator):
+    def __init__(self):
+        super().__init__(self, 100)
+        self.task_count = huey.storage.queue_size()
+
+    @property
+    def count(self):
+        return self.task_count
+
+    def page(self, number):
+        limit = self.per_page
+        offset = (number - 1) * self.per_page
+        return self._get_page(
+            self.enqueued_items(limit, offset),
+            number,
+            self,
+        )
+
+    # Copied from Huey's SqliteStorage with some modifications to allow pagination
+    def enqueued_items(self, limit, offset):
+        to_bytes = lambda b: bytes(b) if not isinstance(b, bytes) else b
+        sql = "select data from task where queue=? order by priority desc, id limit ? offset ?"
+        params = (huey.storage.name, limit, offset)
+
+        serialized_tasks = [
+            to_bytes(i) for i, in huey.storage.sql(sql, params, results=True)
+        ]
+        return [huey.deserialize_task(task) for task in serialized_tasks]
+
+
+# Custom view to display Huey tasks in the admin
+def background_task_view(request):
+    page_number = int(request.GET.get("p", 1))
+    paginator = TaskPaginator()
+    page = paginator.get_page(page_number)
+    page_range = paginator.get_elided_page_range(page_number, on_each_side=2, on_ends=2)
+    context = {
+        **linkding_admin_site.each_context(request),
+        "title": "Background tasks",
+        "page": page,
+        "page_range": page_range,
+        "tasks": page.object_list,
+    }
+    return render(request, "admin/background_tasks.html", context)
+
+
 class LinkdingAdminSite(AdminSite):
-    site_header = 'linkding administration'
-    site_title = 'linkding Admin'
+    site_header = "linkding administration"
+    site_title = "linkding Admin"
+
+    def get_urls(self):
+        urls = super().get_urls()
+        custom_urls = [
+            path("tasks/", background_task_view, name="background_tasks"),
+        ]
+        return custom_urls + urls
+
+    def get_app_list(self, request, app_label=None):
+        app_list = super().get_app_list(request, app_label)
+        app_list += [
+            {
+                "name": "Huey",
+                "app_label": "huey_app",
+                "models": [
+                    {
+                        "name": "Queued tasks",
+                        "object_name": "background_tasks",
+                        "admin_url": "/admin/tasks/",
+                        "view_only": True,
+                    }
+                ],
+            }
+        ]
+        return app_list


 class AdminBookmark(admin.ModelAdmin):
-    list_display = ('resolved_title', 'url', 'is_archived', 'owner', 'date_added')
-    search_fields = ('title', 'description', 'website_title', 'website_description', 'url', 'tags__name')
-    list_filter = ('owner__username', 'is_archived', 'unread', 'tags',)
-    ordering = ('-date_added',)
-    actions = ['delete_selected_bookmarks', 'archive_selected_bookmarks', 'unarchive_selected_bookmarks', 'mark_as_read', 'mark_as_unread']
+    list_display = ("resolved_title", "url", "is_archived", "owner", "date_added")
+    search_fields = (
+        "title",
+        "description",
+        "website_title",
+        "website_description",
+        "url",
+        "tags__name",
+    )
+    list_filter = (
+        "owner__username",
+        "is_archived",
+        "unread",
+        "tags",
+    )
+    ordering = ("-date_added",)
+    actions = [
+        "delete_selected_bookmarks",
+        "archive_selected_bookmarks",
+        "unarchive_selected_bookmarks",
+        "mark_as_read",
+        "mark_as_unread",
+    ]

    def get_actions(self, request):
        actions = super().get_actions(request)
        # Remove default delete action, which gets replaced by delete_selected_bookmarks below
        # The default action shows a confirmation page which can fail in production when selecting all bookmarks and the
        # number of objects to delete exceeds the value in DATA_UPLOAD_MAX_NUMBER_FIELDS (1000 by default)
-        del actions['delete_selected']
+        del actions["delete_selected"]
        return actions

    def delete_selected_bookmarks(self, request, queryset: QuerySet):
        bookmarks_count = queryset.count()
        for bookmark in queryset:
            bookmark.delete()
-        self.message_user(request, ngettext(
-            '%d bookmark was successfully deleted.',
-            '%d bookmarks were successfully deleted.',
-            bookmarks_count,
-        ) % bookmarks_count, messages.SUCCESS)
+        self.message_user(
+            request,
+            ngettext(
+                "%d bookmark was successfully deleted.",
+                "%d bookmarks were successfully deleted.",
+                bookmarks_count,
+            )
+            % bookmarks_count,
+            messages.SUCCESS,
+        )

    def archive_selected_bookmarks(self, request, queryset: QuerySet):
        for bookmark in queryset:
            archive_bookmark(bookmark)
        bookmarks_count = queryset.count()
-        self.message_user(request, ngettext(
-            '%d bookmark was successfully archived.',
-            '%d bookmarks were successfully archived.',
-            bookmarks_count,
-        ) % bookmarks_count, messages.SUCCESS)
+        self.message_user(
+            request,
+            ngettext(
+                "%d bookmark was successfully archived.",
+                "%d bookmarks were successfully archived.",
+                bookmarks_count,
+            )
+            % bookmarks_count,
+            messages.SUCCESS,
+        )

    def unarchive_selected_bookmarks(self, request, queryset: QuerySet):
        for bookmark in queryset:
            unarchive_bookmark(bookmark)
        bookmarks_count = queryset.count()
-        self.message_user(request, ngettext(
-            '%d bookmark was successfully unarchived.',
-            '%d bookmarks were successfully unarchived.',
-            bookmarks_count,
-        ) % bookmarks_count, messages.SUCCESS)
+        self.message_user(
+            request,
+            ngettext(
+                "%d bookmark was successfully unarchived.",
+                "%d bookmarks were successfully unarchived.",
+                bookmarks_count,
+            )
+            % bookmarks_count,
+            messages.SUCCESS,
+        )

    def mark_as_read(self, request, queryset: QuerySet):
        bookmarks_count = queryset.count()
        queryset.update(unread=False)
-        self.message_user(request, ngettext(
-            '%d bookmark marked as read.',
-            '%d bookmarks marked as read.',
-            bookmarks_count,
-        ) % bookmarks_count, messages.SUCCESS)
+        self.message_user(
+            request,
+            ngettext(
+                "%d bookmark marked as read.",
+                "%d bookmarks marked as read.",
+                bookmarks_count,
+            )
+            % bookmarks_count,
+            messages.SUCCESS,
+        )

    def mark_as_unread(self, request, queryset: QuerySet):
        bookmarks_count = queryset.count()
        queryset.update(unread=True)
-        self.message_user(request, ngettext(
-            '%d bookmark marked as unread.',
-            '%d bookmarks marked as unread.',
-            bookmarks_count,
-        ) % bookmarks_count, messages.SUCCESS)
+        self.message_user(
+            request,
+            ngettext(
+                "%d bookmark marked as unread.",
+                "%d bookmarks marked as unread.",
+                bookmarks_count,
+            )
+            % bookmarks_count,
+            messages.SUCCESS,
+        )
+
+
+class AdminBookmarkAsset(admin.ModelAdmin):
+    list_display = ("display_name", "date_created", "status")
+    search_fields = (
+        "display_name",
+        "file",
+    )
+    list_filter = ("status",)


 class AdminTag(admin.ModelAdmin):
-    list_display = ('name', 'bookmarks_count', 'owner', 'date_added')
-    search_fields = ('name', 'owner__username')
-    list_filter = ('owner__username',)
-    ordering = ('-date_added',)
-    actions = ['delete_unused_tags']
+    list_display = ("name", "bookmarks_count", "owner", "date_added")
+    search_fields = ("name", "owner__username")
+    list_filter = ("owner__username",)
+    ordering = ("-date_added",)
+    actions = ["delete_unused_tags"]

    def get_queryset(self, request):
        queryset = super().get_queryset(request)
@@ -97,7 +223,7 @@ class AdminTag(admin.ModelAdmin):
    def bookmarks_count(self, obj):
        return obj.bookmarks_count

-    bookmarks_count.admin_order_field = 'bookmarks_count'
+    bookmarks_count.admin_order_field = "bookmarks_count"

    def delete_unused_tags(self, request, queryset: QuerySet):
        unused_tags = queryset.filter(bookmark__isnull=True)
@@ -106,22 +232,32 @@ class AdminTag(admin.ModelAdmin):
            tag.delete()

        if unused_tags_count > 0:
-            self.message_user(request, ngettext(
-                '%d unused tag was successfully deleted.',
-                '%d unused tags were successfully deleted.',
-                unused_tags_count,
-            ) % unused_tags_count, messages.SUCCESS)
+            self.message_user(
+                request,
+                ngettext(
+                    "%d unused tag was successfully deleted.",
+                    "%d unused tags were successfully deleted.",
+                    unused_tags_count,
+                )
+                % unused_tags_count,
+                messages.SUCCESS,
+            )
        else:
-            self.message_user(request, gettext(
-                'There were no unused tags in the selection',
-            ), messages.SUCCESS)
+            self.message_user(
+                request,
+                gettext(
+                    "There were no unused tags in the selection",
+                ),
+                messages.SUCCESS,
+            )


 class AdminUserProfileInline(admin.StackedInline):
    model = UserProfile
    can_delete = False
-    verbose_name_plural = 'Profile'
-    fk_name = 'user'
+    verbose_name_plural = "Profile"
+    fk_name = "user"
+    readonly_fields = ("search_preferences",)


 class AdminCustomUser(UserAdmin):
@@ -134,23 +270,22 @@ class AdminCustomUser(UserAdmin):


 class AdminToast(admin.ModelAdmin):
-    list_display = ('key', 'message', 'owner', 'acknowledged')
-    search_fields = ('key', 'message')
-    list_filter = ('owner__username',)
+    list_display = ("key", "message", "owner", "acknowledged")
+    search_fields = ("key", "message")
+    list_filter = ("owner__username",)


 class AdminFeedToken(admin.ModelAdmin):
-    list_display = ('key', 'user')
-    search_fields = ['key']
-    list_filter = ('user__username',)
+    list_display = ("key", "user")
+    search_fields = ["key"]
+    list_filter = ("user__username",)


 linkding_admin_site = LinkdingAdminSite()
 linkding_admin_site.register(Bookmark, AdminBookmark)
+linkding_admin_site.register(BookmarkAsset, AdminBookmarkAsset)
 linkding_admin_site.register(Tag, AdminTag)
 linkding_admin_site.register(User, AdminCustomUser)
 linkding_admin_site.register(TokenProxy, TokenAdmin)
 linkding_admin_site.register(Toast, AdminToast)
 linkding_admin_site.register(FeedToken, AdminFeedToken)
-linkding_admin_site.register(Task, TaskAdmin)
-linkding_admin_site.register(CompletedTask, CompletedTaskAdmin)
--- a/bookmarks/api/routes.py
+++ b/bookmarks/api/routes.py
@@ -1,90 +1,121 @@
 from rest_framework import viewsets, mixins, status
 from rest_framework.decorators import action
+from rest_framework.permissions import AllowAny
 from rest_framework.response import Response
 from rest_framework.routers import DefaultRouter

 from bookmarks import queries
-from bookmarks.api.serializers import BookmarkSerializer, TagSerializer
-from bookmarks.models import Bookmark, BookmarkFilters, Tag, User
-from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark, website_loader
+from bookmarks.api.serializers import (
+    BookmarkSerializer,
+    TagSerializer,
+    UserProfileSerializer,
+)
+from bookmarks.models import Bookmark, BookmarkSearch, Tag, User
+from bookmarks.services.bookmarks import (
+    archive_bookmark,
+    unarchive_bookmark,
+    website_loader,
+)
 from bookmarks.services.website_loader import WebsiteMetadata


-class BookmarkViewSet(viewsets.GenericViewSet,
-                      mixins.ListModelMixin,
-                      mixins.RetrieveModelMixin,
-                      mixins.CreateModelMixin,
-                      mixins.UpdateModelMixin,
-                      mixins.DestroyModelMixin):
+class BookmarkViewSet(
+    viewsets.GenericViewSet,
+    mixins.ListModelMixin,
+    mixins.RetrieveModelMixin,
+    mixins.CreateModelMixin,
+    mixins.UpdateModelMixin,
+    mixins.DestroyModelMixin,
+):
    serializer_class = BookmarkSerializer

+    def get_permissions(self):
+        # Allow unauthenticated access to shared bookmarks.
+        # The shared action should still filter bookmarks so that
+        # unauthenticated users only see bookmarks from users that have public
+        # sharing explicitly enabled
+        if self.action == "shared":
+            return [AllowAny()]
+
+        # Otherwise use default permissions which should require authentication
+        return super().get_permissions()
+
    def get_queryset(self):
        user = self.request.user
        # For list action, use query set that applies search and tag projections
-        if self.action == 'list':
-            query_string = self.request.GET.get('q')
-            return queries.query_bookmarks(user, user.profile, query_string)
+        if self.action == "list":
+            search = BookmarkSearch.from_request(self.request.GET)
+            return queries.query_bookmarks(user, user.profile, search)

        # For single entity actions use default query set without projections
        return Bookmark.objects.all().filter(owner=user)

    def get_serializer_context(self):
-        return {'user': self.request.user}
+        return {"user": self.request.user}

-    @action(methods=['get'], detail=False)
+    @action(methods=["get"], detail=False)
    def archived(self, request):
        user = request.user
-        query_string = request.GET.get('q')
-        query_set = queries.query_archived_bookmarks(user, user.profile, query_string)
+        search = BookmarkSearch.from_request(request.GET)
+        query_set = queries.query_archived_bookmarks(user, user.profile, search)
        page = self.paginate_queryset(query_set)
        serializer = self.get_serializer_class()
        data = serializer(page, many=True).data
        return self.get_paginated_response(data)

-    @action(methods=['get'], detail=False)
+    @action(methods=["get"], detail=False)
    def shared(self, request):
-        filters = BookmarkFilters(request)
-        user = User.objects.filter(username=filters.user).first()
-        query_set = queries.query_shared_bookmarks(user, request.user.profile, filters.query)
+        search = BookmarkSearch.from_request(request.GET)
+        user = User.objects.filter(username=search.user).first()
+        public_only = not request.user.is_authenticated
+        query_set = queries.query_shared_bookmarks(
+            user, request.user_profile, search, public_only
+        )
        page = self.paginate_queryset(query_set)
        serializer = self.get_serializer_class()
        data = serializer(page, many=True).data
        return self.get_paginated_response(data)

-    @action(methods=['post'], detail=True)
+    @action(methods=["post"], detail=True)
    def archive(self, request, pk):
        bookmark = self.get_object()
        archive_bookmark(bookmark)
        return Response(status=status.HTTP_204_NO_CONTENT)

-    @action(methods=['post'], detail=True)
+    @action(methods=["post"], detail=True)
    def unarchive(self, request, pk):
        bookmark = self.get_object()
        unarchive_bookmark(bookmark)
        return Response(status=status.HTTP_204_NO_CONTENT)

-    @action(methods=['get'], detail=False)
+    @action(methods=["get"], detail=False)
    def check(self, request):
-        url = request.GET.get('url')
+        url = request.GET.get("url")
        bookmark = Bookmark.objects.filter(owner=request.user, url=url).first()
-        existing_bookmark_data = self.get_serializer(bookmark).data if bookmark else None
+        existing_bookmark_data = (
+            self.get_serializer(bookmark).data if bookmark else None
+        )

        # Either return metadata from existing bookmark, or scrape from URL
        if bookmark:
-            metadata = WebsiteMetadata(url, bookmark.website_title, bookmark.website_description)
+            metadata = WebsiteMetadata(
+                url, bookmark.website_title, bookmark.website_description
+            )
        else:
            metadata = website_loader.load_website_metadata(url)

-        return Response({
-            'bookmark': existing_bookmark_data,
-            'metadata': metadata.to_dict()
-        }, status=status.HTTP_200_OK)
+        return Response(
+            {"bookmark": existing_bookmark_data, "metadata": metadata.to_dict()},
+            status=status.HTTP_200_OK,
+        )


-class TagViewSet(viewsets.GenericViewSet,
-                 mixins.ListModelMixin,
-                 mixins.RetrieveModelMixin,
-                 mixins.CreateModelMixin):
+class TagViewSet(
+    viewsets.GenericViewSet,
+    mixins.ListModelMixin,
+    mixins.RetrieveModelMixin,
+    mixins.CreateModelMixin,
+):
    serializer_class = TagSerializer

    def get_queryset(self):
@@ -92,9 +123,16 @@ class TagViewSet(viewsets.GenericViewSet,
        return Tag.objects.all().filter(owner=user)

    def get_serializer_context(self):
-        return {'user': self.request.user}
+        return {"user": self.request.user}
+
+
+class UserViewSet(viewsets.GenericViewSet):
+    @action(methods=["get"], detail=False)
+    def profile(self, request):
+        return Response(UserProfileSerializer(request.user.profile).data)


 router = DefaultRouter()
-router.register(r'bookmarks', BookmarkViewSet, basename='bookmark')
-router.register(r'tags', TagViewSet, basename='tag')
+router.register(r"bookmarks", BookmarkViewSet, basename="bookmark")
+router.register(r"tags", TagViewSet, basename="tag")
+router.register(r"user", UserViewSet, basename="user")
--- a/bookmarks/api/serializers.py
+++ b/bookmarks/api/serializers.py
@@ -2,7 +2,7 @@ from django.db.models import prefetch_related_objects
 from rest_framework import serializers
 from rest_framework.serializers import ListSerializer

-from bookmarks.models import Bookmark, Tag, build_tag_string
+from bookmarks.models import Bookmark, Tag, build_tag_string, UserProfile
 from bookmarks.services.bookmarks import create_bookmark, update_bookmark
 from bookmarks.services.tags import get_or_create_tag

@@ -14,7 +14,7 @@ class TagListField(serializers.ListField):
 class BookmarkListSerializer(ListSerializer):
    def to_representation(self, data):
        # Prefetch nested relations to avoid n+1 queries
-        prefetch_related_objects(data, 'tags')
+        prefetch_related_objects(data, "tags")

        return super().to_representation(data)

@@ -23,32 +23,34 @@ class BookmarkSerializer(serializers.ModelSerializer):
    class Meta:
        model = Bookmark
        fields = [
-            'id',
-            'url',
-            'title',
-            'description',
-            'notes',
-            'website_title',
-            'website_description',
-            'is_archived',
-            'unread',
-            'shared',
-            'tag_names',
-            'date_added',
-            'date_modified'
+            "id",
+            "url",
+            "title",
+            "description",
+            "notes",
+            "website_title",
+            "website_description",
+            "web_archive_snapshot_url",
+            "is_archived",
+            "unread",
+            "shared",
+            "tag_names",
+            "date_added",
+            "date_modified",
        ]
        read_only_fields = [
-            'website_title',
-            'website_description',
-            'date_added',
-            'date_modified'
+            "website_title",
+            "website_description",
+            "web_archive_snapshot_url",
+            "date_added",
+            "date_modified",
        ]
        list_serializer_class = BookmarkListSerializer

    # Override optional char fields to provide default value
-    title = serializers.CharField(required=False, allow_blank=True, default='')
-    description = serializers.CharField(required=False, allow_blank=True, default='')
-    notes = serializers.CharField(required=False, allow_blank=True, default='')
+    title = serializers.CharField(required=False, allow_blank=True, default="")
+    description = serializers.CharField(required=False, allow_blank=True, default="")
+    notes = serializers.CharField(required=False, allow_blank=True, default="")
    is_archived = serializers.BooleanField(required=False, default=False)
    unread = serializers.BooleanField(required=False, default=False)
    shared = serializers.BooleanField(required=False, default=False)
@@ -57,35 +59,53 @@ class BookmarkSerializer(serializers.ModelSerializer):

    def create(self, validated_data):
        bookmark = Bookmark()
-        bookmark.url = validated_data['url']
-        bookmark.title = validated_data['title']
-        bookmark.description = validated_data['description']
-        bookmark.notes = validated_data['notes']
-        bookmark.is_archived = validated_data['is_archived']
-        bookmark.unread = validated_data['unread']
-        bookmark.shared = validated_data['shared']
-        tag_string = build_tag_string(validated_data['tag_names'])
-        return create_bookmark(bookmark, tag_string, self.context['user'])
+        bookmark.url = validated_data["url"]
+        bookmark.title = validated_data["title"]
+        bookmark.description = validated_data["description"]
+        bookmark.notes = validated_data["notes"]
+        bookmark.is_archived = validated_data["is_archived"]
+        bookmark.unread = validated_data["unread"]
+        bookmark.shared = validated_data["shared"]
+        tag_string = build_tag_string(validated_data["tag_names"])
+        return create_bookmark(bookmark, tag_string, self.context["user"])

    def update(self, instance: Bookmark, validated_data):
        # Update fields if they were provided in the payload
-        for key in ['url', 'title', 'description', 'notes', 'unread', 'shared']:
+        for key in ["url", "title", "description", "notes", "unread", "shared"]:
            if key in validated_data:
                setattr(instance, key, validated_data[key])

        # Use tag string from payload, or use bookmark's current tags as fallback
        tag_string = build_tag_string(instance.tag_names)
-        if 'tag_names' in validated_data:
-            tag_string = build_tag_string(validated_data['tag_names'])
+        if "tag_names" in validated_data:
+            tag_string = build_tag_string(validated_data["tag_names"])

-        return update_bookmark(instance, tag_string, self.context['user'])
+        return update_bookmark(instance, tag_string, self.context["user"])


 class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
-        fields = ['id', 'name', 'date_added']
-        read_only_fields = ['date_added']
+        fields = ["id", "name", "date_added"]
+        read_only_fields = ["date_added"]

    def create(self, validated_data):
-        return get_or_create_tag(validated_data['name'], self.context['user'])
+        return get_or_create_tag(validated_data["name"], self.context["user"])
+
+
+class UserProfileSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = UserProfile
+        fields = [
+            "theme",
+            "bookmark_date_display",
+            "bookmark_link_target",
+            "web_archive_integration",
+            "tag_search",
+            "enable_sharing",
+            "enable_public_sharing",
+            "enable_favicons",
+            "display_url",
+            "permanent_notes",
+            "search_preferences",
+        ]
--- a/bookmarks/apps.py
+++ b/bookmarks/apps.py
@@ -2,7 +2,7 @@ from django.apps import AppConfig


 class BookmarksConfig(AppConfig):
-    name = 'bookmarks'
+    name = "bookmarks"

    def ready(self):
        # Register signal handlers
--- a/bookmarks/components/SearchAutoComplete.svelte
+++ b/bookmarks/components/SearchAutoComplete.svelte
@@ -1,271 +0,0 @@
-<script>
-    import {SearchHistory} from "./SearchHistory";
-    import {clampText, debounce, getCurrentWord, getCurrentWordBounds} from "./util";
-
-    const searchHistory = new SearchHistory()
-
-    export let name;
-    export let placeholder;
-    export let value;
-    export let tags;
-    export let mode = '';
-    export let apiClient;
-    export let filters;
-
-    let isFocus = false;
-    let isOpen = false;
-    let suggestions = []
-    let selectedIndex = undefined;
-    let input = null;
-
-    // Track current search query after loading the page
-    searchHistory.pushCurrent()
-    updateSuggestions()
-
-    function handleFocus() {
-        isFocus = true;
-    }
-
-    function handleBlur() {
-        isFocus = false;
-        close();
-    }
-
-    function handleInput(e) {
-        value = e.target.value
-        debouncedLoadSuggestions()
-    }
-
-    function handleKeyDown(e) {
-        // Enter
-        if (isOpen && selectedIndex !== undefined && (e.keyCode === 13 || e.keyCode === 9)) {
-            const suggestion = suggestions.total[selectedIndex];
-            if (suggestion) completeSuggestion(suggestion);
-            e.preventDefault();
-        }
-        // Escape
-        if (e.keyCode === 27) {
-            close();
-            e.preventDefault();
-        }
-        // Up arrow
-        if (e.keyCode === 38) {
-            updateSelection(-1);
-            e.preventDefault();
-        }
-        // Down arrow
-        if (e.keyCode === 40) {
-            if (!isOpen) {
-                loadSuggestions()
-            } else {
-                updateSelection(1);
-            }
-            e.preventDefault();
-        }
-    }
-
-    function open() {
-        isOpen = true;
-    }
-
-    function close() {
-        isOpen = false;
-        updateSuggestions()
-        selectedIndex = undefined
-    }
-
-    function hasSuggestions() {
-        return suggestions.total.length > 0
-    }
-
-    async function loadSuggestions() {
-
-        let suggestionIndex = 0
-
-        function nextIndex() {
-            return suggestionIndex++
-        }
-
-        // Tag suggestions
-        let tagSuggestions = []
-        const currentWord = getCurrentWord(input)
-        if (currentWord && currentWord.length > 1 && currentWord[0] === '#') {
-            const searchTag = currentWord.substring(1, currentWord.length)
-            tagSuggestions = (tags || []).filter(tagName => tagName.toLowerCase().indexOf(searchTag.toLowerCase()) === 0)
-                .slice(0, 5)
-                .map(tagName => ({
-                    type: 'tag',
-                    index: nextIndex(),
-                    label: `#${tagName}`,
-                    tagName: tagName
-                }))
-        }
-
-        // Recent search suggestions
-        const search = searchHistory.getRecentSearches(value, 5).map(value => ({
-            type: 'search',
-            index: nextIndex(),
-            label: value,
-            value
-        }))
-
-        // Bookmark suggestions
-        let bookmarks = []
-
-        if (value && value.length >= 3) {
-            const path = mode ? `/${mode}` : ''
-            const suggestionFilters = {
-                ...filters,
-                q: value
-            }
-            const fetchedBookmarks = await apiClient.listBookmarks(suggestionFilters, {limit: 5, offset: 0, path})
-            bookmarks = fetchedBookmarks.map(bookmark => {
-                const fullLabel = bookmark.title || bookmark.website_title || bookmark.url
-                const label = clampText(fullLabel, 60)
-                return {
-                    type: 'bookmark',
-                    index: nextIndex(),
-                    label,
-                    bookmark
-                }
-            })
-        }
-
-        updateSuggestions(search, bookmarks, tagSuggestions)
-
-        if (hasSuggestions()) {
-            open()
-        } else {
-            close()
-        }
-    }
-
-    const debouncedLoadSuggestions = debounce(loadSuggestions)
-
-    function updateSuggestions(search, bookmarks, tagSuggestions) {
-        search = search || []
-        bookmarks = bookmarks || []
-        tagSuggestions = tagSuggestions || []
-        suggestions = {
-            search,
-            bookmarks,
-            tags: tagSuggestions,
-            total: [
-                ...tagSuggestions,
-                ...search,
-                ...bookmarks,
-            ]
-        }
-    }
-
-    function completeSuggestion(suggestion) {
-        if (suggestion.type === 'search') {
-            value = suggestion.value
-            close()
-        }
-        if (suggestion.type === 'bookmark') {
-            window.open(suggestion.bookmark.url, '_blank')
-            close()
-        }
-        if (suggestion.type === 'tag') {
-            const bounds = getCurrentWordBounds(input);
-            const inputValue = input.value;
-            input.value = inputValue.substring(0, bounds.start) + `#${suggestion.tagName} ` + inputValue.substring(bounds.end);
-            close()
-        }
-    }
-
-    function updateSelection(dir) {
-
-        const length = suggestions.total.length;
-
-        if (length === 0) return
-
-        if (selectedIndex === undefined) {
-            selectedIndex = dir > 0 ? 0 : Math.max(length - 1, 0)
-            return
-        }
-
-        let newIndex = selectedIndex + dir;
-
-        if (newIndex < 0) newIndex = Math.max(length - 1, 0);
-        if (newIndex >= length) newIndex = 0;
-
-        selectedIndex = newIndex;
-    }
-</script>
-
-<div class="form-autocomplete">
-    <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
-        <input type="search" class="form-input" name="{name}" placeholder="{placeholder}" autocomplete="off" value="{value}"
-               bind:this={input}
-               on:input={handleInput} on:keydown={handleKeyDown} on:focus={handleFocus} on:blur={handleBlur}>
-    </div>
-
-    <ul class="menu" class:open={isOpen}>
-        {#if suggestions.tags.length > 0}
-            <li class="menu-item group-item">Tags</li>
-        {/if}
-        {#each suggestions.tags as suggestion}
-            <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
-                <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
-                    <div class="tile tile-centered">
-                        <div class="tile-content">
-                            {suggestion.label}
-                        </div>
-                    </div>
-                </a>
-            </li>
-        {/each}
-
-        {#if suggestions.search.length > 0}
-            <li class="menu-item group-item">Recent Searches</li>
-        {/if}
-        {#each suggestions.search as suggestion}
-            <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
-                <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
-                    <div class="tile tile-centered">
-                        <div class="tile-content">
-                            {suggestion.label}
-                        </div>
-                    </div>
-                </a>
-            </li>
-        {/each}
-
-        {#if suggestions.bookmarks.length > 0}
-            <li class="menu-item group-item">Bookmarks</li>
-        {/if}
-        {#each suggestions.bookmarks as suggestion}
-            <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
-                <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
-                    <div class="tile tile-centered">
-                        <div class="tile-content">
-                            {suggestion.label}
-                        </div>
-                    </div>
-                </a>
-            </li>
-        {/each}
-    </ul>
-</div>
-
-<style>
-    .menu {
-        display: none;
-        max-height: 400px;
-        overflow: auto;
-    }
-
-    .menu.open {
-        display: block;
-    }
-
-    .form-autocomplete-input {
-        padding: 0;
-    }
-    .form-autocomplete-input.is-focused {
-        z-index: 2;
-    }
-
-</style>
--- a/bookmarks/components/SearchHistory.js
+++ b/bookmarks/components/SearchHistory.js
@@ -1,48 +0,0 @@
-const SEARCH_HISTORY_KEY = 'searchHistory'
-const MAX_ENTRIES = 30
-
-export class SearchHistory {
-
-    getHistory() {
-        const historyJson = localStorage.getItem(SEARCH_HISTORY_KEY)
-        return historyJson ? JSON.parse(historyJson) : {
-            recent: []
-        }
-    }
-
-    pushCurrent() {
-        // Skip if browser is not compatible
-        if (!window.URLSearchParams) return
-        const urlParams = new URLSearchParams(window.location.search);
-        const searchParam = urlParams.get('q');
-
-        if (!searchParam) return
-
-        this.push(searchParam)
-    }
-
-    push(search) {
-        const history = this.getHistory()
-
-        history.recent.unshift(search)
-
-        // Remove duplicates and clamp to max entries
-        history.recent = history.recent.reduce((acc, cur) => {
-            if (acc.length >= MAX_ENTRIES) return acc
-            if (acc.indexOf(cur) >= 0) return acc
-            acc.push(cur)
-            return acc
-        }, [])
-
-        const newHistoryJson = JSON.stringify(history)
-        localStorage.setItem(SEARCH_HISTORY_KEY, newHistoryJson)
-    }
-
-    getRecentSearches(query, max) {
-        const history = this.getHistory()
-
-        return history.recent
-            .filter(search => !query || search.toLowerCase().indexOf(query.toLowerCase()) >= 0)
-            .slice(0, max)
-    }
-}
--- a/bookmarks/components/TagAutocomplete.svelte
+++ b/bookmarks/components/TagAutocomplete.svelte
@@ -1,168 +0,0 @@
-<script>
-    import {getCurrentWord, getCurrentWordBounds} from "./util";
-
-    export let id;
-    export let name;
-    export let value;
-    export let apiClient;
-    export let variant = 'default';
-
-    let tags = [];
-    let isFocus = false;
-    let isOpen = false;
-    let input = null;
-    let suggestionList = null;
-
-    let suggestions = [];
-    let selectedIndex = 0;
-
-    init();
-
-    async function init() {
-        // For now we cache all tags on load as the template did before
-        try {
-            tags = await apiClient.getTags({limit: 1000, offset: 0});
-            tags.sort((left, right) => left.name.toLowerCase().localeCompare(right.name.toLowerCase()))
-        } catch (e) {
-            console.warn('TagAutocomplete: Error loading tag list');
-        }
-    }
-
-    function handleFocus() {
-        isFocus = true;
-    }
-
-    function handleBlur() {
-        isFocus = false;
-        close();
-    }
-
-    function handleInput(e) {
-        input = e.target;
-
-        const word = getCurrentWord(input);
-
-        suggestions = word
-            ? tags.filter(tag => tag.name.toLowerCase().indexOf(word.toLowerCase()) === 0)
-            : [];
-
-        if (word && suggestions.length > 0) {
-            open();
-        } else {
-            close();
-        }
-    }
-
-    function handleKeyDown(e) {
-        if (isOpen && (e.keyCode === 13 || e.keyCode === 9)) {
-            const suggestion = suggestions[selectedIndex];
-            complete(suggestion);
-            e.preventDefault();
-        }
-        if (e.keyCode === 27) {
-            close();
-            e.preventDefault();
-        }
-        if (e.keyCode === 38) {
-            updateSelection(-1);
-            e.preventDefault();
-        }
-        if (e.keyCode === 40) {
-            updateSelection(1);
-            e.preventDefault();
-        }
-    }
-
-    function open() {
-        isOpen = true;
-        selectedIndex = 0;
-    }
-
-    function close() {
-        isOpen = false;
-        suggestions = [];
-        selectedIndex = 0;
-    }
-
-    function complete(suggestion) {
-        const bounds = getCurrentWordBounds(input);
-        const value = input.value;
-        input.value = value.substring(0, bounds.start) + suggestion.name + ' ' + value.substring(bounds.end);
-
-        close();
-    }
-
-    function updateSelection(dir) {
-
-        const length = suggestions.length;
-        let newIndex = selectedIndex + dir;
-
-        if (newIndex < 0) newIndex = Math.max(length - 1, 0);
-        if (newIndex >= length) newIndex = 0;
-
-        selectedIndex = newIndex;
-
-        // Scroll to selected list item
-        setTimeout(() => {
-            if (suggestionList) {
-                const selectedListItem = suggestionList.querySelector('li.selected');
-                if (selectedListItem) {
-                    selectedListItem.scrollIntoView({block: 'center'});
-                }
-            }
-        }, 0);
-    }
-</script>
-
-<div class="form-autocomplete" class:small={variant === 'small'}>
-    <!-- autocomplete input container -->
-    <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
-        <!-- autocomplete real input box -->
-        <input id="{id}" name="{name}" value="{value ||''}" placeholder="&nbsp;"
-               class="form-input" type="text" autocomplete="off" autocapitalize="off"
-               on:input={handleInput} on:keydown={handleKeyDown}
-               on:focus={handleFocus} on:blur={handleBlur}>
-    </div>
-
-    <!-- autocomplete suggestion list -->
-    <ul class="menu" class:open={isOpen && suggestions.length > 0}
-        bind:this={suggestionList}>
-        <!-- menu list items -->
-        {#each suggestions as tag,i}
-            <li class="menu-item" class:selected={selectedIndex === i}>
-                <a href="#" on:mousedown|preventDefault={() => complete(tag)}>
-                    <div class="tile tile-centered">
-                        <div class="tile-content">
-                            {tag.name}
-                        </div>
-                    </div>
-                </a>
-            </li>
-        {/each}
-    </ul>
-</div>
-
-<style>
-    .menu {
-        display: none;
-        max-height: 200px;
-        overflow: auto;
-    }
-
-    .menu.open {
-        display: block;
-    }
-
-    .form-autocomplete.small .form-autocomplete-input {
-        height: 1.4rem;
-        min-height: 1.4rem;
-    }
-    .form-autocomplete.small .form-autocomplete-input input {
-        margin: 0;
-        padding: 0;
-        font-size: 0.7rem;
-    }
-    .form-autocomplete.small .menu .menu-item {
-        font-size: 0.7rem;
-    }
-</style>
--- a/bookmarks/components/api.js
+++ b/bookmarks/components/api.js
@@ -1,32 +0,0 @@
-export class ApiClient {
-    constructor(baseUrl) {
-        this.baseUrl = baseUrl
-    }
-
-    listBookmarks(filters, options = {limit: 100, offset: 0, path: ''}) {
-        const query = [
-          `limit=${options.limit}`,
-          `offset=${options.offset}`,
-        ]
-        Object.keys(filters).forEach(key => {
-            const value = filters[key]
-            if (value) {
-                query.push(`${key}=${encodeURIComponent(value)}`)
-            }
-        })
-        const queryString = query.join('&')
-        const url = `${this.baseUrl}bookmarks${options.path}/?${queryString}`
-
-        return fetch(url)
-            .then(response => response.json())
-            .then(data => data.results)
-    }
-
-    getTags(options = {limit: 100, offset: 0}) {
-        const url = `${this.baseUrl}tags/?limit=${options.limit}&offset=${options.offset}`
-
-        return fetch(url)
-            .then(response => response.json())
-            .then(data => data.results)
-    }
-}
--- a/bookmarks/components/index.js
+++ b/bookmarks/components/index.js
@@ -1,10 +0,0 @@
-import TagAutoComplete from './TagAutocomplete.svelte'
-import SearchAutoComplete from './SearchAutoComplete.svelte'
-import {ApiClient} from './api'
-
-export default {
-    ApiClient,
-    TagAutoComplete,
-    SearchAutoComplete
-}
-
--- a/bookmarks/components/util.js
+++ b/bookmarks/components/util.js
@@ -1,37 +0,0 @@
-export function debounce(callback, delay = 250) {
-    let timeoutId
-    return (...args) => {
-        clearTimeout(timeoutId)
-        timeoutId = setTimeout(() => {
-            timeoutId = null
-            callback(...args)
-        }, delay)
-    }
-}
-
-export function clampText(text, maxChars = 30) {
-    if(!text || text.length <= 30) return text
-
-    return text.substr(0, maxChars) + '...'
-}
-
-export function getCurrentWordBounds(input) {
-    const text = input.value;
-    const end = input.selectionStart;
-    let start = end;
-
-    let currentChar = text.charAt(start - 1);
-
-    while (currentChar && currentChar !== ' ' && start > 0) {
-        start--;
-        currentChar = text.charAt(start - 1);
-    }
-
-    return {start, end};
-}
-
-export function getCurrentWord(input) {
-    const bounds = getCurrentWordBounds(input);
-
-    return input.value.substring(bounds.start, bounds.end);
-}
--- a/bookmarks/context_processors.py
+++ b/bookmarks/context_processors.py
@@ -1,12 +1,36 @@
-from bookmarks.models import Toast
+from bookmarks import queries
+from bookmarks.models import BookmarkSearch, Toast
+from bookmarks import utils


 def toasts(request):
-    user = request.user if hasattr(request, 'user') else None
-    toast_messages = Toast.objects.filter(owner=user, acknowledged=False) if user and user.is_authenticated else []
+    user = request.user
+    toast_messages = (
+        Toast.objects.filter(owner=user, acknowledged=False)
+        if user.is_authenticated
+        else []
+    )
    has_toasts = len(toast_messages) > 0

    return {
-        'has_toasts': has_toasts,
-        'toast_messages': toast_messages,
+        "has_toasts": has_toasts,
+        "toast_messages": toast_messages,
    }
+
+
+def public_shares(request):
+    # Only check for public shares for anonymous users
+    if not request.user.is_authenticated:
+        query_set = queries.query_shared_bookmarks(
+            None, request.user_profile, BookmarkSearch(), True
+        )
+        has_public_shares = query_set.count() > 0
+        return {
+            "has_public_shares": has_public_shares,
+        }
+
+    return {}
+
+
+def app_version(request):
+    return {"app_version": utils.app_version}
--- a/bookmarks/e2e/e2e_test_bookmark_details_modal.py
+++ b/bookmarks/e2e/e2e_test_bookmark_details_modal.py
@@ -0,0 +1,133 @@
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+from bookmarks.models import Bookmark
+
+
+class BookmarkDetailsModalE2ETestCase(LinkdingE2ETestCase):
+    def test_show_details(self):
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:index"), p)
+
+            details_modal = self.open_details_modal(bookmark)
+            title = details_modal.locator("h2")
+            expect(title).to_have_text(bookmark.title)
+
+    def test_close_details(self):
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:index"), p)
+
+            # close with close button
+            details_modal = self.open_details_modal(bookmark)
+            details_modal.locator("button.close").click()
+            expect(details_modal).to_be_hidden()
+
+            # close with backdrop
+            details_modal = self.open_details_modal(bookmark)
+            overlay = details_modal.locator(".modal-overlay")
+            overlay.click(position={"x": 0, "y": 0})
+            expect(details_modal).to_be_hidden()
+
+    def test_toggle_archived(self):
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            # archive
+            url = reverse("bookmarks:index")
+            self.open(url, p)
+
+            details_modal = self.open_details_modal(bookmark)
+            details_modal.get_by_text("Archived", exact=False).click()
+            expect(self.locate_bookmark(bookmark.title)).not_to_be_visible()
+
+            # unarchive
+            url = reverse("bookmarks:archived")
+            self.page.goto(self.live_server_url + url)
+
+            details_modal = self.open_details_modal(bookmark)
+            details_modal.get_by_text("Archived", exact=False).click()
+            expect(self.locate_bookmark(bookmark.title)).not_to_be_visible()
+
+    def test_toggle_unread(self):
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            # mark as unread
+            url = reverse("bookmarks:index")
+            self.open(url, p)
+
+            details_modal = self.open_details_modal(bookmark)
+
+            details_modal.get_by_text("Unread").click()
+            bookmark_item = self.locate_bookmark(bookmark.title)
+            expect(bookmark_item.get_by_text("Unread")).to_be_visible()
+
+            # mark as read
+            details_modal.get_by_text("Unread").click()
+            bookmark_item = self.locate_bookmark(bookmark.title)
+            expect(bookmark_item.get_by_text("Unread")).not_to_be_visible()
+
+    def test_toggle_shared(self):
+        profile = self.get_or_create_test_user().profile
+        profile.enable_sharing = True
+        profile.save()
+
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            # share bookmark
+            url = reverse("bookmarks:index")
+            self.open(url, p)
+
+            details_modal = self.open_details_modal(bookmark)
+
+            details_modal.get_by_text("Shared").click()
+            bookmark_item = self.locate_bookmark(bookmark.title)
+            expect(bookmark_item.get_by_text("Shared")).to_be_visible()
+
+            # unshare bookmark
+            details_modal.get_by_text("Shared").click()
+            bookmark_item = self.locate_bookmark(bookmark.title)
+            expect(bookmark_item.get_by_text("Shared")).not_to_be_visible()
+
+    def test_edit_return_url(self):
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index") + f"?q={bookmark.title}"
+            self.open(url, p)
+
+            details_modal = self.open_details_modal(bookmark)
+
+            # Navigate to edit page
+            with self.page.expect_navigation():
+                details_modal.get_by_text("Edit").click()
+
+            # Cancel edit, verify return url
+            with self.page.expect_navigation(url=self.live_server_url + url):
+                self.page.get_by_text("Nevermind").click()
+
+    def test_delete(self):
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index") + f"?q={bookmark.title}"
+            self.open(url, p)
+
+            details_modal = self.open_details_modal(bookmark)
+
+            # Delete bookmark, verify return url
+            with self.page.expect_navigation(url=self.live_server_url + url):
+                details_modal.get_by_text("Delete...").click()
+                details_modal.get_by_text("Confirm").click()
+
+            # verify bookmark is deleted
+            self.locate_bookmark(bookmark.title)
+            expect(self.locate_bookmark(bookmark.title)).not_to_be_visible()
+
+        self.assertEqual(Bookmark.objects.count(), 0)
--- a/bookmarks/e2e/e2e_test_bookmark_details_view.py
+++ b/bookmarks/e2e/e2e_test_bookmark_details_view.py
@@ -0,0 +1,37 @@
+from django.urls import reverse
+from playwright.sync_api import sync_playwright
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+
+
+class BookmarkDetailsViewE2ETestCase(LinkdingE2ETestCase):
+    def test_edit_return_url(self):
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:details", args=[bookmark.id]), p)
+
+            # Navigate to edit page
+            with self.page.expect_navigation():
+                self.page.get_by_text("Edit").click()
+
+            # Cancel edit, verify return url
+            with self.page.expect_navigation(
+                url=self.live_server_url
+                + reverse("bookmarks:details", args=[bookmark.id])
+            ):
+                self.page.get_by_text("Nevermind").click()
+
+    def test_delete_return_url(self):
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:details", args=[bookmark.id]), p)
+
+            # Trigger delete, verify return url
+            # Should probably return to last bookmark list page, but for now just returns to index
+            with self.page.expect_navigation(
+                url=self.live_server_url + reverse("bookmarks:index")
+            ):
+                self.page.get_by_text("Delete...").click()
+                self.page.get_by_text("Confirm").click()
--- a/bookmarks/e2e/e2e_test_bookmark_form.py
+++ b/bookmarks/e2e/e2e_test_bookmark_form.py
@@ -0,0 +1,87 @@
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+
+
+class BookmarkFormE2ETestCase(LinkdingE2ETestCase):
+    def test_create_should_check_for_existing_bookmark(self):
+        existing_bookmark = self.setup_bookmark(
+            title="Existing title",
+            description="Existing description",
+            notes="Existing notes",
+            tags=[self.setup_tag(name="tag1"), self.setup_tag(name="tag2")],
+            website_title="Existing website title",
+            website_description="Existing website description",
+            unread=True,
+        )
+        tag_names = " ".join(existing_bookmark.tag_names)
+
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse("bookmarks:new"))
+
+            # Enter bookmarked URL
+            page.get_by_label("URL").fill(existing_bookmark.url)
+            # Already bookmarked hint should be visible
+            page.get_by_text("This URL is already bookmarked.").wait_for(timeout=2000)
+            # Form should be pre-filled with data from existing bookmark
+            self.assertEqual(
+                existing_bookmark.title, page.get_by_label("Title").input_value()
+            )
+            self.assertEqual(
+                existing_bookmark.description,
+                page.get_by_label("Description").input_value(),
+            )
+            self.assertEqual(
+                existing_bookmark.notes, page.get_by_label("Notes").input_value()
+            )
+            self.assertEqual(
+                existing_bookmark.website_title,
+                page.get_by_label("Title").get_attribute("placeholder"),
+            )
+            self.assertEqual(
+                existing_bookmark.website_description,
+                page.get_by_label("Description").get_attribute("placeholder"),
+            )
+            self.assertEqual(tag_names, page.get_by_label("Tags").input_value())
+            self.assertTrue(tag_names, page.get_by_label("Mark as unread").is_checked())
+
+            # Enter non-bookmarked URL
+            page.get_by_label("URL").fill("https://example.com/unknown")
+            # Already bookmarked hint should be hidden
+            page.get_by_text("This URL is already bookmarked.").wait_for(
+                state="hidden", timeout=2000
+            )
+
+            browser.close()
+
+    def test_edit_should_not_check_for_existing_bookmark(self):
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(
+                self.live_server_url + reverse("bookmarks:edit", args=[bookmark.id])
+            )
+
+            page.wait_for_timeout(timeout=1000)
+            page.get_by_text("This URL is already bookmarked.").wait_for(state="hidden")
+
+    def test_enter_url_of_existing_bookmark_should_show_notes(self):
+        bookmark = self.setup_bookmark(
+            notes="Existing notes", description="Existing description"
+        )
+
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse("bookmarks:new"))
+
+            details = page.locator("details.notes")
+            expect(details).not_to_have_attribute("open", value="")
+
+            page.get_by_label("URL").fill(bookmark.url)
+            expect(details).to_have_attribute("open", value="")
--- a/bookmarks/e2e/e2e_test_bookmark_item.py
+++ b/bookmarks/e2e/e2e_test_bookmark_item.py
@@ -6,20 +6,18 @@ from playwright.sync_api import sync_playwright, expect
 from bookmarks.e2e.helpers import LinkdingE2ETestCase


-@skip("Fails in CI, needs investigation")
-class BookmarkListE2ETestCase(LinkdingE2ETestCase):
+class BookmarkItemE2ETestCase(LinkdingE2ETestCase):
+    @skip("Fails in CI, needs investigation")
    def test_toggle_notes_should_show_hide_notes(self):
-        self.setup_bookmark(notes='Test notes')
+        bookmark = self.setup_bookmark(notes="Test notes")

        with sync_playwright() as p:
-            browser = self.setup_browser(p)
-            page = browser.new_page()
-            page.goto(self.live_server_url + reverse('bookmarks:index'))
+            page = self.open(reverse("bookmarks:index"), p)

-            notes = page.locator('li .notes')
+            notes = self.locate_bookmark(bookmark.title).locator(".notes")
            expect(notes).to_be_hidden()

-            toggle_notes = page.locator('li button.toggle-notes')
+            toggle_notes = page.locator("li button.toggle-notes")
            toggle_notes.click()
            expect(notes).to_be_visible()

--- a/bookmarks/e2e/e2e_test_bookmark_page_bulk_edit.py
+++ b/bookmarks/e2e/e2e_test_bookmark_page_bulk_edit.py
@@ -0,0 +1,335 @@
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+from bookmarks.models import Bookmark
+
+
+class BookmarkPagePartialUpdatesE2ETestCase(LinkdingE2ETestCase):
+    def setup_test_data(self):
+        self.setup_numbered_bookmarks(50)
+        self.setup_numbered_bookmarks(50, archived=True)
+        self.setup_numbered_bookmarks(50, prefix="foo")
+        self.setup_numbered_bookmarks(50, archived=True, prefix="foo")
+
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(
+                is_archived=False, title__startswith="Bookmark"
+            ).count(),
+        )
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(
+                is_archived=True, title__startswith="Archived Bookmark"
+            ).count(),
+        )
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(is_archived=False, title__startswith="foo").count(),
+        )
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(is_archived=True, title__startswith="foo").count(),
+        )
+
+    def test_active_bookmarks_bulk_select_across(self):
+        self.setup_test_data()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:index"), p)
+
+            bookmark_list = self.locate_bookmark_list()
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bulk_edit_select_all().click()
+            self.locate_bulk_edit_select_across().click()
+
+            self.select_bulk_action("Delete")
+            self.locate_bulk_edit_bar().get_by_text("Execute").click()
+            self.locate_bulk_edit_bar().get_by_text("Confirm").click()
+            # Wait until bookmark list is updated (old reference becomes invisible)
+            expect(bookmark_list).not_to_be_visible()
+
+        self.assertEqual(
+            0,
+            Bookmark.objects.filter(
+                is_archived=False, title__startswith="Bookmark"
+            ).count(),
+        )
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(
+                is_archived=True, title__startswith="Archived Bookmark"
+            ).count(),
+        )
+        self.assertEqual(
+            0,
+            Bookmark.objects.filter(is_archived=False, title__startswith="foo").count(),
+        )
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(is_archived=True, title__startswith="foo").count(),
+        )
+
+    def test_archived_bookmarks_bulk_select_across(self):
+        self.setup_test_data()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:archived"), p)
+
+            bookmark_list = self.locate_bookmark_list()
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bulk_edit_select_all().click()
+            self.locate_bulk_edit_select_across().click()
+
+            self.select_bulk_action("Delete")
+            self.locate_bulk_edit_bar().get_by_text("Execute").click()
+            self.locate_bulk_edit_bar().get_by_text("Confirm").click()
+            # Wait until bookmark list is updated (old reference becomes invisible)
+            expect(bookmark_list).not_to_be_visible()
+
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(
+                is_archived=False, title__startswith="Bookmark"
+            ).count(),
+        )
+        self.assertEqual(
+            0,
+            Bookmark.objects.filter(
+                is_archived=True, title__startswith="Archived Bookmark"
+            ).count(),
+        )
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(is_archived=False, title__startswith="foo").count(),
+        )
+        self.assertEqual(
+            0,
+            Bookmark.objects.filter(is_archived=True, title__startswith="foo").count(),
+        )
+
+    def test_active_bookmarks_bulk_select_across_respects_query(self):
+        self.setup_test_data()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:index") + "?q=foo", p)
+
+            bookmark_list = self.locate_bookmark_list()
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bulk_edit_select_all().click()
+            self.locate_bulk_edit_select_across().click()
+
+            self.select_bulk_action("Delete")
+            self.locate_bulk_edit_bar().get_by_text("Execute").click()
+            self.locate_bulk_edit_bar().get_by_text("Confirm").click()
+            # Wait until bookmark list is updated (old reference becomes invisible)
+            expect(bookmark_list).not_to_be_visible()
+
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(
+                is_archived=False, title__startswith="Bookmark"
+            ).count(),
+        )
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(
+                is_archived=True, title__startswith="Archived Bookmark"
+            ).count(),
+        )
+        self.assertEqual(
+            0,
+            Bookmark.objects.filter(is_archived=False, title__startswith="foo").count(),
+        )
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(is_archived=True, title__startswith="foo").count(),
+        )
+
+    def test_archived_bookmarks_bulk_select_across_respects_query(self):
+        self.setup_test_data()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:archived") + "?q=foo", p)
+
+            bookmark_list = self.locate_bookmark_list()
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bulk_edit_select_all().click()
+            self.locate_bulk_edit_select_across().click()
+
+            self.select_bulk_action("Delete")
+            self.locate_bulk_edit_bar().get_by_text("Execute").click()
+            self.locate_bulk_edit_bar().get_by_text("Confirm").click()
+            # Wait until bookmark list is updated (old reference becomes invisible)
+            expect(bookmark_list).not_to_be_visible()
+
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(
+                is_archived=False, title__startswith="Bookmark"
+            ).count(),
+        )
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(
+                is_archived=True, title__startswith="Archived Bookmark"
+            ).count(),
+        )
+        self.assertEqual(
+            50,
+            Bookmark.objects.filter(is_archived=False, title__startswith="foo").count(),
+        )
+        self.assertEqual(
+            0,
+            Bookmark.objects.filter(is_archived=True, title__startswith="foo").count(),
+        )
+
+    def test_select_all_toggles_all_checkboxes(self):
+        self.setup_numbered_bookmarks(5)
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index")
+            page = self.open(url, p)
+
+            self.locate_bulk_edit_toggle().click()
+
+            checkboxes = page.locator("label[ld-bulk-edit-checkbox] input")
+            self.assertEqual(6, checkboxes.count())
+            for i in range(checkboxes.count()):
+                expect(checkboxes.nth(i)).not_to_be_checked()
+
+            self.locate_bulk_edit_select_all().click()
+
+            for i in range(checkboxes.count()):
+                expect(checkboxes.nth(i)).to_be_checked()
+
+            self.locate_bulk_edit_select_all().click()
+
+            for i in range(checkboxes.count()):
+                expect(checkboxes.nth(i)).not_to_be_checked()
+
+    def test_select_all_shows_select_across(self):
+        self.setup_numbered_bookmarks(5)
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index")
+            self.open(url, p)
+
+            self.locate_bulk_edit_toggle().click()
+
+            expect(self.locate_bulk_edit_select_across()).not_to_be_visible()
+
+            self.locate_bulk_edit_select_all().click()
+            expect(self.locate_bulk_edit_select_across()).to_be_visible()
+
+            self.locate_bulk_edit_select_all().click()
+            expect(self.locate_bulk_edit_select_across()).not_to_be_visible()
+
+    def test_select_across_is_unchecked_when_toggling_all(self):
+        self.setup_numbered_bookmarks(5)
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index")
+            self.open(url, p)
+
+            self.locate_bulk_edit_toggle().click()
+
+            # Show select across, check it
+            self.locate_bulk_edit_select_all().click()
+            self.locate_bulk_edit_select_across().click()
+            expect(self.locate_bulk_edit_select_across()).to_be_checked()
+
+            # Hide select across by toggling select all
+            self.locate_bulk_edit_select_all().click()
+            expect(self.locate_bulk_edit_select_across()).not_to_be_visible()
+
+            # Show select across again, verify it is unchecked
+            self.locate_bulk_edit_select_all().click()
+            expect(self.locate_bulk_edit_select_across()).not_to_be_checked()
+
+    def test_select_across_is_unchecked_when_toggling_bookmark(self):
+        self.setup_numbered_bookmarks(5)
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index")
+            self.open(url, p)
+
+            self.locate_bulk_edit_toggle().click()
+
+            # Show select across, check it
+            self.locate_bulk_edit_select_all().click()
+            self.locate_bulk_edit_select_across().click()
+            expect(self.locate_bulk_edit_select_across()).to_be_checked()
+
+            # Hide select across by toggling a single bookmark
+            self.locate_bookmark("Bookmark 1").locator(
+                "label[ld-bulk-edit-checkbox]"
+            ).click()
+            expect(self.locate_bulk_edit_select_across()).not_to_be_visible()
+
+            # Show select across again, verify it is unchecked
+            self.locate_bookmark("Bookmark 1").locator(
+                "label[ld-bulk-edit-checkbox]"
+            ).click()
+            expect(self.locate_bulk_edit_select_across()).not_to_be_checked()
+
+    def test_execute_resets_all_checkboxes(self):
+        self.setup_numbered_bookmarks(100)
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index")
+            page = self.open(url, p)
+
+            bookmark_list = self.locate_bookmark_list()
+
+            # Select all bookmarks, enable select across
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bulk_edit_select_all().click()
+            self.locate_bulk_edit_select_across().click()
+
+            # Execute bulk action
+            self.select_bulk_action("Mark as unread")
+            self.locate_bulk_edit_bar().get_by_text("Execute").click()
+            self.locate_bulk_edit_bar().get_by_text("Confirm").click()
+
+            # Wait until bookmark list is updated (old reference becomes invisible)
+            expect(bookmark_list).not_to_be_visible()
+
+            # Verify bulk edit checkboxes are reset
+            checkboxes = page.locator("label[ld-bulk-edit-checkbox] input")
+            self.assertEqual(31, checkboxes.count())
+            for i in range(checkboxes.count()):
+                expect(checkboxes.nth(i)).not_to_be_checked()
+
+            # Toggle select all and verify select across is reset
+            self.locate_bulk_edit_select_all().click()
+            expect(self.locate_bulk_edit_select_across()).not_to_be_checked()
+
+    def test_update_select_across_bookmark_count(self):
+        self.setup_numbered_bookmarks(100)
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index")
+            self.open(url, p)
+
+            bookmark_list = self.locate_bookmark_list()
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bulk_edit_select_all().click()
+
+            expect(
+                self.locate_bulk_edit_bar().get_by_text("All pages (100 bookmarks)")
+            ).to_be_visible()
+
+            self.select_bulk_action("Delete")
+            self.locate_bulk_edit_bar().get_by_text("Execute").click()
+            self.locate_bulk_edit_bar().get_by_text("Confirm").click()
+            # Wait until bookmark list is updated (old reference becomes invisible)
+            expect(bookmark_list).not_to_be_visible()
+
+            expect(self.locate_bulk_edit_select_all()).not_to_be_checked()
+            self.locate_bulk_edit_select_all().click()
+
+            expect(
+                self.locate_bulk_edit_bar().get_by_text("All pages (70 bookmarks)")
+            ).to_be_visible()
--- a/bookmarks/e2e/e2e_test_bookmark_page_partial_updates.py
+++ b/bookmarks/e2e/e2e_test_bookmark_page_partial_updates.py
@@ -0,0 +1,308 @@
+from typing import List
+
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+
+
+class BookmarkPagePartialUpdatesE2ETestCase(LinkdingE2ETestCase):
+    def setup_fixture(self):
+        profile = self.get_or_create_test_user().profile
+        profile.enable_sharing = True
+        profile.save()
+
+        # create a number of bookmarks with different states / visibility to
+        # verify correct data is loaded on update
+        self.setup_numbered_bookmarks(3, with_tags=True)
+        self.setup_numbered_bookmarks(3, with_tags=True, archived=True)
+        self.setup_numbered_bookmarks(
+            3,
+            shared=True,
+            prefix="Joe's Bookmark",
+            user=self.setup_user(enable_sharing=True),
+        )
+
+    def assertVisibleBookmarks(self, titles: List[str]):
+        bookmark_tags = self.page.locator("li[ld-bookmark-item]")
+        expect(bookmark_tags).to_have_count(len(titles))
+
+        for title in titles:
+            matching_tag = bookmark_tags.filter(has_text=title)
+            expect(matching_tag).to_be_visible()
+
+    def assertVisibleTags(self, titles: List[str]):
+        tag_tags = self.page.locator(".tag-cloud .unselected-tags a")
+        expect(tag_tags).to_have_count(len(titles))
+
+        for title in titles:
+            matching_tag = tag_tags.filter(has_text=title)
+            expect(matching_tag).to_be_visible()
+
+    def test_partial_update_respects_query(self):
+        self.setup_numbered_bookmarks(5, prefix="foo")
+        self.setup_numbered_bookmarks(5, prefix="bar")
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index") + "?q=foo"
+            self.open(url, p)
+
+            self.assertVisibleBookmarks(["foo 1", "foo 2", "foo 3", "foo 4", "foo 5"])
+
+            self.locate_bookmark("foo 2").get_by_text("Archive").click()
+            self.assertVisibleBookmarks(["foo 1", "foo 3", "foo 4", "foo 5"])
+
+    def test_partial_update_respects_sort(self):
+        self.setup_numbered_bookmarks(5, prefix="foo")
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index") + "?sort=title_asc"
+            page = self.open(url, p)
+
+            first_item = page.locator("li[ld-bookmark-item]").first
+            expect(first_item).to_contain_text("foo 1")
+
+            first_item.get_by_text("Archive").click()
+
+            first_item = page.locator("li[ld-bookmark-item]").first
+            expect(first_item).to_contain_text("foo 2")
+
+    def test_partial_update_respects_page(self):
+        # add a suffix, otherwise 'foo 1' also matches 'foo 10'
+        self.setup_numbered_bookmarks(50, prefix="foo", suffix="-")
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index") + "?q=foo&page=2"
+            self.open(url, p)
+
+            # with descending sort, page two has 'foo 1' to 'foo 20'
+            expected_titles = [f"foo {i}-" for i in range(1, 21)]
+            self.assertVisibleBookmarks(expected_titles)
+
+            self.locate_bookmark("foo 20-").get_by_text("Archive").click()
+
+            expected_titles = [f"foo {i}-" for i in range(1, 20)]
+            self.assertVisibleBookmarks(expected_titles)
+
+    def test_multiple_partial_updates(self):
+        self.setup_numbered_bookmarks(5)
+
+        with sync_playwright() as p:
+            url = reverse("bookmarks:index")
+            self.open(url, p)
+
+            self.locate_bookmark("Bookmark 1").get_by_text("Archive").click()
+            self.assertVisibleBookmarks(
+                ["Bookmark 2", "Bookmark 3", "Bookmark 4", "Bookmark 5"]
+            )
+
+            self.locate_bookmark("Bookmark 2").get_by_text("Archive").click()
+            self.assertVisibleBookmarks(["Bookmark 3", "Bookmark 4", "Bookmark 5"])
+
+            self.locate_bookmark("Bookmark 3").get_by_text("Archive").click()
+            self.assertVisibleBookmarks(["Bookmark 4", "Bookmark 5"])
+
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_archive(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:index"), p)
+
+            self.locate_bookmark("Bookmark 2").get_by_text("Archive").click()
+
+            self.assertVisibleBookmarks(["Bookmark 1", "Bookmark 3"])
+            self.assertVisibleTags(["Tag 1", "Tag 3"])
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_delete(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:index"), p)
+
+            self.locate_bookmark("Bookmark 2").get_by_text("Remove").click()
+            self.locate_bookmark("Bookmark 2").get_by_text("Confirm").click()
+
+            self.assertVisibleBookmarks(["Bookmark 1", "Bookmark 3"])
+            self.assertVisibleTags(["Tag 1", "Tag 3"])
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_mark_as_read(self):
+        self.setup_fixture()
+        bookmark2 = self.get_numbered_bookmark("Bookmark 2")
+        bookmark2.unread = True
+        bookmark2.save()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:index"), p)
+
+            expect(self.locate_bookmark("Bookmark 2")).to_have_class("unread")
+            self.locate_bookmark("Bookmark 2").get_by_text("Unread").click()
+            self.locate_bookmark("Bookmark 2").get_by_text("Yes").click()
+
+            expect(self.locate_bookmark("Bookmark 2")).not_to_have_class("unread")
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_unshare(self):
+        self.setup_fixture()
+        bookmark2 = self.get_numbered_bookmark("Bookmark 2")
+        bookmark2.shared = True
+        bookmark2.save()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:index"), p)
+
+            expect(self.locate_bookmark("Bookmark 2")).to_have_class("shared")
+            self.locate_bookmark("Bookmark 2").get_by_text("Shared").click()
+            self.locate_bookmark("Bookmark 2").get_by_text("Yes").click()
+
+            expect(self.locate_bookmark("Bookmark 2")).not_to_have_class("shared")
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_bulk_archive(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:index"), p)
+
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bookmark("Bookmark 2").locator(
+                "label[ld-bulk-edit-checkbox]"
+            ).click()
+            self.select_bulk_action("Archive")
+            self.locate_bulk_edit_bar().get_by_text("Execute").click()
+            self.locate_bulk_edit_bar().get_by_text("Confirm").click()
+
+            self.assertVisibleBookmarks(["Bookmark 1", "Bookmark 3"])
+            self.assertVisibleTags(["Tag 1", "Tag 3"])
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_bulk_delete(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:index"), p)
+
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bookmark("Bookmark 2").locator(
+                "label[ld-bulk-edit-checkbox]"
+            ).click()
+            self.select_bulk_action("Delete")
+            self.locate_bulk_edit_bar().get_by_text("Execute").click()
+            self.locate_bulk_edit_bar().get_by_text("Confirm").click()
+
+            self.assertVisibleBookmarks(["Bookmark 1", "Bookmark 3"])
+            self.assertVisibleTags(["Tag 1", "Tag 3"])
+            self.assertReloads(0)
+
+    def test_archived_bookmarks_partial_update_on_unarchive(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:archived"), p)
+
+            self.locate_bookmark("Archived Bookmark 2").get_by_text("Unarchive").click()
+
+            self.assertVisibleBookmarks(["Archived Bookmark 1", "Archived Bookmark 3"])
+            self.assertVisibleTags(["Archived Tag 1", "Archived Tag 3"])
+            self.assertReloads(0)
+
+    def test_archived_bookmarks_partial_update_on_delete(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:archived"), p)
+
+            self.locate_bookmark("Archived Bookmark 2").get_by_text("Remove").click()
+            self.locate_bookmark("Archived Bookmark 2").get_by_text("Confirm").click()
+
+            self.assertVisibleBookmarks(["Archived Bookmark 1", "Archived Bookmark 3"])
+            self.assertVisibleTags(["Archived Tag 1", "Archived Tag 3"])
+            self.assertReloads(0)
+
+    def test_archived_bookmarks_partial_update_on_bulk_unarchive(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:archived"), p)
+
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bookmark("Archived Bookmark 2").locator(
+                "label[ld-bulk-edit-checkbox]"
+            ).click()
+            self.select_bulk_action("Unarchive")
+            self.locate_bulk_edit_bar().get_by_text("Execute").click()
+            self.locate_bulk_edit_bar().get_by_text("Confirm").click()
+
+            self.assertVisibleBookmarks(["Archived Bookmark 1", "Archived Bookmark 3"])
+            self.assertVisibleTags(["Archived Tag 1", "Archived Tag 3"])
+            self.assertReloads(0)
+
+    def test_archived_bookmarks_partial_update_on_bulk_delete(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:archived"), p)
+
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bookmark("Archived Bookmark 2").locator(
+                "label[ld-bulk-edit-checkbox]"
+            ).click()
+            self.select_bulk_action("Delete")
+            self.locate_bulk_edit_bar().get_by_text("Execute").click()
+            self.locate_bulk_edit_bar().get_by_text("Confirm").click()
+
+            self.assertVisibleBookmarks(["Archived Bookmark 1", "Archived Bookmark 3"])
+            self.assertVisibleTags(["Archived Tag 1", "Archived Tag 3"])
+            self.assertReloads(0)
+
+    def test_shared_bookmarks_partial_update_on_unarchive(self):
+        self.setup_fixture()
+        self.setup_numbered_bookmarks(
+            3, shared=True, prefix="My Bookmark", with_tags=True
+        )
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:shared"), p)
+
+            self.locate_bookmark("My Bookmark 2").get_by_text("Archive").click()
+
+            # Shared bookmarks page also shows archived bookmarks, though it probably shouldn't
+            self.assertVisibleBookmarks(
+                [
+                    "My Bookmark 1",
+                    "My Bookmark 2",
+                    "My Bookmark 3",
+                    "Joe's Bookmark 1",
+                    "Joe's Bookmark 2",
+                    "Joe's Bookmark 3",
+                ]
+            )
+            self.assertVisibleTags(["Shared Tag 1", "Shared Tag 2", "Shared Tag 3"])
+            self.assertReloads(0)
+
+    def test_shared_bookmarks_partial_update_on_delete(self):
+        self.setup_fixture()
+        self.setup_numbered_bookmarks(
+            3, shared=True, prefix="My Bookmark", with_tags=True
+        )
+
+        with sync_playwright() as p:
+            self.open(reverse("bookmarks:shared"), p)
+
+            self.locate_bookmark("My Bookmark 2").get_by_text("Remove").click()
+            self.locate_bookmark("My Bookmark 2").get_by_text("Confirm").click()
+
+            self.assertVisibleBookmarks(
+                [
+                    "My Bookmark 1",
+                    "My Bookmark 3",
+                    "Joe's Bookmark 1",
+                    "Joe's Bookmark 2",
+                    "Joe's Bookmark 3",
+                ]
+            )
+            self.assertVisibleTags(["Shared Tag 1", "Shared Tag 3"])
+            self.assertReloads(0)
--- a/bookmarks/e2e/e2e_test_global_shortcuts.py
+++ b/bookmarks/e2e/e2e_test_global_shortcuts.py
@@ -9,11 +9,11 @@ class GlobalShortcutsE2ETestCase(LinkdingE2ETestCase):
        with sync_playwright() as p:
            browser = self.setup_browser(p)
            page = browser.new_page()
-            page.goto(self.live_server_url + reverse('bookmarks:index'))
+            page.goto(self.live_server_url + reverse("bookmarks:index"))

-            page.press('body', 's')
+            page.press("body", "s")

-            expect(page.get_by_placeholder('Search for words or #tags')).to_be_focused()
+            expect(page.get_by_placeholder("Search for words or #tags")).to_be_focused()

            browser.close()

@@ -21,10 +21,10 @@ class GlobalShortcutsE2ETestCase(LinkdingE2ETestCase):
        with sync_playwright() as p:
            browser = self.setup_browser(p)
            page = browser.new_page()
-            page.goto(self.live_server_url + reverse('bookmarks:index'))
+            page.goto(self.live_server_url + reverse("bookmarks:index"))

-            page.press('body', 'n')
+            page.press("body", "n")

-            expect(page).to_have_url(self.live_server_url + reverse('bookmarks:new'))
+            expect(page).to_have_url(self.live_server_url + reverse("bookmarks:new"))

            browser.close()
--- a/bookmarks/e2e/e2e_test_settings_general.py
+++ b/bookmarks/e2e/e2e_test_settings_general.py
@@ -0,0 +1,88 @@
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+from bookmarks.models import UserProfile
+
+
+class SettingsGeneralE2ETestCase(LinkdingE2ETestCase):
+    def test_should_only_enable_public_sharing_if_sharing_is_enabled(self):
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse("bookmarks:settings.general"))
+
+            enable_sharing = page.get_by_label("Enable bookmark sharing")
+            enable_sharing_label = page.get_by_text("Enable bookmark sharing")
+            enable_public_sharing = page.get_by_label("Enable public bookmark sharing")
+            enable_public_sharing_label = page.get_by_text(
+                "Enable public bookmark sharing"
+            )
+
+            # Public sharing is disabled by default
+            expect(enable_sharing).not_to_be_checked()
+            expect(enable_public_sharing).not_to_be_checked()
+            expect(enable_public_sharing).to_be_disabled()
+
+            # Enable sharing
+            enable_sharing_label.click()
+            expect(enable_sharing).to_be_checked()
+            expect(enable_public_sharing).not_to_be_checked()
+            expect(enable_public_sharing).to_be_enabled()
+
+            # Enable public sharing
+            enable_public_sharing_label.click()
+            expect(enable_public_sharing).to_be_checked()
+            expect(enable_public_sharing).to_be_enabled()
+
+            # Disable sharing
+            enable_sharing_label.click()
+            expect(enable_sharing).not_to_be_checked()
+            expect(enable_public_sharing).not_to_be_checked()
+            expect(enable_public_sharing).to_be_disabled()
+
+    def test_should_not_show_bookmark_description_max_lines_when_display_inline(self):
+        profile = self.get_or_create_test_user().profile
+        profile.bookmark_description_display = (
+            UserProfile.BOOKMARK_DESCRIPTION_DISPLAY_INLINE
+        )
+        profile.save()
+
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse("bookmarks:settings.general"))
+
+            max_lines = page.get_by_label("Bookmark description max lines")
+            expect(max_lines).to_be_hidden()
+
+    def test_should_show_bookmark_description_max_lines_when_display_separate(self):
+        profile = self.get_or_create_test_user().profile
+        profile.bookmark_description_display = (
+            UserProfile.BOOKMARK_DESCRIPTION_DISPLAY_SEPARATE
+        )
+        profile.save()
+
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse("bookmarks:settings.general"))
+
+            max_lines = page.get_by_label("Bookmark description max lines")
+            expect(max_lines).to_be_visible()
+
+    def test_should_update_bookmark_description_max_lines_when_changing_display(self):
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse("bookmarks:settings.general"))
+
+            max_lines = page.get_by_label("Bookmark description max lines")
+            expect(max_lines).to_be_hidden()
+
+            display = page.get_by_label("Bookmark description", exact=True)
+            display.select_option("separate")
+            expect(max_lines).to_be_visible()
+
+            display.select_option("inline")
+            expect(max_lines).to_be_hidden()
--- a/bookmarks/e2e/helpers.py
+++ b/bookmarks/e2e/helpers.py
@@ -1,5 +1,6 @@
 from django.contrib.staticfiles.testing import LiveServerTestCase
-from playwright.sync_api import BrowserContext
+from playwright.sync_api import BrowserContext, Playwright, Page
+from playwright.sync_api import expect

 from bookmarks.tests.helpers import BookmarkFactoryMixin

@@ -7,15 +8,71 @@ from bookmarks.tests.helpers import BookmarkFactoryMixin
 class LinkdingE2ETestCase(LiveServerTestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.client.force_login(self.get_or_create_test_user())
-        self.cookie = self.client.cookies['sessionid']
+        self.cookie = self.client.cookies["sessionid"]

    def setup_browser(self, playwright) -> BrowserContext:
        browser = playwright.chromium.launch(headless=True)
        context = browser.new_context()
-        context.add_cookies([{
-            'name': 'sessionid',
-            'value': self.cookie.value,
-            'domain': self.live_server_url.replace('http:', ''),
-            'path': '/'
-        }])
+        context.add_cookies(
+            [
+                {
+                    "name": "sessionid",
+                    "value": self.cookie.value,
+                    "domain": self.live_server_url.replace("http:", ""),
+                    "path": "/",
+                }
+            ]
+        )
        return context
+
+    def open(self, url: str, playwright: Playwright) -> Page:
+        browser = self.setup_browser(playwright)
+        self.page = browser.new_page()
+        self.page.goto(self.live_server_url + url)
+        self.page.on("load", self.on_load)
+        self.num_loads = 0
+        return self.page
+
+    def on_load(self):
+        self.num_loads += 1
+
+    def assertReloads(self, count: int):
+        self.assertEqual(self.num_loads, count)
+
+    def locate_bookmark_list(self):
+        return self.page.locator("ul[ld-bookmark-list]")
+
+    def locate_bookmark(self, title: str):
+        bookmark_tags = self.page.locator("li[ld-bookmark-item]")
+        return bookmark_tags.filter(has_text=title)
+
+    def locate_details_modal(self):
+        return self.page.locator(".modal.bookmark-details")
+
+    def open_details_modal(self, bookmark):
+        details_button = self.locate_bookmark(bookmark.title).get_by_text("View")
+        details_button.click()
+
+        details_modal = self.locate_details_modal()
+        expect(details_modal).to_be_visible()
+
+        return details_modal
+
+    def locate_bulk_edit_bar(self):
+        return self.page.locator(".bulk-edit-bar")
+
+    def locate_bulk_edit_select_all(self):
+        return self.locate_bulk_edit_bar().locator("label[ld-bulk-edit-checkbox][all]")
+
+    def locate_bulk_edit_select_across(self):
+        return self.locate_bulk_edit_bar().locator("label.select-across")
+
+    def locate_bulk_edit_toggle(self):
+        return self.page.get_by_title("Bulk edit")
+
+    def select_bulk_action(self, value: str):
+        return (
+            self.locate_bulk_edit_bar()
+            .locator('select[name="bulk_action"]')
+            .select_option(value)
+        )
--- a/bookmarks/e2e/test_bookmark_form.py
+++ b/bookmarks/e2e/test_bookmark_form.py
@@ -1,67 +0,0 @@
-from django.urls import reverse
-from playwright.sync_api import sync_playwright, expect
-
-from bookmarks.e2e.helpers import LinkdingE2ETestCase
-
-
-class BookmarkFormE2ETestCase(LinkdingE2ETestCase):
-    def test_create_should_check_for_existing_bookmark(self):
-        existing_bookmark = self.setup_bookmark(title='Existing title',
-                                                description='Existing description',
-                                                notes='Existing notes',
-                                                tags=[self.setup_tag(name='tag1'), self.setup_tag(name='tag2')],
-                                                website_title='Existing website title',
-                                                website_description='Existing website description',
-                                                unread=True)
-        tag_names = ' '.join(existing_bookmark.tag_names)
-
-        with sync_playwright() as p:
-            browser = self.setup_browser(p)
-            page = browser.new_page()
-            page.goto(self.live_server_url + reverse('bookmarks:new'))
-
-            # Enter bookmarked URL
-            page.get_by_label('URL').fill(existing_bookmark.url)
-            # Already bookmarked hint should be visible
-            page.get_by_text('This URL is already bookmarked.').wait_for(timeout=2000)
-            # Form should be pre-filled with data from existing bookmark
-            self.assertEqual(existing_bookmark.title, page.get_by_label('Title').input_value())
-            self.assertEqual(existing_bookmark.description, page.get_by_label('Description').input_value())
-            self.assertEqual(existing_bookmark.notes, page.get_by_label('Notes').input_value())
-            self.assertEqual(existing_bookmark.website_title, page.get_by_label('Title').get_attribute('placeholder'))
-            self.assertEqual(existing_bookmark.website_description,
-                             page.get_by_label('Description').get_attribute('placeholder'))
-            self.assertEqual(tag_names, page.get_by_label('Tags').input_value())
-            self.assertTrue(tag_names, page.get_by_label('Mark as unread').is_checked())
-
-            # Enter non-bookmarked URL
-            page.get_by_label('URL').fill('https://example.com/unknown')
-            # Already bookmarked hint should be hidden
-            page.get_by_text('This URL is already bookmarked.').wait_for(state='hidden', timeout=2000)
-
-            browser.close()
-
-    def test_edit_should_not_check_for_existing_bookmark(self):
-        bookmark = self.setup_bookmark()
-
-        with sync_playwright() as p:
-            browser = self.setup_browser(p)
-            page = browser.new_page()
-            page.goto(self.live_server_url + reverse('bookmarks:edit', args=[bookmark.id]))
-
-            page.wait_for_timeout(timeout=1000)
-            page.get_by_text('This URL is already bookmarked.').wait_for(state='hidden')
-
-    def test_enter_url_of_existing_bookmark_should_show_notes(self):
-        bookmark = self.setup_bookmark(notes='Existing notes', description='Existing description')
-
-        with sync_playwright() as p:
-            browser = self.setup_browser(p)
-            page = browser.new_page()
-            page.goto(self.live_server_url + reverse('bookmarks:new'))
-
-            details = page.locator('details.notes')
-            expect(details).not_to_have_attribute('open', value='')
-
-            page.get_by_label('URL').fill(bookmark.url)
-            expect(details).to_have_attribute('open', value='')
--- a/bookmarks/feeds.py
+++ b/bookmarks/feeds.py
@@ -1,31 +1,44 @@
+import unicodedata
 from dataclasses import dataclass

 from django.contrib.syndication.views import Feed
 from django.db.models import QuerySet
 from django.urls import reverse

-from bookmarks.models import Bookmark, FeedToken
 from bookmarks import queries
+from bookmarks.models import Bookmark, BookmarkSearch, FeedToken, UserProfile


@dataclass
 class FeedContext:
-    feed_token: FeedToken
+    feed_token: FeedToken | None
    query_set: QuerySet[Bookmark]


+def sanitize(text: str):
+    if not text:
+        return ""
+    # remove control characters
+    valid_chars = ["\n", "\r", "\t"]
+    return "".join(
+        ch for ch in text if ch in valid_chars or unicodedata.category(ch)[0] != "C"
+    )
+
+
 class BaseBookmarksFeed(Feed):
    def get_object(self, request, feed_key: str):
        feed_token = FeedToken.objects.get(key__exact=feed_key)
-        query_string = request.GET.get('q')
-        query_set = queries.query_bookmarks(feed_token.user, feed_token.user.profile, query_string)
+        search = BookmarkSearch(q=request.GET.get("q", ""))
+        query_set = queries.query_bookmarks(
+            feed_token.user, feed_token.user.profile, search
+        )
        return FeedContext(feed_token, query_set)

    def item_title(self, item: Bookmark):
-        return item.resolved_title
+        return sanitize(item.resolved_title)

    def item_description(self, item: Bookmark):
-        return item.resolved_description
+        return sanitize(item.resolved_description)

    def item_link(self, item: Bookmark):
        return item.url
@@ -35,22 +48,58 @@ class BaseBookmarksFeed(Feed):


 class AllBookmarksFeed(BaseBookmarksFeed):
-    title = 'All bookmarks'
-    description = 'All bookmarks'
+    title = "All bookmarks"
+    description = "All bookmarks"

    def link(self, context: FeedContext):
-        return reverse('bookmarks:feeds.all', args=[context.feed_token.key])
+        return reverse("bookmarks:feeds.all", args=[context.feed_token.key])

    def items(self, context: FeedContext):
        return context.query_set


 class UnreadBookmarksFeed(BaseBookmarksFeed):
-    title = 'Unread bookmarks'
-    description = 'All unread bookmarks'
+    title = "Unread bookmarks"
+    description = "All unread bookmarks"

    def link(self, context: FeedContext):
-        return reverse('bookmarks:feeds.unread', args=[context.feed_token.key])
+        return reverse("bookmarks:feeds.unread", args=[context.feed_token.key])

    def items(self, context: FeedContext):
        return context.query_set.filter(unread=True)
+
+
+class SharedBookmarksFeed(BaseBookmarksFeed):
+    title = "Shared bookmarks"
+    description = "All shared bookmarks"
+
+    def get_object(self, request, feed_key: str):
+        feed_token = FeedToken.objects.get(key__exact=feed_key)
+        search = BookmarkSearch(q=request.GET.get("q", ""))
+        query_set = queries.query_shared_bookmarks(
+            None, feed_token.user.profile, search, False
+        )
+        return FeedContext(feed_token, query_set)
+
+    def link(self, context: FeedContext):
+        return reverse("bookmarks:feeds.shared", args=[context.feed_token.key])
+
+    def items(self, context: FeedContext):
+        return context.query_set
+
+
+class PublicSharedBookmarksFeed(BaseBookmarksFeed):
+    title = "Public shared bookmarks"
+    description = "All public shared bookmarks"
+
+    def get_object(self, request):
+        search = BookmarkSearch(q=request.GET.get("q", ""))
+        default_profile = UserProfile()
+        query_set = queries.query_shared_bookmarks(None, default_profile, search, True)
+        return FeedContext(None, query_set)
+
+    def link(self, context: FeedContext):
+        return reverse("bookmarks:feeds.public_shared")
+
+    def items(self, context: FeedContext):
+        return context.query_set
--- a/bookmarks/frontend/api.js
+++ b/bookmarks/frontend/api.js
@@ -0,0 +1,29 @@
+export class ApiClient {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+
+  listBookmarks(search, options = { limit: 100, offset: 0, path: "" }) {
+    const query = [`limit=${options.limit}`, `offset=${options.offset}`];
+    Object.keys(search).forEach((key) => {
+      const value = search[key];
+      if (value) {
+        query.push(`${key}=${encodeURIComponent(value)}`);
+      }
+    });
+    const queryString = query.join("&");
+    const url = `${this.baseUrl}bookmarks${options.path}/?${queryString}`;
+
+    return fetch(url)
+      .then((response) => response.json())
+      .then((data) => data.results);
+  }
+
+  getTags(options = { limit: 100, offset: 0 }) {
+    const url = `${this.baseUrl}tags/?limit=${options.limit}&offset=${options.offset}`;
+
+    return fetch(url)
+      .then((response) => response.json())
+      .then((data) => data.results);
+  }
+}
--- a/bookmarks/frontend/behaviors/bookmark-page.js
+++ b/bookmarks/frontend/behaviors/bookmark-page.js
@@ -0,0 +1,87 @@
+import { registerBehavior, swapContent } from "./index";
+
+class BookmarkPage {
+  constructor(element) {
+    this.element = element;
+    this.form = element.querySelector("form.bookmark-actions");
+    this.form.addEventListener("submit", this.onFormSubmit.bind(this));
+
+    this.bookmarkList = element.querySelector(".bookmark-list-container");
+    this.tagCloud = element.querySelector(".tag-cloud-container");
+
+    document.addEventListener("bookmark-page-refresh", () => {
+      this.refresh();
+    });
+  }
+
+  async onFormSubmit(event) {
+    event.preventDefault();
+
+    const url = this.form.action;
+    const formData = new FormData(this.form);
+    formData.append(event.submitter.name, event.submitter.value);
+
+    await fetch(url, {
+      method: "POST",
+      body: formData,
+      redirect: "manual", // ignore redirect
+    });
+    await this.refresh();
+  }
+
+  async refresh() {
+    const query = window.location.search;
+    const bookmarksUrl = this.element.getAttribute("bookmarks-url");
+    const tagsUrl = this.element.getAttribute("tags-url");
+    Promise.all([
+      fetch(`${bookmarksUrl}${query}`).then((response) => response.text()),
+      fetch(`${tagsUrl}${query}`).then((response) => response.text()),
+    ]).then(([bookmarkListHtml, tagCloudHtml]) => {
+      swapContent(this.bookmarkList, bookmarkListHtml);
+      swapContent(this.tagCloud, tagCloudHtml);
+
+      // Dispatch list updated event
+      const listElement = this.bookmarkList.querySelector(
+        "ul[data-bookmarks-total]",
+      );
+      const bookmarksTotal =
+        (listElement && listElement.dataset.bookmarksTotal) || 0;
+
+      this.bookmarkList.dispatchEvent(
+        new CustomEvent("bookmark-list-updated", {
+          bubbles: true,
+          detail: { bookmarksTotal },
+        }),
+      );
+    });
+  }
+}
+
+registerBehavior("ld-bookmark-page", BookmarkPage);
+
+class BookmarkItem {
+  constructor(element) {
+    this.element = element;
+
+    // Toggle notes
+    const notesToggle = element.querySelector(".toggle-notes");
+    if (notesToggle) {
+      notesToggle.addEventListener("click", this.onToggleNotes.bind(this));
+    }
+
+    // Add tooltip to title if it is truncated
+    const titleAnchor = element.querySelector(".title > a");
+    const titleSpan = titleAnchor.querySelector("span");
+    if (titleSpan.offsetWidth > titleAnchor.offsetWidth) {
+      titleAnchor.dataset.tooltip = titleSpan.textContent;
+    }
+  }
+
+  onToggleNotes(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    this.element.classList.toggle("show-notes");
+  }
+}
+
+registerBehavior("ld-bookmark-item", BookmarkItem);
--- a/bookmarks/frontend/behaviors/bulk-edit.js
+++ b/bookmarks/frontend/behaviors/bulk-edit.js
@@ -0,0 +1,141 @@
+import { registerBehavior } from "./index";
+
+class BulkEdit {
+  constructor(element) {
+    this.element = element;
+    this.active = false;
+    this.actionSelect = element.querySelector("select[name='bulk_action']");
+    this.tagAutoComplete = element.querySelector(".tag-autocomplete");
+    this.selectAcross = element.querySelector("label.select-across");
+
+    element.addEventListener(
+      "bulk-edit-toggle-active",
+      this.onToggleActive.bind(this),
+    );
+    element.addEventListener(
+      "bulk-edit-toggle-all",
+      this.onToggleAll.bind(this),
+    );
+    element.addEventListener(
+      "bulk-edit-toggle-bookmark",
+      this.onToggleBookmark.bind(this),
+    );
+    element.addEventListener(
+      "bookmark-list-updated",
+      this.onListUpdated.bind(this),
+    );
+
+    this.actionSelect.addEventListener(
+      "change",
+      this.onActionSelected.bind(this),
+    );
+  }
+
+  get allCheckbox() {
+    return this.element.querySelector("[ld-bulk-edit-checkbox][all] input");
+  }
+
+  get bookmarkCheckboxes() {
+    return [
+      ...this.element.querySelectorAll(
+        "[ld-bulk-edit-checkbox]:not([all]) input",
+      ),
+    ];
+  }
+
+  onToggleActive() {
+    this.active = !this.active;
+    if (this.active) {
+      this.element.classList.add("active", "activating");
+      setTimeout(() => {
+        this.element.classList.remove("activating");
+      }, 500);
+    } else {
+      this.element.classList.remove("active");
+    }
+  }
+
+  onToggleBookmark() {
+    const allChecked = this.bookmarkCheckboxes.every((checkbox) => {
+      return checkbox.checked;
+    });
+    this.allCheckbox.checked = allChecked;
+    this.updateSelectAcross(allChecked);
+  }
+
+  onToggleAll() {
+    const allChecked = this.allCheckbox.checked;
+    this.bookmarkCheckboxes.forEach((checkbox) => {
+      checkbox.checked = allChecked;
+    });
+    this.updateSelectAcross(allChecked);
+  }
+
+  onActionSelected() {
+    const action = this.actionSelect.value;
+
+    if (action === "bulk_tag" || action === "bulk_untag") {
+      this.tagAutoComplete.classList.remove("d-none");
+    } else {
+      this.tagAutoComplete.classList.add("d-none");
+    }
+  }
+
+  onListUpdated(event) {
+    // Reset checkbox states
+    this.reset();
+
+    // Update total number of bookmarks
+    const total = event.detail.bookmarksTotal;
+    const totalSpan = this.selectAcross.querySelector("span.total");
+    totalSpan.textContent = total;
+  }
+
+  updateSelectAcross(allChecked) {
+    if (allChecked) {
+      this.selectAcross.classList.remove("d-none");
+    } else {
+      this.selectAcross.classList.add("d-none");
+      this.selectAcross.querySelector("input").checked = false;
+    }
+  }
+
+  reset() {
+    this.allCheckbox.checked = false;
+    this.bookmarkCheckboxes.forEach((checkbox) => {
+      checkbox.checked = false;
+    });
+    this.updateSelectAcross(false);
+  }
+}
+
+class BulkEditActiveToggle {
+  constructor(element) {
+    this.element = element;
+    element.addEventListener("click", this.onClick.bind(this));
+  }
+
+  onClick() {
+    this.element.dispatchEvent(
+      new CustomEvent("bulk-edit-toggle-active", { bubbles: true }),
+    );
+  }
+}
+
+class BulkEditCheckbox {
+  constructor(element) {
+    this.element = element;
+    element.addEventListener("change", this.onChange.bind(this));
+  }
+
+  onChange() {
+    const type = this.element.hasAttribute("all") ? "all" : "bookmark";
+    this.element.dispatchEvent(
+      new CustomEvent(`bulk-edit-toggle-${type}`, { bubbles: true }),
+    );
+  }
+}
+
+registerBehavior("ld-bulk-edit", BulkEdit);
+registerBehavior("ld-bulk-edit-active-toggle", BulkEditActiveToggle);
+registerBehavior("ld-bulk-edit-checkbox", BulkEditCheckbox);
--- a/bookmarks/frontend/behaviors/confirm-button.js
+++ b/bookmarks/frontend/behaviors/confirm-button.js
@@ -0,0 +1,74 @@
+import { registerBehavior } from "./index";
+
+class ConfirmButtonBehavior {
+  constructor(element) {
+    const button = element;
+    button.dataset.type = button.type;
+    button.dataset.name = button.name;
+    button.dataset.value = button.value;
+    button.removeAttribute("type");
+    button.removeAttribute("name");
+    button.removeAttribute("value");
+    button.addEventListener("click", this.onClick.bind(this));
+    this.button = button;
+  }
+
+  onClick(event) {
+    event.preventDefault();
+
+    const container = document.createElement("span");
+    container.className = "confirmation";
+
+    const icon = this.button.getAttribute("confirm-icon");
+    if (icon) {
+      const iconElement = document.createElementNS(
+        "http://www.w3.org/2000/svg",
+        "svg",
+      );
+      iconElement.style.width = "16px";
+      iconElement.style.height = "16px";
+      iconElement.innerHTML = `<use xlink:href="#${icon}"></use>`;
+      container.append(iconElement);
+    }
+
+    const question = this.button.getAttribute("confirm-question");
+    if (question) {
+      const questionElement = document.createElement("span");
+      questionElement.innerText = question;
+      container.append(question);
+    }
+
+    const buttonClasses = Array.from(this.button.classList.values())
+      .filter((cls) => cls.startsWith("btn"))
+      .join(" ");
+
+    const cancelButton = document.createElement(this.button.nodeName);
+    cancelButton.type = "button";
+    cancelButton.innerText = question ? "No" : "Cancel";
+    cancelButton.className = `${buttonClasses} mr-1`;
+    cancelButton.addEventListener("click", this.reset.bind(this));
+
+    const confirmButton = document.createElement(this.button.nodeName);
+    confirmButton.type = this.button.dataset.type;
+    confirmButton.name = this.button.dataset.name;
+    confirmButton.value = this.button.dataset.value;
+    confirmButton.innerText = question ? "Yes" : "Confirm";
+    confirmButton.className = buttonClasses;
+    confirmButton.addEventListener("click", this.reset.bind(this));
+
+    container.append(cancelButton, confirmButton);
+    this.container = container;
+
+    this.button.before(container);
+    this.button.classList.add("d-none");
+  }
+
+  reset() {
+    setTimeout(() => {
+      this.container.remove();
+      this.button.classList.remove("d-none");
+    });
+  }
+}
+
+registerBehavior("ld-confirm-button", ConfirmButtonBehavior);
--- a/bookmarks/frontend/behaviors/dropdown.js
+++ b/bookmarks/frontend/behaviors/dropdown.js
@@ -0,0 +1,36 @@
+import { registerBehavior } from "./index";
+
+class DropdownBehavior {
+  constructor(element) {
+    this.element = element;
+    this.opened = false;
+    this.onOutsideClick = this.onOutsideClick.bind(this);
+
+    const toggle = element.querySelector(".dropdown-toggle");
+    toggle.addEventListener("click", () => {
+      if (this.opened) {
+        this.close();
+      } else {
+        this.open();
+      }
+    });
+  }
+
+  open() {
+    this.element.classList.add("active");
+    document.addEventListener("click", this.onOutsideClick);
+  }
+
+  close() {
+    this.element.classList.remove("active");
+    document.removeEventListener("click", this.onOutsideClick);
+  }
+
+  onOutsideClick(event) {
+    if (!this.element.contains(event.target)) {
+      this.close();
+    }
+  }
+}
+
+registerBehavior("ld-dropdown", DropdownBehavior);
--- a/bookmarks/frontend/behaviors/form.js
+++ b/bookmarks/frontend/behaviors/form.js
@@ -0,0 +1,54 @@
+import { registerBehavior, swap } from "./index";
+
+class FormBehavior {
+  constructor(element) {
+    this.element = element;
+    element.addEventListener("submit", this.onFormSubmit.bind(this));
+  }
+
+  async onFormSubmit(event) {
+    event.preventDefault();
+
+    const url = this.element.action;
+    const formData = new FormData(this.element);
+    if (event.submitter) {
+      formData.append(event.submitter.name, event.submitter.value);
+    }
+
+    await fetch(url, {
+      method: "POST",
+      body: formData,
+      redirect: "manual", // ignore redirect
+    });
+
+    // Dispatch refresh events
+    const refreshEvents = this.element.getAttribute("refresh-events");
+    if (refreshEvents) {
+      refreshEvents.split(",").forEach((eventName) => {
+        document.dispatchEvent(new CustomEvent(eventName));
+      });
+    }
+
+    // Refresh form
+    await this.refresh();
+  }
+
+  async refresh() {
+    const refreshUrl = this.element.getAttribute("refresh-url");
+    const html = await fetch(refreshUrl).then((response) => response.text());
+    swap(this.element, html);
+  }
+}
+
+class FormAutoSubmitBehavior {
+  constructor(element) {
+    this.element = element;
+    this.element.addEventListener("change", () => {
+      const form = this.element.closest("form");
+      form.dispatchEvent(new Event("submit", { cancelable: true }));
+    });
+  }
+}
+
+registerBehavior("ld-form", FormBehavior);
+registerBehavior("ld-form-auto-submit", FormAutoSubmitBehavior);
--- a/bookmarks/frontend/behaviors/global-shortcuts.js
+++ b/bookmarks/frontend/behaviors/global-shortcuts.js
@@ -0,0 +1,73 @@
+import { registerBehavior } from "./index";
+
+class GlobalShortcuts {
+  constructor() {
+    document.addEventListener("keydown", this.onKeyDown.bind(this));
+  }
+
+  onKeyDown(event) {
+    // Skip if event occurred within an input element
+    const targetNodeName = event.target.nodeName;
+    const isInputTarget =
+      targetNodeName === "INPUT" ||
+      targetNodeName === "SELECT" ||
+      targetNodeName === "TEXTAREA";
+
+    if (isInputTarget) {
+      return;
+    }
+
+    // Handle shortcuts for navigating bookmarks with arrow keys
+    const isArrowUp = event.key === "ArrowUp";
+    const isArrowDown = event.key === "ArrowDown";
+    if (isArrowUp || isArrowDown) {
+      event.preventDefault();
+
+      // Detect current bookmark list item
+      const path = event.composedPath();
+      const currentItem = path.find(
+        (item) => item.hasAttribute && item.hasAttribute("ld-bookmark-item"),
+      );
+
+      // Find next item
+      let nextItem;
+      if (currentItem) {
+        nextItem = isArrowUp
+          ? currentItem.previousElementSibling
+          : currentItem.nextElementSibling;
+      } else {
+        // Select first item
+        nextItem = document.querySelector("[ld-bookmark-item]");
+      }
+      // Focus first link
+      if (nextItem) {
+        nextItem.querySelector("a").focus();
+      }
+    }
+
+    // Handle shortcut for toggling all notes
+    if (event.key === "e") {
+      const list = document.querySelector(".bookmark-list");
+      if (list) {
+        list.classList.toggle("show-notes");
+      }
+    }
+
+    // Handle shortcut for focusing search input
+    if (event.key === "s") {
+      const searchInput = document.querySelector('input[type="search"]');
+
+      if (searchInput) {
+        searchInput.focus();
+        event.preventDefault();
+      }
+    }
+
+    // Handle shortcut for adding new bookmark
+    if (event.key === "n") {
+      window.location.assign("/bookmarks/new");
+    }
+  }
+}
+
+registerBehavior("ld-global-shortcuts", GlobalShortcuts);
--- a/bookmarks/frontend/behaviors/index.js
+++ b/bookmarks/frontend/behaviors/index.js
@@ -0,0 +1,50 @@
+const behaviorRegistry = {};
+
+export function registerBehavior(name, behavior) {
+  behaviorRegistry[name] = behavior;
+  applyBehaviors(document, [name]);
+}
+
+export function applyBehaviors(container, behaviorNames = null) {
+  if (!behaviorNames) {
+    behaviorNames = Object.keys(behaviorRegistry);
+  }
+
+  behaviorNames.forEach((behaviorName) => {
+    const behavior = behaviorRegistry[behaviorName];
+    const elements = Array.from(
+      container.querySelectorAll(`[${behaviorName}]`),
+    );
+
+    // Include the container element if it has the behavior
+    if (container.hasAttribute && container.hasAttribute(behaviorName)) {
+      elements.push(container);
+    }
+
+    elements.forEach((element) => {
+      element.__behaviors = element.__behaviors || [];
+      const hasBehavior = element.__behaviors.some(
+        (b) => b instanceof behavior,
+      );
+
+      if (hasBehavior) {
+        return;
+      }
+
+      const behaviorInstance = new behavior(element);
+      element.__behaviors.push(behaviorInstance);
+    });
+  });
+}
+
+export function swap(element, html) {
+  const dom = new DOMParser().parseFromString(html, "text/html");
+  const newElement = dom.body.firstChild;
+  element.replaceWith(newElement);
+  applyBehaviors(newElement);
+}
+
+export function swapContent(element, html) {
+  element.innerHTML = html;
+  applyBehaviors(element);
+}
--- a/bookmarks/frontend/behaviors/modal.js
+++ b/bookmarks/frontend/behaviors/modal.js
@@ -0,0 +1,100 @@
+import { applyBehaviors, registerBehavior } from "./index";
+
+class ModalBehavior {
+  constructor(element) {
+    const toggle = element;
+    toggle.addEventListener("click", this.onToggleClick.bind(this));
+    this.toggle = toggle;
+  }
+
+  async onToggleClick(event) {
+    // Ignore Ctrl + click
+    if (event.ctrlKey || event.metaKey) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+
+    // Create modal either by teleporting existing content or fetching from URL
+    const modal = this.toggle.hasAttribute("modal-content")
+      ? this.createFromContent()
+      : await this.createFromUrl();
+
+    if (!modal) {
+      return;
+    }
+
+    // Register close handlers
+    const modalOverlay = modal.querySelector(".modal-overlay");
+    const closeButton = modal.querySelector("button.close");
+    modalOverlay.addEventListener("click", this.onClose.bind(this));
+    closeButton.addEventListener("click", this.onClose.bind(this));
+
+    document.body.append(modal);
+    applyBehaviors(document.body);
+    this.modal = modal;
+  }
+
+  async createFromUrl() {
+    const url = this.toggle.getAttribute("modal-url");
+    const modalHtml = await fetch(url).then((response) => response.text());
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(modalHtml, "text/html");
+    return doc.querySelector(".modal");
+  }
+
+  createFromContent() {
+    const contentSelector = this.toggle.getAttribute("modal-content");
+    const content = document.querySelector(contentSelector);
+    if (!content) {
+      return;
+    }
+
+    // Todo: make title configurable, only used for tag cloud for now
+    const modal = document.createElement("div");
+    modal.classList.add("modal", "active");
+    modal.innerHTML = `
+      <div class="modal-overlay" aria-label="Close"></div>
+      <div class="modal-container">
+        <div class="modal-header d-flex justify-between align-center">
+          <div class="modal-title h5">Tags</div>
+          <button class="close">
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
+            <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+            <path d="M18 6l-12 12"></path>
+            <path d="M6 6l12 12"></path>
+          </svg>
+          </button>
+        </div>
+        <div class="modal-body">
+          <div class="content"></div>
+        </div>
+      </div>
+    `;
+
+    const contentOwner = content.parentElement;
+    const contentContainer = modal.querySelector(".content");
+    contentContainer.append(content);
+    this.content = content;
+    this.contentOwner = contentOwner;
+
+    return modal;
+  }
+
+  onClose() {
+    // Teleport content back
+    if (this.content && this.contentOwner) {
+      this.contentOwner.append(this.content);
+    }
+
+    // Remove modal
+    this.modal.classList.add("closing");
+    this.modal.addEventListener("animationend", (event) => {
+      if (event.animationName === "fade-out") {
+        this.modal.remove();
+      }
+    });
+  }
+}
+
+registerBehavior("ld-modal", ModalBehavior);
--- a/bookmarks/frontend/behaviors/tag-autocomplete.js
+++ b/bookmarks/frontend/behaviors/tag-autocomplete.js
@@ -0,0 +1,27 @@
+import { registerBehavior } from "./index";
+import TagAutoCompleteComponent from "../components/TagAutocomplete.svelte";
+import { ApiClient } from "../api";
+
+class TagAutocomplete {
+  constructor(element) {
+    const wrapper = document.createElement("div");
+    const apiBaseUrl = document.documentElement.dataset.apiBaseUrl || "";
+    const apiClient = new ApiClient(apiBaseUrl);
+
+    new TagAutoCompleteComponent({
+      target: wrapper,
+      props: {
+        id: element.id,
+        name: element.name,
+        value: element.value,
+        placeholder: element.getAttribute("placeholder") || "",
+        apiClient: apiClient,
+        variant: element.getAttribute("variant"),
+      },
+    });
+
+    element.replaceWith(wrapper.firstElementChild);
+  }
+}
+
+registerBehavior("ld-tag-autocomplete", TagAutocomplete);
--- a/bookmarks/frontend/components/SearchAutoComplete.svelte
+++ b/bookmarks/frontend/components/SearchAutoComplete.svelte
@@ -0,0 +1,261 @@
+<script>
+  import {SearchHistory} from "./SearchHistory";
+  import {clampText, debounce, getCurrentWord, getCurrentWordBounds} from "../util";
+
+  const searchHistory = new SearchHistory()
+
+  export let name;
+  export let placeholder;
+  export let value;
+  export let tags;
+  export let mode = '';
+  export let apiClient;
+  export let search;
+  export let linkTarget = '_blank';
+
+  let isFocus = false;
+  let isOpen = false;
+  let suggestions = []
+  let selectedIndex = undefined;
+  let input = null;
+
+  // Track current search query after loading the page
+  searchHistory.pushCurrent()
+  updateSuggestions()
+
+  function handleFocus() {
+    isFocus = true;
+  }
+
+  function handleBlur() {
+    isFocus = false;
+    close();
+  }
+
+  function handleInput(e) {
+    value = e.target.value
+    debouncedLoadSuggestions()
+  }
+
+  function handleKeyDown(e) {
+    // Enter
+    if (isOpen && selectedIndex !== undefined && (e.keyCode === 13 || e.keyCode === 9)) {
+      const suggestion = suggestions.total[selectedIndex];
+      if (suggestion) completeSuggestion(suggestion);
+      e.preventDefault();
+    }
+    // Escape
+    if (e.keyCode === 27) {
+      close();
+      e.preventDefault();
+    }
+    // Up arrow
+    if (e.keyCode === 38) {
+      updateSelection(-1);
+      e.preventDefault();
+    }
+    // Down arrow
+    if (e.keyCode === 40) {
+      if (!isOpen) {
+        loadSuggestions()
+      } else {
+        updateSelection(1);
+      }
+      e.preventDefault();
+    }
+  }
+
+  function open() {
+    isOpen = true;
+  }
+
+  function close() {
+    isOpen = false;
+    updateSuggestions()
+    selectedIndex = undefined
+  }
+
+  function hasSuggestions() {
+    return suggestions.total.length > 0
+  }
+
+  async function loadSuggestions() {
+
+    let suggestionIndex = 0
+
+    function nextIndex() {
+      return suggestionIndex++
+    }
+
+    // Tag suggestions
+    let tagSuggestions = []
+    const currentWord = getCurrentWord(input)
+    if (currentWord && currentWord.length > 1 && currentWord[0] === '#') {
+      const searchTag = currentWord.substring(1, currentWord.length)
+      tagSuggestions = (tags || []).filter(tagName => tagName.toLowerCase().indexOf(searchTag.toLowerCase()) === 0)
+        .slice(0, 5)
+        .map(tagName => ({
+          type: 'tag',
+          index: nextIndex(),
+          label: `#${tagName}`,
+          tagName: tagName
+        }))
+    }
+
+    // Recent search suggestions
+    const recentSearches = searchHistory.getRecentSearches(value, 5).map(value => ({
+      type: 'search',
+      index: nextIndex(),
+      label: value,
+      value
+    }))
+
+    // Bookmark suggestions
+    let bookmarks = []
+
+    if (value && value.length >= 3) {
+      const path = mode ? `/${mode}` : ''
+      const suggestionSearch = {
+        ...search,
+        q: value
+      }
+      const fetchedBookmarks = await apiClient.listBookmarks(suggestionSearch, {limit: 5, offset: 0, path})
+      bookmarks = fetchedBookmarks.map(bookmark => {
+        const fullLabel = bookmark.title || bookmark.website_title || bookmark.url
+        const label = clampText(fullLabel, 60)
+        return {
+          type: 'bookmark',
+          index: nextIndex(),
+          label,
+          bookmark
+        }
+      })
+    }
+
+    updateSuggestions(recentSearches, bookmarks, tagSuggestions)
+
+    if (hasSuggestions()) {
+      open()
+    } else {
+      close()
+    }
+  }
+
+  const debouncedLoadSuggestions = debounce(loadSuggestions)
+
+  function updateSuggestions(recentSearches, bookmarks, tagSuggestions) {
+    recentSearches = recentSearches || []
+    bookmarks = bookmarks || []
+    tagSuggestions = tagSuggestions || []
+    suggestions = {
+      recentSearches,
+      bookmarks,
+      tags: tagSuggestions,
+      total: [
+        ...tagSuggestions,
+        ...recentSearches,
+        ...bookmarks,
+      ]
+    }
+  }
+
+  function completeSuggestion(suggestion) {
+    if (suggestion.type === 'search') {
+      value = suggestion.value
+      close()
+    }
+    if (suggestion.type === 'bookmark') {
+      window.open(suggestion.bookmark.url, linkTarget)
+      close()
+    }
+    if (suggestion.type === 'tag') {
+      const bounds = getCurrentWordBounds(input);
+      const inputValue = input.value;
+      input.value = inputValue.substring(0, bounds.start) + `#${suggestion.tagName} ` + inputValue.substring(bounds.end);
+      close()
+    }
+  }
+
+  function updateSelection(dir) {
+
+    const length = suggestions.total.length;
+
+    if (length === 0) return
+
+    if (selectedIndex === undefined) {
+      selectedIndex = dir > 0 ? 0 : Math.max(length - 1, 0)
+      return
+    }
+
+    let newIndex = selectedIndex + dir;
+
+    if (newIndex < 0) newIndex = Math.max(length - 1, 0);
+    if (newIndex >= length) newIndex = 0;
+
+    selectedIndex = newIndex;
+  }
+</script>
+
+<div class="form-autocomplete">
+  <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
+    <input type="search" class="form-input" name="{name}" placeholder="{placeholder}" autocomplete="off" value="{value}"
+           bind:this={input}
+           on:input={handleInput} on:keydown={handleKeyDown} on:focus={handleFocus} on:blur={handleBlur}>
+  </div>
+
+  <ul class="menu" class:open={isOpen}>
+    {#if suggestions.tags.length > 0}
+      <li class="menu-item group-item">Tags</li>
+    {/if}
+    {#each suggestions.tags as suggestion}
+      <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
+        <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
+          {suggestion.label}
+        </a>
+      </li>
+    {/each}
+
+    {#if suggestions.recentSearches.length > 0}
+      <li class="menu-item group-item">Recent Searches</li>
+    {/if}
+    {#each suggestions.recentSearches as suggestion}
+      <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
+        <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
+          {suggestion.label}
+        </a>
+      </li>
+    {/each}
+
+    {#if suggestions.bookmarks.length > 0}
+      <li class="menu-item group-item">Bookmarks</li>
+    {/if}
+    {#each suggestions.bookmarks as suggestion}
+      <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
+        <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
+          {suggestion.label}
+        </a>
+      </li>
+    {/each}
+  </ul>
+</div>
+
+<style>
+    .menu {
+        display: none;
+        max-height: 400px;
+        overflow: auto;
+    }
+
+    .menu.open {
+        display: block;
+    }
+
+    .form-autocomplete-input {
+        padding: 0;
+    }
+
+    .form-autocomplete-input.is-focused {
+        z-index: 2;
+    }
+
+</style>
--- a/bookmarks/frontend/components/SearchHistory.js
+++ b/bookmarks/frontend/components/SearchHistory.js
@@ -0,0 +1,52 @@
+const SEARCH_HISTORY_KEY = "searchHistory";
+const MAX_ENTRIES = 30;
+
+export class SearchHistory {
+  getHistory() {
+    const historyJson = localStorage.getItem(SEARCH_HISTORY_KEY);
+    return historyJson
+      ? JSON.parse(historyJson)
+      : {
+          recent: [],
+        };
+  }
+
+  pushCurrent() {
+    // Skip if browser is not compatible
+    if (!window.URLSearchParams) return;
+    const urlParams = new URLSearchParams(window.location.search);
+    const searchParam = urlParams.get("q");
+
+    if (!searchParam) return;
+
+    this.push(searchParam);
+  }
+
+  push(search) {
+    const history = this.getHistory();
+
+    history.recent.unshift(search);
+
+    // Remove duplicates and clamp to max entries
+    history.recent = history.recent.reduce((acc, cur) => {
+      if (acc.length >= MAX_ENTRIES) return acc;
+      if (acc.indexOf(cur) >= 0) return acc;
+      acc.push(cur);
+      return acc;
+    }, []);
+
+    const newHistoryJson = JSON.stringify(history);
+    localStorage.setItem(SEARCH_HISTORY_KEY, newHistoryJson);
+  }
+
+  getRecentSearches(query, max) {
+    const history = this.getHistory();
+
+    return history.recent
+      .filter(
+        (search) =>
+          !query || search.toLowerCase().indexOf(query.toLowerCase()) >= 0,
+      )
+      .slice(0, max);
+  }
+}
--- a/bookmarks/frontend/components/TagAutocomplete.svelte
+++ b/bookmarks/frontend/components/TagAutocomplete.svelte
@@ -0,0 +1,170 @@
+<script>
+  import {getCurrentWord, getCurrentWordBounds} from "../util";
+
+  export let id;
+  export let name;
+  export let value;
+  export let placeholder;
+  export let apiClient;
+  export let variant = 'default';
+
+  let tags = [];
+  let isFocus = false;
+  let isOpen = false;
+  let input = null;
+  let suggestionList = null;
+
+  let suggestions = [];
+  let selectedIndex = 0;
+
+  init();
+
+  async function init() {
+    // For now we cache all tags on load as the template did before
+    try {
+      tags = await apiClient.getTags({limit: 5000, offset: 0});
+      tags.sort((left, right) => left.name.toLowerCase().localeCompare(right.name.toLowerCase()))
+    } catch (e) {
+      console.warn('TagAutocomplete: Error loading tag list');
+    }
+  }
+
+  function handleFocus() {
+    isFocus = true;
+  }
+
+  function handleBlur() {
+    isFocus = false;
+    close();
+  }
+
+  function handleInput(e) {
+    input = e.target;
+
+    const word = getCurrentWord(input);
+
+    suggestions = word
+      ? tags.filter(tag => tag.name.toLowerCase().indexOf(word.toLowerCase()) === 0)
+      : [];
+
+    if (word && suggestions.length > 0) {
+      open();
+    } else {
+      close();
+    }
+  }
+
+  function handleKeyDown(e) {
+    if (isOpen && (e.keyCode === 13 || e.keyCode === 9)) {
+      const suggestion = suggestions[selectedIndex];
+      complete(suggestion);
+      e.preventDefault();
+    }
+    if (e.keyCode === 27) {
+      close();
+      e.preventDefault();
+    }
+    if (e.keyCode === 38) {
+      updateSelection(-1);
+      e.preventDefault();
+    }
+    if (e.keyCode === 40) {
+      updateSelection(1);
+      e.preventDefault();
+    }
+  }
+
+  function open() {
+    isOpen = true;
+    selectedIndex = 0;
+  }
+
+  function close() {
+    isOpen = false;
+    suggestions = [];
+    selectedIndex = 0;
+  }
+
+  function complete(suggestion) {
+    const bounds = getCurrentWordBounds(input);
+    const value = input.value;
+    input.value = value.substring(0, bounds.start) + suggestion.name + ' ' + value.substring(bounds.end);
+
+    close();
+  }
+
+  function updateSelection(dir) {
+
+    const length = suggestions.length;
+    let newIndex = selectedIndex + dir;
+
+    if (newIndex < 0) newIndex = Math.max(length - 1, 0);
+    if (newIndex >= length) newIndex = 0;
+
+    selectedIndex = newIndex;
+
+    // Scroll to selected list item
+    setTimeout(() => {
+      if (suggestionList) {
+        const selectedListItem = suggestionList.querySelector('li.selected');
+        if (selectedListItem) {
+          selectedListItem.scrollIntoView({block: 'center'});
+        }
+      }
+    }, 0);
+  }
+</script>
+
+<div class="form-autocomplete" class:small={variant === 'small'}>
+  <!-- autocomplete input container -->
+  <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
+    <!-- autocomplete real input box -->
+    <input id="{id}" name="{name}" value="{value ||''}" placeholder="{placeholder || ' '}"
+           class="form-input" type="text" autocomplete="off" autocapitalize="off"
+           on:input={handleInput} on:keydown={handleKeyDown}
+           on:focus={handleFocus} on:blur={handleBlur}>
+  </div>
+
+  <!-- autocomplete suggestion list -->
+  <ul class="menu" class:open={isOpen && suggestions.length > 0}
+      bind:this={suggestionList}>
+    <!-- menu list items -->
+    {#each suggestions as tag,i}
+      <li class="menu-item" class:selected={selectedIndex === i}>
+        <a href="#" on:mousedown|preventDefault={() => complete(tag)}>
+          {tag.name}
+        </a>
+      </li>
+    {/each}
+  </ul>
+</div>
+
+<style>
+    .menu {
+        display: none;
+        max-height: 200px;
+        overflow: auto;
+    }
+
+    .menu.open {
+        display: block;
+    }
+
+    .form-autocomplete.small .form-autocomplete-input {
+        height: var(--control-size-sm);
+        min-height: var(--control-size-sm);
+        padding: 0.05rem 0.3rem;
+    }
+
+    .form-autocomplete.small .form-autocomplete-input input {
+        width: 100%;
+        height: 100%;
+        margin: 0;
+        padding: 0;
+        font-size: var(--font-size-sm);
+    }
+
+    .form-autocomplete.small .menu .menu-item {
+        font-size: var(--font-size-sm);
+    }
+</style>
--- a/bookmarks/frontend/index.js
+++ b/bookmarks/frontend/index.js
@@ -0,0 +1,11 @@
+import "./behaviors/bookmark-page";
+import "./behaviors/bulk-edit";
+import "./behaviors/confirm-button";
+import "./behaviors/dropdown";
+import "./behaviors/form";
+import "./behaviors/modal";
+import "./behaviors/global-shortcuts";
+import "./behaviors/tag-autocomplete";
+export { default as TagAutoComplete } from "./components/TagAutocomplete.svelte";
+export { default as SearchAutoComplete } from "./components/SearchAutoComplete.svelte";
+export { ApiClient } from "./api";
--- a/bookmarks/frontend/util.js
+++ b/bookmarks/frontend/util.js
@@ -0,0 +1,37 @@
+export function debounce(callback, delay = 250) {
+  let timeoutId;
+  return (...args) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      callback(...args);
+    }, delay);
+  };
+}
+
+export function clampText(text, maxChars = 30) {
+  if (!text || text.length <= 30) return text;
+
+  return text.substr(0, maxChars) + "...";
+}
+
+export function getCurrentWordBounds(input) {
+  const text = input.value;
+  const end = input.selectionStart;
+  let start = end;
+
+  let currentChar = text.charAt(start - 1);
+
+  while (currentChar && currentChar !== " " && start > 0) {
+    start--;
+    currentChar = text.charAt(start - 1);
+  }
+
+  return { start, end };
+}
+
+export function getCurrentWord(input) {
+  const bounds = getCurrentWordBounds(input);
+
+  return input.value.substring(bounds.start, bounds.end);
+}
--- a/bookmarks/management/commands/backup.py
+++ b/bookmarks/management/commands/backup.py
@@ -0,0 +1,26 @@
+import sqlite3
+import os
+
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    help = "Creates a backup of the linkding database"
+
+    def add_arguments(self, parser):
+        parser.add_argument("destination", type=str, help="Backup file destination")
+
+    def handle(self, *args, **options):
+        destination = options["destination"]
+
+        def progress(status, remaining, total):
+            self.stdout.write(f"Copied {total-remaining} of {total} pages...")
+
+        source_db = sqlite3.connect(os.path.join("data", "db.sqlite3"))
+        backup_db = sqlite3.connect(destination)
+        with backup_db:
+            source_db.backup(backup_db, pages=50, progress=progress)
+        backup_db.close()
+        source_db.close()
+
+        self.stdout.write(self.style.SUCCESS(f"Backup created at {destination}"))
--- a/bookmarks/management/commands/clean_tasks.py
+++ b/bookmarks/management/commands/clean_tasks.py
@@ -1,15 +0,0 @@
-from background_task.models import Task, CompletedTask
-from django.core.management.base import BaseCommand
-
-
-class Command(BaseCommand):
-    help = "Remove task locks and clear completed task history"
-
-    def handle(self, *args, **options):
-        # Remove task locks
-        # If the background task processor exited while executing tasks, these tasks would still be marked as locked,
-        # even though no process is working on them, and would prevent the task processor from picking the next task in
-        # the queue
-        Task.objects.all().update(locked_by=None, locked_at=None)
-        # Clear task history to prevent them from bloating the DB
-        CompletedTask.objects.all().delete()
--- a/bookmarks/management/commands/create_initial_superuser.py
+++ b/bookmarks/management/commands/create_initial_superuser.py
@@ -12,18 +12,20 @@ class Command(BaseCommand):

    def handle(self, *args, **options):
        User = get_user_model()
-        superuser_name = os.getenv('LD_SUPERUSER_NAME', None)
-        superuser_password = os.getenv('LD_SUPERUSER_PASSWORD', None)
+        superuser_name = os.getenv("LD_SUPERUSER_NAME", None)
+        superuser_password = os.getenv("LD_SUPERUSER_PASSWORD", None)

        # Skip if option is undefined
        if not superuser_name:
-            logger.info('Skip creating initial superuser, LD_SUPERUSER_NAME option is not defined')
+            logger.info(
+                "Skip creating initial superuser, LD_SUPERUSER_NAME option is not defined"
+            )
            return

        # Skip if user already exists
        user_exists = User.objects.filter(username=superuser_name).exists()
        if user_exists:
-            logger.info('Skip creating initial superuser, user already exists')
+            logger.info("Skip creating initial superuser, user already exists")
            return

        user = User(username=superuser_name, is_superuser=True, is_staff=True)
@@ -34,4 +36,4 @@ class Command(BaseCommand):
            user.set_unusable_password()

        user.save()
-        logger.info('Created initial superuser')
+        logger.info("Created initial superuser")
--- a/bookmarks/management/commands/enable_wal.py
+++ b/bookmarks/management/commands/enable_wal.py
@@ -0,0 +1,24 @@
+import logging
+
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.db import connections
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Enable WAL journal mode when using an SQLite database"
+
+    def handle(self, *args, **options):
+        if not settings.USE_SQLITE:
+            return
+
+        connection = connections["default"]
+        with connection.cursor() as cursor:
+            cursor.execute("PRAGMA journal_mode")
+            current_mode = cursor.fetchone()[0]
+            logger.info(f"Current journal mode: {current_mode}")
+            if current_mode != "wal":
+                cursor.execute("PRAGMA journal_mode=wal;")
+                logger.info("Switched to WAL journal mode")
--- a/bookmarks/management/commands/ensure_superuser.py
+++ b/bookmarks/management/commands/ensure_superuser.py
@@ -6,13 +6,15 @@ class Command(BaseCommand):
    help = "Creates an admin user non-interactively if it doesn't exist"

    def add_arguments(self, parser):
-        parser.add_argument('--username', help="Admin's username")
-        parser.add_argument('--email', help="Admin's email")
-        parser.add_argument('--password', help="Admin's password")
+        parser.add_argument("--username", help="Admin's username")
+        parser.add_argument("--email", help="Admin's email")
+        parser.add_argument("--password", help="Admin's password")

    def handle(self, *args, **options):
        User = get_user_model()
-        if not User.objects.filter(username=options['username']).exists():
-            User.objects.create_superuser(username=options['username'],
-                                          email=options['email'],
-                                          password=options['password'])
+        if not User.objects.filter(username=options["username"]).exists():
+            User.objects.create_superuser(
+                username=options["username"],
+                email=options["email"],
+                password=options["password"],
+            )
--- a/bookmarks/management/commands/generate_secret_key.py
+++ b/bookmarks/management/commands/generate_secret_key.py
@@ -0,0 +1,24 @@
+import logging
+import os
+
+from django.core.management.base import BaseCommand
+from django.core.management.utils import get_random_secret_key
+
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Generate secret key file if it does not exist"
+
+    def handle(self, *args, **options):
+        secret_key_file = os.path.join("data", "secretkey.txt")
+
+        if os.path.exists(secret_key_file):
+            logger.info(f"Secret key file already exists")
+            return
+
+        secret_key = get_random_secret_key()
+        with open(secret_key_file, "w") as f:
+            f.write(secret_key)
+        logger.info(f"Generated secret key file")
--- a/bookmarks/management/commands/import_netscape.py
+++ b/bookmarks/management/commands/import_netscape.py
@@ -5,15 +5,17 @@ from bookmarks.services.importer import import_netscape_html


 class Command(BaseCommand):
-    help = 'Import Netscape HTML bookmark file'
+    help = "Import Netscape HTML bookmark file"

    def add_arguments(self, parser):
-        parser.add_argument('file', type=str, help='Path to file')
-        parser.add_argument('user', type=str, help='Name of the user for which to import')
+        parser.add_argument("file", type=str, help="Path to file")
+        parser.add_argument(
+            "user", type=str, help="Name of the user for which to import"
+        )

    def handle(self, *args, **kwargs):
-        filepath = kwargs['file']
-        username = kwargs['user']
+        filepath = kwargs["file"]
+        username = kwargs["user"]
        with open(filepath) as html_file:
            html = html_file.read()
        user = User.objects.get(username=username)
--- a/bookmarks/management/commands/migrate_tasks.py
+++ b/bookmarks/management/commands/migrate_tasks.py
@@ -0,0 +1,75 @@
+import json
+import os
+import sqlite3
+import importlib
+
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    help = "Migrate tasks from django-background-tasks to Huey"
+
+    def handle(self, *args, **options):
+        db = sqlite3.connect(os.path.join("data", "db.sqlite3"))
+
+        # Check if background_task table exists
+        cursor = db.cursor()
+        cursor.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='background_task'"
+        )
+        row = cursor.fetchone()
+        if not row:
+            self.stdout.write(
+                "Legacy task table does not exist. Skipping task migration"
+            )
+            return
+
+        # Load legacy tasks
+        cursor.execute("SELECT id, task_name, task_params FROM background_task")
+        legacy_tasks = cursor.fetchall()
+
+        if len(legacy_tasks) == 0:
+            self.stdout.write("No legacy tasks found. Skipping task migration")
+            return
+
+        self.stdout.write(
+            f"Found {len(legacy_tasks)} legacy tasks. Migrating to Huey..."
+        )
+
+        # Migrate tasks to Huey
+        succeeded_tasks = []
+        for task in legacy_tasks:
+            task_id = task[0]
+            task_name = task[1]
+            task_params_json = task[2]
+            try:
+                task_params = json.loads(task_params_json)
+                function_params = task_params[0]
+
+                # Resolve task function
+                module_name, func_name = task_name.rsplit(".", 1)
+                module = importlib.import_module(module_name)
+                func = getattr(module, func_name)
+
+                # Call task function
+                func(*function_params)
+                succeeded_tasks.append(task_id)
+            except Exception:
+                self.stderr.write(f"Error migrating task [{task_id}] {task_name}")
+
+        self.stdout.write(f"Migrated {len(succeeded_tasks)} tasks successfully")
+
+        # Clean up
+        try:
+            placeholders = ", ".join("?" for _ in succeeded_tasks)
+            sql = f"DELETE FROM background_task WHERE id IN ({placeholders})"
+            cursor.execute(sql, succeeded_tasks)
+            db.commit()
+            self.stdout.write(
+                f"Deleted {len(succeeded_tasks)} migrated tasks from legacy table"
+            )
+        except Exception:
+            self.stderr.write("Error cleaning up legacy tasks")
+
+        cursor.close()
+        db.close()
--- a/bookmarks/middlewares.py
+++ b/bookmarks/middlewares.py
@@ -1,6 +1,24 @@
 from django.conf import settings
 from django.contrib.auth.middleware import RemoteUserMiddleware

+from bookmarks.models import UserProfile
+

 class CustomRemoteUserMiddleware(RemoteUserMiddleware):
    header = settings.LD_AUTH_PROXY_USERNAME_HEADER
+
+
+class UserProfileMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        if request.user.is_authenticated:
+            request.user_profile = request.user.profile
+        else:
+            request.user_profile = UserProfile()
+            request.user_profile.enable_favicons = True
+
+        response = self.get_response(request)
+
+        return response
--- a/bookmarks/migrations/0001_initial.py
+++ b/bookmarks/migrations/0001_initial.py
@@ -15,19 +15,36 @@ class Migration(migrations.Migration):

    operations = [
        migrations.CreateModel(
-            name='Bookmark',
+            name="Bookmark",
            fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('url', models.URLField()),
-                ('title', models.CharField(max_length=512)),
-                ('description', models.TextField()),
-                ('website_title', models.CharField(blank=True, max_length=512, null=True)),
-                ('website_description', models.TextField(blank=True, null=True)),
-                ('unread', models.BooleanField(default=True)),
-                ('date_added', models.DateTimeField()),
-                ('date_modified', models.DateTimeField()),
-                ('date_accessed', models.DateTimeField(blank=True, null=True)),
-                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("url", models.URLField()),
+                ("title", models.CharField(max_length=512)),
+                ("description", models.TextField()),
+                (
+                    "website_title",
+                    models.CharField(blank=True, max_length=512, null=True),
+                ),
+                ("website_description", models.TextField(blank=True, null=True)),
+                ("unread", models.BooleanField(default=True)),
+                ("date_added", models.DateTimeField()),
+                ("date_modified", models.DateTimeField()),
+                ("date_accessed", models.DateTimeField(blank=True, null=True)),
+                (
+                    "owner",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
            ],
        ),
    ]
--- a/bookmarks/migrations/0002_auto_20190629_2303.py
+++ b/bookmarks/migrations/0002_auto_20190629_2303.py
@@ -9,22 +9,36 @@ class Migration(migrations.Migration):

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-        ('bookmarks', '0001_initial'),
+        ("bookmarks", "0001_initial"),
    ]

    operations = [
        migrations.CreateModel(
-            name='Tag',
+            name="Tag",
            fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('name', models.CharField(max_length=64)),
-                ('date_added', models.DateTimeField()),
-                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("name", models.CharField(max_length=64)),
+                ("date_added", models.DateTimeField()),
+                (
+                    "owner",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
            ],
        ),
        migrations.AddField(
-            model_name='bookmark',
-            name='tags',
-            field=models.ManyToManyField(to='bookmarks.Tag'),
+            model_name="bookmark",
+            name="tags",
+            field=models.ManyToManyField(to="bookmarks.Tag"),
        ),
    ]
--- a/bookmarks/migrations/0003_auto_20200913_0656.py
+++ b/bookmarks/migrations/0003_auto_20200913_0656.py
@@ -6,13 +6,13 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0002_auto_20190629_2303'),
+        ("bookmarks", "0002_auto_20190629_2303"),
    ]

    operations = [
        migrations.AlterField(
-            model_name='bookmark',
-            name='url',
+            model_name="bookmark",
+            name="url",
            field=models.URLField(max_length=2048),
        ),
    ]
--- a/bookmarks/migrations/0004_auto_20200926_1028.py
+++ b/bookmarks/migrations/0004_auto_20200926_1028.py
@@ -6,18 +6,18 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0003_auto_20200913_0656'),
+        ("bookmarks", "0003_auto_20200913_0656"),
    ]

    operations = [
        migrations.AlterField(
-            model_name='bookmark',
-            name='description',
+            model_name="bookmark",
+            name="description",
            field=models.TextField(blank=True),
        ),
        migrations.AlterField(
-            model_name='bookmark',
-            name='title',
+            model_name="bookmark",
+            name="title",
            field=models.CharField(blank=True, max_length=512),
        ),
    ]
--- a/bookmarks/migrations/0005_auto_20210103_1212.py
+++ b/bookmarks/migrations/0005_auto_20210103_1212.py
@@ -7,13 +7,16 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0004_auto_20200926_1028'),
+        ("bookmarks", "0004_auto_20200926_1028"),
    ]

    operations = [
        migrations.AlterField(
-            model_name='bookmark',
-            name='url',
-            field=models.CharField(max_length=2048, validators=[bookmarks.validators.BookmarkURLValidator()]),
+            model_name="bookmark",
+            name="url",
+            field=models.CharField(
+                max_length=2048,
+                validators=[bookmarks.validators.BookmarkURLValidator()],
+            ),
        ),
    ]
--- a/bookmarks/migrations/0006_bookmark_is_archived.py
+++ b/bookmarks/migrations/0006_bookmark_is_archived.py
@@ -6,13 +6,13 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0005_auto_20210103_1212'),
+        ("bookmarks", "0005_auto_20210103_1212"),
    ]

    operations = [
        migrations.AddField(
-            model_name='bookmark',
-            name='is_archived',
+            model_name="bookmark",
+            name="is_archived",
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0007_userprofile.py
+++ b/bookmarks/migrations/0007_userprofile.py
@@ -6,8 +6,8 @@ import django.db.models.deletion


 def forwards(apps, schema_editor):
-    User = apps.get_model('auth', 'User')
-    UserProfile = apps.get_model('bookmarks', 'UserProfile')
+    User = apps.get_model("auth", "User")
+    UserProfile = apps.get_model("bookmarks", "UserProfile")
    for user in User.objects.all():
        try:
            if user.profile:
@@ -24,19 +24,42 @@ def reverse(apps, schema_editor):
 class Migration(migrations.Migration):
    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-        ('bookmarks', '0006_bookmark_is_archived'),
+        ("bookmarks", "0006_bookmark_is_archived"),
    ]

    operations = [
        migrations.CreateModel(
-            name='UserProfile',
+            name="UserProfile",
            fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('theme',
-                 models.CharField(choices=[('auto', 'Auto'), ('light', 'Light'), ('dark', 'Dark')], default='auto',
-                                  max_length=10)),
-                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='profile',
-                                              to=settings.AUTH_USER_MODEL)),
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "theme",
+                    models.CharField(
+                        choices=[
+                            ("auto", "Auto"),
+                            ("light", "Light"),
+                            ("dark", "Dark"),
+                        ],
+                        default="auto",
+                        max_length=10,
+                    ),
+                ),
+                (
+                    "user",
+                    models.OneToOneField(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="profile",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
            ],
        ),
        migrations.RunPython(forwards, reverse),
--- a/bookmarks/migrations/0008_userprofile_bookmark_date_display.py
+++ b/bookmarks/migrations/0008_userprofile_bookmark_date_display.py
@@ -6,13 +6,21 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0007_userprofile'),
+        ("bookmarks", "0007_userprofile"),
    ]

    operations = [
        migrations.AddField(
-            model_name='userprofile',
-            name='bookmark_date_display',
-            field=models.CharField(choices=[('relative', 'Relative'), ('absolute', 'Absolute'), ('hidden', 'Hidden')], default='relative', max_length=10),
+            model_name="userprofile",
+            name="bookmark_date_display",
+            field=models.CharField(
+                choices=[
+                    ("relative", "Relative"),
+                    ("absolute", "Absolute"),
+                    ("hidden", "Hidden"),
+                ],
+                default="relative",
+                max_length=10,
+            ),
        ),
    ]
--- a/bookmarks/migrations/0009_bookmark_web_archive_snapshot_url.py
+++ b/bookmarks/migrations/0009_bookmark_web_archive_snapshot_url.py
@@ -6,13 +6,13 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0008_userprofile_bookmark_date_display'),
+        ("bookmarks", "0008_userprofile_bookmark_date_display"),
    ]

    operations = [
        migrations.AddField(
-            model_name='bookmark',
-            name='web_archive_snapshot_url',
+            model_name="bookmark",
+            name="web_archive_snapshot_url",
            field=models.CharField(blank=True, max_length=2048),
        ),
    ]
--- a/bookmarks/migrations/0010_userprofile_bookmark_link_target.py
+++ b/bookmarks/migrations/0010_userprofile_bookmark_link_target.py
@@ -6,13 +6,17 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0009_bookmark_web_archive_snapshot_url'),
+        ("bookmarks", "0009_bookmark_web_archive_snapshot_url"),
    ]

    operations = [
        migrations.AddField(
-            model_name='userprofile',
-            name='bookmark_link_target',
-            field=models.CharField(choices=[('_blank', 'New page'), ('_self', 'Same page')], default='_blank', max_length=10),
+            model_name="userprofile",
+            name="bookmark_link_target",
+            field=models.CharField(
+                choices=[("_blank", "New page"), ("_self", "Same page")],
+                default="_blank",
+                max_length=10,
+            ),
        ),
    ]
--- a/bookmarks/migrations/0011_userprofile_web_archive_integration.py
+++ b/bookmarks/migrations/0011_userprofile_web_archive_integration.py
@@ -6,13 +6,17 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0010_userprofile_bookmark_link_target'),
+        ("bookmarks", "0010_userprofile_bookmark_link_target"),
    ]

    operations = [
        migrations.AddField(
-            model_name='userprofile',
-            name='web_archive_integration',
-            field=models.CharField(choices=[('disabled', 'Disabled'), ('enabled', 'Enabled')], default='disabled', max_length=10),
+            model_name="userprofile",
+            name="web_archive_integration",
+            field=models.CharField(
+                choices=[("disabled", "Disabled"), ("enabled", "Enabled")],
+                default="disabled",
+                max_length=10,
+            ),
        ),
    ]
--- a/bookmarks/migrations/0012_toast.py
+++ b/bookmarks/migrations/0012_toast.py
@@ -9,18 +9,32 @@ class Migration(migrations.Migration):

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-        ('bookmarks', '0011_userprofile_web_archive_integration'),
+        ("bookmarks", "0011_userprofile_web_archive_integration"),
    ]

    operations = [
        migrations.CreateModel(
-            name='Toast',
+            name="Toast",
            fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('key', models.CharField(max_length=50)),
-                ('message', models.TextField()),
-                ('acknowledged', models.BooleanField(default=False)),
-                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("key", models.CharField(max_length=50)),
+                ("message", models.TextField()),
+                ("acknowledged", models.BooleanField(default=False)),
+                (
+                    "owner",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
            ],
        ),
    ]
--- a/bookmarks/migrations/0013_web_archive_optin_toast.py
+++ b/bookmarks/migrations/0013_web_archive_optin_toast.py
@@ -10,19 +10,21 @@ User = get_user_model()

 def forwards(apps, schema_editor):
    for user in User.objects.all():
-        toast = Toast(key='web_archive_opt_in_hint',
-                      message='The Internet Archive Wayback Machine integration has been disabled by default. Check the Settings to re-enable it.',
-                      owner=user)
+        toast = Toast(
+            key="web_archive_opt_in_hint",
+            message="The Internet Archive Wayback Machine integration has been disabled by default. Check the Settings to re-enable it.",
+            owner=user,
+        )
        toast.save()


 def reverse(apps, schema_editor):
-    Toast.objects.filter(key='web_archive_opt_in_hint').delete()
+    Toast.objects.filter(key="web_archive_opt_in_hint").delete()


 class Migration(migrations.Migration):
    dependencies = [
-        ('bookmarks', '0012_toast'),
+        ("bookmarks", "0012_toast"),
    ]

    operations = [
--- a/bookmarks/migrations/0014_alter_bookmark_unread.py
+++ b/bookmarks/migrations/0014_alter_bookmark_unread.py
@@ -4,7 +4,7 @@ from django.db import migrations, models


 def forwards(apps, schema_editor):
-    Bookmark = apps.get_model('bookmarks', 'Bookmark')
+    Bookmark = apps.get_model("bookmarks", "Bookmark")
    Bookmark.objects.update(unread=False)


@@ -14,13 +14,13 @@ def reverse(apps, schema_editor):

 class Migration(migrations.Migration):
    dependencies = [
-        ('bookmarks', '0013_web_archive_optin_toast'),
+        ("bookmarks", "0013_web_archive_optin_toast"),
    ]

    operations = [
        migrations.AlterField(
-            model_name='bookmark',
-            name='unread',
+            model_name="bookmark",
+            name="unread",
            field=models.BooleanField(default=False),
        ),
        migrations.RunPython(forwards, reverse),
--- a/bookmarks/migrations/0015_feedtoken.py
+++ b/bookmarks/migrations/0015_feedtoken.py
@@ -9,16 +9,26 @@ class Migration(migrations.Migration):

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-        ('bookmarks', '0014_alter_bookmark_unread'),
+        ("bookmarks", "0014_alter_bookmark_unread"),
    ]

    operations = [
        migrations.CreateModel(
-            name='FeedToken',
+            name="FeedToken",
            fields=[
-                ('key', models.CharField(max_length=40, primary_key=True, serialize=False)),
-                ('created', models.DateTimeField(auto_now_add=True)),
-                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='feed_token', to=settings.AUTH_USER_MODEL)),
+                (
+                    "key",
+                    models.CharField(max_length=40, primary_key=True, serialize=False),
+                ),
+                ("created", models.DateTimeField(auto_now_add=True)),
+                (
+                    "user",
+                    models.OneToOneField(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="feed_token",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
            ],
        ),
    ]
--- a/bookmarks/migrations/0016_bookmark_shared.py
+++ b/bookmarks/migrations/0016_bookmark_shared.py
@@ -6,13 +6,13 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0015_feedtoken'),
+        ("bookmarks", "0015_feedtoken"),
    ]

    operations = [
        migrations.AddField(
-            model_name='bookmark',
-            name='shared',
+            model_name="bookmark",
+            name="shared",
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0017_userprofile_enable_sharing.py
+++ b/bookmarks/migrations/0017_userprofile_enable_sharing.py
@@ -6,13 +6,13 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0016_bookmark_shared'),
+        ("bookmarks", "0016_bookmark_shared"),
    ]

    operations = [
        migrations.AddField(
-            model_name='userprofile',
-            name='enable_sharing',
+            model_name="userprofile",
+            name="enable_sharing",
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0018_bookmark_favicon_file.py
+++ b/bookmarks/migrations/0018_bookmark_favicon_file.py
@@ -6,13 +6,13 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0017_userprofile_enable_sharing'),
+        ("bookmarks", "0017_userprofile_enable_sharing"),
    ]

    operations = [
        migrations.AddField(
-            model_name='bookmark',
-            name='favicon_file',
+            model_name="bookmark",
+            name="favicon_file",
            field=models.CharField(blank=True, max_length=512),
        ),
    ]
--- a/bookmarks/migrations/0019_userprofile_enable_favicons.py
+++ b/bookmarks/migrations/0019_userprofile_enable_favicons.py
@@ -6,13 +6,13 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0018_bookmark_favicon_file'),
+        ("bookmarks", "0018_bookmark_favicon_file"),
    ]

    operations = [
        migrations.AddField(
-            model_name='userprofile',
-            name='enable_favicons',
+            model_name="userprofile",
+            name="enable_favicons",
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0020_userprofile_tag_search.py
+++ b/bookmarks/migrations/0020_userprofile_tag_search.py
@@ -6,13 +6,17 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0019_userprofile_enable_favicons'),
+        ("bookmarks", "0019_userprofile_enable_favicons"),
    ]

    operations = [
        migrations.AddField(
-            model_name='userprofile',
-            name='tag_search',
-            field=models.CharField(choices=[('strict', 'Strict'), ('lax', 'Lax')], default='strict', max_length=10),
+            model_name="userprofile",
+            name="tag_search",
+            field=models.CharField(
+                choices=[("strict", "Strict"), ("lax", "Lax")],
+                default="strict",
+                max_length=10,
+            ),
        ),
    ]
--- a/bookmarks/migrations/0021_userprofile_display_url.py
+++ b/bookmarks/migrations/0021_userprofile_display_url.py
@@ -6,13 +6,13 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0020_userprofile_tag_search'),
+        ("bookmarks", "0020_userprofile_tag_search"),
    ]

    operations = [
        migrations.AddField(
-            model_name='userprofile',
-            name='display_url',
+            model_name="userprofile",
+            name="display_url",
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0022_bookmark_notes.py
+++ b/bookmarks/migrations/0022_bookmark_notes.py
@@ -6,13 +6,13 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0021_userprofile_display_url'),
+        ("bookmarks", "0021_userprofile_display_url"),
    ]

    operations = [
        migrations.AddField(
-            model_name='bookmark',
-            name='notes',
+            model_name="bookmark",
+            name="notes",
            field=models.TextField(blank=True),
        ),
    ]
--- a/bookmarks/migrations/0023_userprofile_permanent_notes.py
+++ b/bookmarks/migrations/0023_userprofile_permanent_notes.py
@@ -6,13 +6,13 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ('bookmarks', '0022_bookmark_notes'),
+        ("bookmarks", "0022_bookmark_notes"),
    ]

    operations = [
        migrations.AddField(
-            model_name='userprofile',
-            name='permanent_notes',
+            model_name="userprofile",
+            name="permanent_notes",
            field=models.BooleanField(default=False),
        ),
    ]
--- a/bookmarks/migrations/0024_userprofile_enable_public_sharing.py
+++ b/bookmarks/migrations/0024_userprofile_enable_public_sharing.py
@@ -0,0 +1,18 @@
+# Generated by Django 4.1.9 on 2023-08-14 07:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0023_userprofile_permanent_notes"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="enable_public_sharing",
+            field=models.BooleanField(default=False),
+        ),
+    ]
--- a/bookmarks/migrations/0025_userprofile_search_preferences.py
+++ b/bookmarks/migrations/0025_userprofile_search_preferences.py
@@ -0,0 +1,18 @@
+# Generated by Django 4.1.9 on 2023-09-30 10:44
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0024_userprofile_enable_public_sharing"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="search_preferences",
+            field=models.JSONField(default=dict),
+        ),
+    ]
--- a/bookmarks/migrations/0026_userprofile_custom_css.py
+++ b/bookmarks/migrations/0026_userprofile_custom_css.py
@@ -0,0 +1,18 @@
+# Generated by Django 5.0.2 on 2024-03-16 23:05
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0025_userprofile_search_preferences"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="custom_css",
+            field=models.TextField(blank=True),
+        ),
+    ]
--- a/bookmarks/migrations/0027_userprofile_bookmark_description_display_and_more.py
+++ b/bookmarks/migrations/0027_userprofile_bookmark_description_display_and_more.py
@@ -0,0 +1,27 @@
+# Generated by Django 5.0.2 on 2024-03-23 21:48
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0026_userprofile_custom_css"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="bookmark_description_display",
+            field=models.CharField(
+                choices=[("inline", "Inline"), ("separate", "Separate")],
+                default="inline",
+                max_length=10,
+            ),
+        ),
+        migrations.AddField(
+            model_name="userprofile",
+            name="bookmark_description_max_lines",
+            field=models.IntegerField(default=1),
+        ),
+    ]
--- a/bookmarks/migrations/0028_userprofile_display_archive_bookmark_action_and_more.py
+++ b/bookmarks/migrations/0028_userprofile_display_archive_bookmark_action_and_more.py
@@ -0,0 +1,33 @@
+# Generated by Django 5.0.2 on 2024-03-29 20:05
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0027_userprofile_bookmark_description_display_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="display_archive_bookmark_action",
+            field=models.BooleanField(default=True),
+        ),
+        migrations.AddField(
+            model_name="userprofile",
+            name="display_edit_bookmark_action",
+            field=models.BooleanField(default=True),
+        ),
+        migrations.AddField(
+            model_name="userprofile",
+            name="display_remove_bookmark_action",
+            field=models.BooleanField(default=True),
+        ),
+        migrations.AddField(
+            model_name="userprofile",
+            name="display_view_bookmark_action",
+            field=models.BooleanField(default=True),
+        ),
+    ]
--- a/bookmarks/migrations/0029_bookmark_list_actions_toast.py
+++ b/bookmarks/migrations/0029_bookmark_list_actions_toast.py
@@ -0,0 +1,34 @@
+# Generated by Django 5.0.2 on 2024-03-29 21:25
+
+from django.db import migrations
+from django.contrib.auth import get_user_model
+
+from bookmarks.models import Toast
+
+User = get_user_model()
+
+
+def forwards(apps, schema_editor):
+
+    for user in User.objects.all():
+        toast = Toast(
+            key="bookmark_list_actions_hint",
+            message="This version adds a new link to each bookmark to view details in a dialog. If you feel there is too much clutter you can now hide individual links in the settings.",
+            owner=user,
+        )
+        toast.save()
+
+
+def reverse(apps, schema_editor):
+    Toast.objects.filter(key="bookmark_list_actions_hint").delete()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0028_userprofile_display_archive_bookmark_action_and_more"),
+    ]
+
+    operations = [
+        migrations.RunPython(forwards, reverse),
+    ]
--- a/bookmarks/migrations/0030_bookmarkasset.py
+++ b/bookmarks/migrations/0030_bookmarkasset.py
@@ -0,0 +1,43 @@
+# Generated by Django 5.0.2 on 2024-03-31 08:21
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0029_bookmark_list_actions_toast"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="BookmarkAsset",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("date_created", models.DateTimeField(auto_now_add=True)),
+                ("file", models.CharField(blank=True, max_length=2048)),
+                ("file_size", models.IntegerField(null=True)),
+                ("asset_type", models.CharField(max_length=64)),
+                ("content_type", models.CharField(max_length=128)),
+                ("display_name", models.CharField(blank=True, max_length=2048)),
+                ("status", models.CharField(max_length=64)),
+                ("gzip", models.BooleanField(default=False)),
+                (
+                    "bookmark",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="bookmarks.bookmark",
+                    ),
+                ),
+            ],
+        ),
+    ]
--- a/bookmarks/migrations/0031_userprofile_enable_automatic_html_snapshots.py
+++ b/bookmarks/migrations/0031_userprofile_enable_automatic_html_snapshots.py
@@ -0,0 +1,18 @@
+# Generated by Django 5.0.2 on 2024-04-01 10:29
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0030_bookmarkasset"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="enable_automatic_html_snapshots",
+            field=models.BooleanField(default=True),
+        ),
+    ]
--- a/bookmarks/migrations/0032_html_snapshots_hint_toast.py
+++ b/bookmarks/migrations/0032_html_snapshots_hint_toast.py
@@ -0,0 +1,34 @@
+# Generated by Django 5.0.2 on 2024-04-01 12:17
+
+from django.db import migrations
+from django.contrib.auth import get_user_model
+
+from bookmarks.models import Toast
+
+User = get_user_model()
+
+
+def forwards(apps, schema_editor):
+
+    for user in User.objects.all():
+        toast = Toast(
+            key="html_snapshots_hint",
+            message="This version adds a new feature for archiving snapshots of websites locally. To use it, you need to switch to a different Docker image. See the installation instructions on GitHub for details.",
+            owner=user,
+        )
+        toast.save()
+
+
+def reverse(apps, schema_editor):
+    Toast.objects.filter(key="bookmark_list_actions_hint").delete()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookmarks", "0031_userprofile_enable_automatic_html_snapshots"),
+    ]
+
+    operations = [
+        migrations.RunPython(forwards, reverse),
+    ]
--- a/bookmarks/models.py
+++ b/bookmarks/models.py
@@ -1,18 +1,22 @@
-import binascii
+import logging
 import os
 from typing import List

+import binascii
 from django import forms
+from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import User
-from django.core.handlers.wsgi import WSGIRequest
 from django.db import models
-from django.db.models.signals import post_save
+from django.db.models.signals import post_save, post_delete
 from django.dispatch import receiver
+from django.http import QueryDict

 from bookmarks.utils import unique
 from bookmarks.validators import BookmarkURLValidator

+logger = logging.getLogger(__name__)
+

 class Tag(models.Model):
    name = models.CharField(max_length=64)
@@ -26,10 +30,10 @@ class Tag(models.Model):
 def sanitize_tag_name(tag_name: str):
    # strip leading/trailing spaces
    # replace inner spaces with replacement char
-    return tag_name.strip().replace(' ', '-')
+    return tag_name.strip().replace(" ", "-")


-def parse_tag_string(tag_string: str, delimiter: str = ','):
+def parse_tag_string(tag_string: str, delimiter: str = ","):
    if not tag_string:
        return []
    names = tag_string.strip().split(delimiter)
@@ -42,7 +46,7 @@ def parse_tag_string(tag_string: str, delimiter: str = ','):
    return names


-def build_tag_string(tag_names: List[str], delimiter: str = ','):
+def build_tag_string(tag_names: List[str], delimiter: str = ","):
    return delimiter.join(tag_names)


@@ -82,7 +86,48 @@ class Bookmark(models.Model):
        return [tag.name for tag in self.tags.all()]

    def __str__(self):
-        return self.resolved_title + ' (' + self.url[:30] + '...)'
+        return self.resolved_title + " (" + self.url[:30] + "...)"
+
+
+class BookmarkAsset(models.Model):
+    TYPE_SNAPSHOT = "snapshot"
+
+    CONTENT_TYPE_HTML = "text/html"
+
+    STATUS_PENDING = "pending"
+    STATUS_COMPLETE = "complete"
+    STATUS_FAILURE = "failure"
+
+    bookmark = models.ForeignKey(Bookmark, on_delete=models.CASCADE)
+    date_created = models.DateTimeField(auto_now_add=True, null=False)
+    file = models.CharField(max_length=2048, blank=True, null=False)
+    file_size = models.IntegerField(null=True)
+    asset_type = models.CharField(max_length=64, blank=False, null=False)
+    content_type = models.CharField(max_length=128, blank=False, null=False)
+    display_name = models.CharField(max_length=2048, blank=True, null=False)
+    status = models.CharField(max_length=64, blank=False, null=False)
+    gzip = models.BooleanField(default=False, null=False)
+
+    def save(self, *args, **kwargs):
+        if self.file:
+            try:
+                file_path = os.path.join(settings.LD_ASSET_FOLDER, self.file)
+                if os.path.isfile(file_path):
+                    self.file_size = os.path.getsize(file_path)
+            except Exception:
+                pass
+        super().save(*args, **kwargs)
+
+
+@receiver(post_delete, sender=BookmarkAsset)
+def bookmark_asset_deleted(sender, instance, **kwargs):
+    if instance.file:
+        filepath = os.path.join(settings.LD_ASSET_FOLDER, instance.file)
+        if os.path.isfile(filepath):
+            try:
+                os.remove(filepath)
+            except Exception as error:
+                logger.error(f"Failed to delete asset file: {filepath}", exc_info=error)


 class BookmarkForm(forms.ModelForm):
@@ -90,15 +135,13 @@ class BookmarkForm(forms.ModelForm):
    url = forms.CharField(validators=[BookmarkURLValidator()])
    tag_string = forms.CharField(required=False)
    # Do not require title and description in form as we fill these automatically if they are empty
-    title = forms.CharField(max_length=512,
-                            required=False)
-    description = forms.CharField(required=False,
-                                  widget=forms.Textarea())
+    title = forms.CharField(max_length=512, required=False)
+    description = forms.CharField(required=False, widget=forms.Textarea())
    # Include website title and description as hidden field as they only provide info when editing bookmarks
-    website_title = forms.CharField(max_length=512,
-                                    required=False, widget=forms.HiddenInput())
-    website_description = forms.CharField(required=False,
-                                          widget=forms.HiddenInput())
+    website_title = forms.CharField(
+        max_length=512, required=False, widget=forms.HiddenInput()
+    )
+    website_description = forms.CharField(required=False, widget=forms.HiddenInput())
    unread = forms.BooleanField(required=False)
    shared = forms.BooleanField(required=False)
    # Hidden field that determines whether to close window/tab after saving the bookmark
@@ -107,16 +150,16 @@ class BookmarkForm(forms.ModelForm):
    class Meta:
        model = Bookmark
        fields = [
-            'url',
-            'tag_string',
-            'title',
-            'description',
-            'notes',
-            'website_title',
-            'website_description',
-            'unread',
-            'shared',
-            'auto_close',
+            "url",
+            "tag_string",
+            "title",
+            "description",
+            "notes",
+            "website_title",
+            "website_description",
+            "unread",
+            "shared",
+            "auto_close",
        ]

    @property
@@ -124,68 +167,263 @@ class BookmarkForm(forms.ModelForm):
        return self.instance and self.instance.notes


-class BookmarkFilters:
-    def __init__(self, request: WSGIRequest):
-        self.query = request.GET.get('q') or ''
-        self.user = request.GET.get('user') or ''
+class BookmarkSearch:
+    SORT_ADDED_ASC = "added_asc"
+    SORT_ADDED_DESC = "added_desc"
+    SORT_TITLE_ASC = "title_asc"
+    SORT_TITLE_DESC = "title_desc"
+
+    FILTER_SHARED_OFF = "off"
+    FILTER_SHARED_SHARED = "yes"
+    FILTER_SHARED_UNSHARED = "no"
+
+    FILTER_UNREAD_OFF = "off"
+    FILTER_UNREAD_YES = "yes"
+    FILTER_UNREAD_NO = "no"
+
+    params = ["q", "user", "sort", "shared", "unread"]
+    preferences = ["sort", "shared", "unread"]
+    defaults = {
+        "q": "",
+        "user": "",
+        "sort": SORT_ADDED_DESC,
+        "shared": FILTER_SHARED_OFF,
+        "unread": FILTER_UNREAD_OFF,
+    }
+
+    def __init__(
+        self,
+        q: str = None,
+        user: str = None,
+        sort: str = None,
+        shared: str = None,
+        unread: str = None,
+        preferences: dict = None,
+    ):
+        if not preferences:
+            preferences = {}
+        self.defaults = {**BookmarkSearch.defaults, **preferences}
+
+        self.q = q or self.defaults["q"]
+        self.user = user or self.defaults["user"]
+        self.sort = sort or self.defaults["sort"]
+        self.shared = shared or self.defaults["shared"]
+        self.unread = unread or self.defaults["unread"]
+
+    def is_modified(self, param):
+        value = self.__dict__[param]
+        return value != self.defaults[param]
+
+    @property
+    def modified_params(self):
+        return [field for field in self.params if self.is_modified(field)]
+
+    @property
+    def modified_preferences(self):
+        return [
+            preference
+            for preference in self.preferences
+            if self.is_modified(preference)
+        ]
+
+    @property
+    def has_modifications(self):
+        return len(self.modified_params) > 0
+
+    @property
+    def has_modified_preferences(self):
+        return len(self.modified_preferences) > 0
+
+    @property
+    def query_params(self):
+        return {param: self.__dict__[param] for param in self.modified_params}
+
+    @property
+    def preferences_dict(self):
+        return {
+            preference: self.__dict__[preference] for preference in self.preferences
+        }
+
+    @staticmethod
+    def from_request(query_dict: QueryDict, preferences: dict = None):
+        initial_values = {}
+        for param in BookmarkSearch.params:
+            value = query_dict.get(param)
+            if value:
+                initial_values[param] = value
+
+        return BookmarkSearch(**initial_values, preferences=preferences)
+
+
+class BookmarkSearchForm(forms.Form):
+    SORT_CHOICES = [
+        (BookmarkSearch.SORT_ADDED_ASC, "Added ↑"),
+        (BookmarkSearch.SORT_ADDED_DESC, "Added ↓"),
+        (BookmarkSearch.SORT_TITLE_ASC, "Title ↑"),
+        (BookmarkSearch.SORT_TITLE_DESC, "Title ↓"),
+    ]
+    FILTER_SHARED_CHOICES = [
+        (BookmarkSearch.FILTER_SHARED_OFF, "Off"),
+        (BookmarkSearch.FILTER_SHARED_SHARED, "Shared"),
+        (BookmarkSearch.FILTER_SHARED_UNSHARED, "Unshared"),
+    ]
+    FILTER_UNREAD_CHOICES = [
+        (BookmarkSearch.FILTER_UNREAD_OFF, "Off"),
+        (BookmarkSearch.FILTER_UNREAD_YES, "Unread"),
+        (BookmarkSearch.FILTER_UNREAD_NO, "Read"),
+    ]
+
+    q = forms.CharField()
+    user = forms.ChoiceField()
+    sort = forms.ChoiceField(choices=SORT_CHOICES)
+    shared = forms.ChoiceField(choices=FILTER_SHARED_CHOICES, widget=forms.RadioSelect)
+    unread = forms.ChoiceField(choices=FILTER_UNREAD_CHOICES, widget=forms.RadioSelect)
+
+    def __init__(
+        self,
+        search: BookmarkSearch,
+        editable_fields: List[str] = None,
+        users: List[User] = None,
+    ):
+        super().__init__()
+        editable_fields = editable_fields or []
+        self.editable_fields = editable_fields
+
+        # set choices for user field if users are provided
+        if users:
+            user_choices = [(user.username, user.username) for user in users]
+            user_choices.insert(0, ("", "Everyone"))
+            self.fields["user"].choices = user_choices
+
+        for param in search.params:
+            # set initial values for modified params
+            self.fields[param].initial = search.__dict__[param]
+
+            # Mark non-editable modified fields as hidden. That way, templates
+            # rendering a form can just loop over hidden_fields to ensure that
+            # all necessary search options are kept when submitting the form.
+            if search.is_modified(param) and param not in editable_fields:
+                self.fields[param].widget = forms.HiddenInput()


 class UserProfile(models.Model):
-    THEME_AUTO = 'auto'
-    THEME_LIGHT = 'light'
-    THEME_DARK = 'dark'
+    THEME_AUTO = "auto"
+    THEME_LIGHT = "light"
+    THEME_DARK = "dark"
    THEME_CHOICES = [
-        (THEME_AUTO, 'Auto'),
-        (THEME_LIGHT, 'Light'),
-        (THEME_DARK, 'Dark'),
+        (THEME_AUTO, "Auto"),
+        (THEME_LIGHT, "Light"),
+        (THEME_DARK, "Dark"),
    ]
-    BOOKMARK_DATE_DISPLAY_RELATIVE = 'relative'
-    BOOKMARK_DATE_DISPLAY_ABSOLUTE = 'absolute'
-    BOOKMARK_DATE_DISPLAY_HIDDEN = 'hidden'
+    BOOKMARK_DATE_DISPLAY_RELATIVE = "relative"
+    BOOKMARK_DATE_DISPLAY_ABSOLUTE = "absolute"
+    BOOKMARK_DATE_DISPLAY_HIDDEN = "hidden"
    BOOKMARK_DATE_DISPLAY_CHOICES = [
-        (BOOKMARK_DATE_DISPLAY_RELATIVE, 'Relative'),
-        (BOOKMARK_DATE_DISPLAY_ABSOLUTE, 'Absolute'),
-        (BOOKMARK_DATE_DISPLAY_HIDDEN, 'Hidden'),
+        (BOOKMARK_DATE_DISPLAY_RELATIVE, "Relative"),
+        (BOOKMARK_DATE_DISPLAY_ABSOLUTE, "Absolute"),
+        (BOOKMARK_DATE_DISPLAY_HIDDEN, "Hidden"),
    ]
-    BOOKMARK_LINK_TARGET_BLANK = '_blank'
-    BOOKMARK_LINK_TARGET_SELF = '_self'
+    BOOKMARK_DESCRIPTION_DISPLAY_INLINE = "inline"
+    BOOKMARK_DESCRIPTION_DISPLAY_SEPARATE = "separate"
+    BOOKMARK_DESCRIPTION_DISPLAY_CHOICES = [
+        (BOOKMARK_DESCRIPTION_DISPLAY_INLINE, "Inline"),
+        (BOOKMARK_DESCRIPTION_DISPLAY_SEPARATE, "Separate"),
+    ]
+    BOOKMARK_LINK_TARGET_BLANK = "_blank"
+    BOOKMARK_LINK_TARGET_SELF = "_self"
    BOOKMARK_LINK_TARGET_CHOICES = [
-        (BOOKMARK_LINK_TARGET_BLANK, 'New page'),
-        (BOOKMARK_LINK_TARGET_SELF, 'Same page'),
+        (BOOKMARK_LINK_TARGET_BLANK, "New page"),
+        (BOOKMARK_LINK_TARGET_SELF, "Same page"),
    ]
-    WEB_ARCHIVE_INTEGRATION_DISABLED = 'disabled'
-    WEB_ARCHIVE_INTEGRATION_ENABLED = 'enabled'
+    WEB_ARCHIVE_INTEGRATION_DISABLED = "disabled"
+    WEB_ARCHIVE_INTEGRATION_ENABLED = "enabled"
    WEB_ARCHIVE_INTEGRATION_CHOICES = [
-        (WEB_ARCHIVE_INTEGRATION_DISABLED, 'Disabled'),
-        (WEB_ARCHIVE_INTEGRATION_ENABLED, 'Enabled'),
+        (WEB_ARCHIVE_INTEGRATION_DISABLED, "Disabled"),
+        (WEB_ARCHIVE_INTEGRATION_ENABLED, "Enabled"),
    ]
-    TAG_SEARCH_STRICT = 'strict'
-    TAG_SEARCH_LAX = 'lax'
+    TAG_SEARCH_STRICT = "strict"
+    TAG_SEARCH_LAX = "lax"
    TAG_SEARCH_CHOICES = [
-        (TAG_SEARCH_STRICT, 'Strict'),
-        (TAG_SEARCH_LAX, 'Lax'),
+        (TAG_SEARCH_STRICT, "Strict"),
+        (TAG_SEARCH_LAX, "Lax"),
    ]
-    user = models.OneToOneField(get_user_model(), related_name='profile', on_delete=models.CASCADE)
-    theme = models.CharField(max_length=10, choices=THEME_CHOICES, blank=False, default=THEME_AUTO)
-    bookmark_date_display = models.CharField(max_length=10, choices=BOOKMARK_DATE_DISPLAY_CHOICES, blank=False,
-                                             default=BOOKMARK_DATE_DISPLAY_RELATIVE)
-    bookmark_link_target = models.CharField(max_length=10, choices=BOOKMARK_LINK_TARGET_CHOICES, blank=False,
-                                            default=BOOKMARK_LINK_TARGET_BLANK)
-    web_archive_integration = models.CharField(max_length=10, choices=WEB_ARCHIVE_INTEGRATION_CHOICES, blank=False,
-                                               default=WEB_ARCHIVE_INTEGRATION_DISABLED)
-    tag_search = models.CharField(max_length=10, choices=TAG_SEARCH_CHOICES, blank=False,
-                                  default=TAG_SEARCH_STRICT)
+    user = models.OneToOneField(
+        get_user_model(), related_name="profile", on_delete=models.CASCADE
+    )
+    theme = models.CharField(
+        max_length=10, choices=THEME_CHOICES, blank=False, default=THEME_AUTO
+    )
+    bookmark_date_display = models.CharField(
+        max_length=10,
+        choices=BOOKMARK_DATE_DISPLAY_CHOICES,
+        blank=False,
+        default=BOOKMARK_DATE_DISPLAY_RELATIVE,
+    )
+    bookmark_description_display = models.CharField(
+        max_length=10,
+        choices=BOOKMARK_DESCRIPTION_DISPLAY_CHOICES,
+        blank=False,
+        default=BOOKMARK_DESCRIPTION_DISPLAY_INLINE,
+    )
+    bookmark_description_max_lines = models.IntegerField(
+        null=False,
+        default=1,
+    )
+    bookmark_link_target = models.CharField(
+        max_length=10,
+        choices=BOOKMARK_LINK_TARGET_CHOICES,
+        blank=False,
+        default=BOOKMARK_LINK_TARGET_BLANK,
+    )
+    web_archive_integration = models.CharField(
+        max_length=10,
+        choices=WEB_ARCHIVE_INTEGRATION_CHOICES,
+        blank=False,
+        default=WEB_ARCHIVE_INTEGRATION_DISABLED,
+    )
+    tag_search = models.CharField(
+        max_length=10,
+        choices=TAG_SEARCH_CHOICES,
+        blank=False,
+        default=TAG_SEARCH_STRICT,
+    )
    enable_sharing = models.BooleanField(default=False, null=False)
+    enable_public_sharing = models.BooleanField(default=False, null=False)
    enable_favicons = models.BooleanField(default=False, null=False)
    display_url = models.BooleanField(default=False, null=False)
+    display_view_bookmark_action = models.BooleanField(default=True, null=False)
+    display_edit_bookmark_action = models.BooleanField(default=True, null=False)
+    display_archive_bookmark_action = models.BooleanField(default=True, null=False)
+    display_remove_bookmark_action = models.BooleanField(default=True, null=False)
    permanent_notes = models.BooleanField(default=False, null=False)
+    custom_css = models.TextField(blank=True, null=False)
+    search_preferences = models.JSONField(default=dict, null=False)
+    enable_automatic_html_snapshots = models.BooleanField(default=True, null=False)


 class UserProfileForm(forms.ModelForm):
    class Meta:
        model = UserProfile
-        fields = ['theme', 'bookmark_date_display', 'bookmark_link_target', 'web_archive_integration', 'tag_search',
-                  'enable_sharing', 'enable_favicons', 'display_url', 'permanent_notes']
+        fields = [
+            "theme",
+            "bookmark_date_display",
+            "bookmark_description_display",
+            "bookmark_description_max_lines",
+            "bookmark_link_target",
+            "web_archive_integration",
+            "tag_search",
+            "enable_sharing",
+            "enable_public_sharing",
+            "enable_favicons",
+            "enable_automatic_html_snapshots",
+            "display_url",
+            "display_view_bookmark_action",
+            "display_edit_bookmark_action",
+            "display_archive_bookmark_action",
+            "display_remove_bookmark_action",
+            "permanent_notes",
+            "custom_css",
+        ]


@receiver(post_save, sender=get_user_model())
@@ -210,11 +448,13 @@ class FeedToken(models.Model):
    """
    Adapted from authtoken.models.Token
    """
+
    key = models.CharField(max_length=40, primary_key=True)
-    user = models.OneToOneField(get_user_model(),
-                                related_name='feed_token',
-                                on_delete=models.CASCADE,
-                                )
+    user = models.OneToOneField(
+        get_user_model(),
+        related_name="feed_token",
+        on_delete=models.CASCADE,
+    )
    created = models.DateTimeField(auto_now_add=True)

    def save(self, *args, **kwargs):
--- a/bookmarks/queries.py
+++ b/bookmarks/queries.py
@@ -1,29 +1,43 @@
 from typing import Optional

+from django.conf import settings
 from django.contrib.auth.models import User
-from django.db.models import Q, QuerySet, Exists, OuterRef
+from django.db.models import Q, QuerySet, Exists, OuterRef, Case, When, CharField
+from django.db.models.expressions import RawSQL
+from django.db.models.functions import Lower

-from bookmarks.models import Bookmark, Tag, UserProfile
+from bookmarks.models import Bookmark, BookmarkSearch, Tag, UserProfile
 from bookmarks.utils import unique


-def query_bookmarks(user: User, profile: UserProfile, query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, profile, query_string) \
-        .filter(is_archived=False)
+def query_bookmarks(
+    user: User, profile: UserProfile, search: BookmarkSearch
+) -> QuerySet:
+    return _base_bookmarks_query(user, profile, search).filter(is_archived=False)


-def query_archived_bookmarks(user: User, profile: UserProfile, query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, profile, query_string) \
-        .filter(is_archived=True)
+def query_archived_bookmarks(
+    user: User, profile: UserProfile, search: BookmarkSearch
+) -> QuerySet:
+    return _base_bookmarks_query(user, profile, search).filter(is_archived=True)


-def query_shared_bookmarks(user: Optional[User], profile: UserProfile, query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, profile, query_string) \
-        .filter(shared=True) \
-        .filter(owner__profile__enable_sharing=True)
+def query_shared_bookmarks(
+    user: Optional[User],
+    profile: UserProfile,
+    search: BookmarkSearch,
+    public_only: bool,
+) -> QuerySet:
+    conditions = Q(shared=True) & Q(owner__profile__enable_sharing=True)
+    if public_only:
+        conditions = conditions & Q(owner__profile__enable_public_sharing=True)
+
+    return _base_bookmarks_query(user, profile, search).filter(conditions)


-def _base_bookmarks_query(user: Optional[User], profile: UserProfile, query_string: str) -> QuerySet:
+def _base_bookmarks_query(
+    user: Optional[User], profile: UserProfile, search: BookmarkSearch
+) -> QuerySet:
    query_set = Bookmark.objects

    # Filter for user
@@ -31,70 +45,126 @@ def _base_bookmarks_query(user: Optional[User], profile: UserProfile, query_stri
        query_set = query_set.filter(owner=user)

    # Split query into search terms and tags
-    query = parse_query_string(query_string)
+    query = parse_query_string(search.q)

    # Filter for search terms and tags
-    for term in query['search_terms']:
-        conditions = Q(title__icontains=term) \
-                     | Q(description__icontains=term) \
-                     | Q(notes__icontains=term) \
-                     | Q(website_title__icontains=term) \
-                     | Q(website_description__icontains=term) \
-                     | Q(url__icontains=term)
+    for term in query["search_terms"]:
+        conditions = (
+            Q(title__icontains=term)
+            | Q(description__icontains=term)
+            | Q(notes__icontains=term)
+            | Q(website_title__icontains=term)
+            | Q(website_description__icontains=term)
+            | Q(url__icontains=term)
+        )

        if profile.tag_search == UserProfile.TAG_SEARCH_LAX:
-            conditions = conditions | Exists(Bookmark.objects.filter(id=OuterRef('id'), tags__name__iexact=term))
+            conditions = conditions | Exists(
+                Bookmark.objects.filter(id=OuterRef("id"), tags__name__iexact=term)
+            )

        query_set = query_set.filter(conditions)

-    for tag_name in query['tag_names']:
-        query_set = query_set.filter(
-            tags__name__iexact=tag_name
-        )
+    for tag_name in query["tag_names"]:
+        query_set = query_set.filter(tags__name__iexact=tag_name)

    # Untagged bookmarks
-    if query['untagged']:
-        query_set = query_set.filter(
-            tags=None
-        )
-    # Unread bookmarks
-    if query['unread']:
-        query_set = query_set.filter(
-            unread=True
-        )
+    if query["untagged"]:
+        query_set = query_set.filter(tags=None)
+    # Legacy unread bookmarks filter from query
+    if query["unread"]:
+        query_set = query_set.filter(unread=True)
+
+    # Unread filter from bookmark search
+    if search.unread == BookmarkSearch.FILTER_UNREAD_YES:
+        query_set = query_set.filter(unread=True)
+    elif search.unread == BookmarkSearch.FILTER_UNREAD_NO:
+        query_set = query_set.filter(unread=False)
+
+    # Shared filter
+    if search.shared == BookmarkSearch.FILTER_SHARED_SHARED:
+        query_set = query_set.filter(shared=True)
+    elif search.shared == BookmarkSearch.FILTER_SHARED_UNSHARED:
+        query_set = query_set.filter(shared=False)

    # Sort by date added
-    query_set = query_set.order_by('-date_added')
+    if search.sort == BookmarkSearch.SORT_ADDED_ASC:
+        query_set = query_set.order_by("date_added")
+    elif search.sort == BookmarkSearch.SORT_ADDED_DESC:
+        query_set = query_set.order_by("-date_added")
+
+    # Sort by title
+    if (
+        search.sort == BookmarkSearch.SORT_TITLE_ASC
+        or search.sort == BookmarkSearch.SORT_TITLE_DESC
+    ):
+        # For the title, the resolved_title logic from the Bookmark entity needs
+        # to be replicated as there is no corresponding database field
+        query_set = query_set.annotate(
+            effective_title=Case(
+                When(Q(title__isnull=False) & ~Q(title__exact=""), then=Lower("title")),
+                When(
+                    Q(website_title__isnull=False) & ~Q(website_title__exact=""),
+                    then=Lower("website_title"),
+                ),
+                default=Lower("url"),
+                output_field=CharField(),
+            )
+        )
+
+        # For SQLite, if the ICU extension is loaded, use the custom collation
+        # loaded into the connection. This results in an improved sort order for
+        # unicode characters (umlauts, etc.)
+        if settings.USE_SQLITE and settings.USE_SQLITE_ICU_EXTENSION:
+            order_field = RawSQL("effective_title COLLATE ICU", ())
+        else:
+            order_field = "effective_title"
+
+        if search.sort == BookmarkSearch.SORT_TITLE_ASC:
+            query_set = query_set.order_by(order_field)
+        elif search.sort == BookmarkSearch.SORT_TITLE_DESC:
+            query_set = query_set.order_by(order_field).reverse()

    return query_set


-def query_bookmark_tags(user: User, profile: UserProfile, query_string: str) -> QuerySet:
-    bookmarks_query = query_bookmarks(user, profile, query_string)
+def query_bookmark_tags(
+    user: User, profile: UserProfile, search: BookmarkSearch
+) -> QuerySet:
+    bookmarks_query = query_bookmarks(user, profile, search)

    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)

    return query_set.distinct()


-def query_archived_bookmark_tags(user: User, profile: UserProfile, query_string: str) -> QuerySet:
-    bookmarks_query = query_archived_bookmarks(user, profile, query_string)
+def query_archived_bookmark_tags(
+    user: User, profile: UserProfile, search: BookmarkSearch
+) -> QuerySet:
+    bookmarks_query = query_archived_bookmarks(user, profile, search)

    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)

    return query_set.distinct()


-def query_shared_bookmark_tags(user: Optional[User], profile: UserProfile, query_string: str) -> QuerySet:
-    bookmarks_query = query_shared_bookmarks(user, profile, query_string)
+def query_shared_bookmark_tags(
+    user: Optional[User],
+    profile: UserProfile,
+    search: BookmarkSearch,
+    public_only: bool,
+) -> QuerySet:
+    bookmarks_query = query_shared_bookmarks(user, profile, search, public_only)

    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)

    return query_set.distinct()


-def query_shared_bookmark_users(profile: UserProfile, query_string: str) -> QuerySet:
-    bookmarks_query = query_shared_bookmarks(None, profile, query_string)
+def query_shared_bookmark_users(
+    profile: UserProfile, search: BookmarkSearch, public_only: bool
+) -> QuerySet:
+    bookmarks_query = query_shared_bookmarks(None, profile, search, public_only)

    query_set = User.objects.filter(bookmark__in=bookmarks_query)

@@ -108,23 +178,23 @@ def get_user_tags(user: User):
 def parse_query_string(query_string):
    # Sanitize query params
    if not query_string:
-        query_string = ''
+        query_string = ""

    # Split query into search terms and tags
-    keywords = query_string.strip().split(' ')
+    keywords = query_string.strip().split(" ")
    keywords = [word for word in keywords if word]

-    search_terms = [word for word in keywords if word[0] != '#' and word[0] != '!']
-    tag_names = [word[1:] for word in keywords if word[0] == '#']
+    search_terms = [word for word in keywords if word[0] != "#" and word[0] != "!"]
+    tag_names = [word[1:] for word in keywords if word[0] == "#"]
    tag_names = unique(tag_names, str.lower)

    # Special search commands
-    untagged = '!untagged' in keywords
-    unread = '!unread' in keywords
+    untagged = "!untagged" in keywords
+    unread = "!unread" in keywords

    return {
-        'search_terms': search_terms,
-        'tag_names': tag_names,
-        'untagged': untagged,
-        'unread': unread,
+        "search_terms": search_terms,
+        "tag_names": tag_names,
+        "untagged": untagged,
+        "unread": unread,
    }
--- a/bookmarks/services/bookmarks.py
+++ b/bookmarks/services/bookmarks.py
@@ -11,7 +11,9 @@ from bookmarks.services import tasks

 def create_bookmark(bookmark: Bookmark, tag_string: str, current_user: User):
    # If URL is already bookmarked, then update it
-    existing_bookmark: Bookmark = Bookmark.objects.filter(owner=current_user, url=bookmark.url).first()
+    existing_bookmark: Bookmark = Bookmark.objects.filter(
+        owner=current_user, url=bookmark.url
+    ).first()

    if existing_bookmark is not None:
        _merge_bookmark_data(bookmark, existing_bookmark)
@@ -32,6 +34,9 @@ def create_bookmark(bookmark: Bookmark, tag_string: str, current_user: User):
    tasks.create_web_archive_snapshot(current_user, bookmark, False)
    # Load favicon
    tasks.load_favicon(current_user, bookmark)
+    # Create HTML snapshot
+    if current_user.profile.enable_automatic_html_snapshots:
+        tasks.create_html_snapshot(bookmark)

    return bookmark

@@ -67,9 +72,10 @@ def archive_bookmark(bookmark: Bookmark):

 def archive_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)

-    bookmarks.update(is_archived=True, date_modified=timezone.now())
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
+        is_archived=True, date_modified=timezone.now()
+    )


 def unarchive_bookmark(bookmark: Bookmark):
@@ -81,42 +87,93 @@ def unarchive_bookmark(bookmark: Bookmark):

 def unarchive_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)

-    bookmarks.update(is_archived=False, date_modified=timezone.now())
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
+        is_archived=False, date_modified=timezone.now()
+    )


 def delete_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)

-    bookmarks.delete()
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).delete()


 def tag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
+    owned_bookmark_ids = Bookmark.objects.filter(
+        owner=current_user, id__in=sanitized_bookmark_ids
+    ).values_list("id", flat=True)
    tag_names = parse_tag_string(tag_string)
    tags = get_or_create_tags(tag_names, current_user)

-    for bookmark in bookmarks:
-        bookmark.tags.add(*tags)
-        bookmark.date_modified = timezone.now()
+    BookmarkToTagRelationShip = Bookmark.tags.through
+    relationships = []
+    for tag in tags:
+        for bookmark_id in owned_bookmark_ids:
+            relationships.append(
+                BookmarkToTagRelationShip(bookmark_id=bookmark_id, tag=tag)
+            )

-    Bookmark.objects.bulk_update(bookmarks, ['date_modified'])
+    # Insert all bookmark -> tag associations at once, should ignore errors if association already exists
+    BookmarkToTagRelationShip.objects.bulk_create(relationships, ignore_conflicts=True)
+    Bookmark.objects.filter(id__in=owned_bookmark_ids).update(
+        date_modified=timezone.now()
+    )


-def untag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user: User):
+def untag_bookmarks(
+    bookmark_ids: [Union[int, str]], tag_string: str, current_user: User
+):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
+    owned_bookmark_ids = Bookmark.objects.filter(
+        owner=current_user, id__in=sanitized_bookmark_ids
+    ).values_list("id", flat=True)
    tag_names = parse_tag_string(tag_string)
    tags = get_or_create_tags(tag_names, current_user)

-    for bookmark in bookmarks:
-        bookmark.tags.remove(*tags)
-        bookmark.date_modified = timezone.now()
+    BookmarkToTagRelationShip = Bookmark.tags.through
+    for tag in tags:
+        # Remove all bookmark -> tag associations for the owned bookmarks and the current tag
+        BookmarkToTagRelationShip.objects.filter(
+            bookmark_id__in=owned_bookmark_ids, tag=tag
+        ).delete()

-    Bookmark.objects.bulk_update(bookmarks, ['date_modified'])
+    Bookmark.objects.filter(id__in=owned_bookmark_ids).update(
+        date_modified=timezone.now()
+    )
+
+
+def mark_bookmarks_as_read(bookmark_ids: [Union[int, str]], current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
+        unread=False, date_modified=timezone.now()
+    )
+
+
+def mark_bookmarks_as_unread(bookmark_ids: [Union[int, str]], current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
+        unread=True, date_modified=timezone.now()
+    )
+
+
+def share_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
+        shared=True, date_modified=timezone.now()
+    )
+
+
+def unshare_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+
+    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
+        shared=False, date_modified=timezone.now()
+    )


 def _merge_bookmark_data(from_bookmark: Bookmark, to_bookmark: Bookmark):
--- a/bookmarks/services/exporter.py
+++ b/bookmarks/services/exporter.py
@@ -13,33 +13,41 @@ def export_netscape_html(bookmarks: List[Bookmark]):
    [append_bookmark(doc, bookmark) for bookmark in bookmarks]
    append_list_end(doc)

-    return '\n\r'.join(doc)
+    return "\n\r".join(doc)


 def append_header(doc: BookmarkDocument):
-    doc.append('<!DOCTYPE NETSCAPE-Bookmark-file-1>')
+    doc.append("<!DOCTYPE NETSCAPE-Bookmark-file-1>")
    doc.append('<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">')
-    doc.append('<TITLE>Bookmarks</TITLE>')
-    doc.append('<H1>Bookmarks</H1>')
+    doc.append("<TITLE>Bookmarks</TITLE>")
+    doc.append("<H1>Bookmarks</H1>")


 def append_list_start(doc: BookmarkDocument):
-    doc.append('<DL><p>')
+    doc.append("<DL><p>")


 def append_bookmark(doc: BookmarkDocument, bookmark: Bookmark):
    url = bookmark.url
-    title = html.escape(bookmark.resolved_title or '')
-    desc = html.escape(bookmark.resolved_description or '')
-    tags = ','.join(bookmark.tag_names)
-    toread = '1' if bookmark.unread else '0'
+    title = html.escape(bookmark.resolved_title or "")
+    desc = html.escape(bookmark.resolved_description or "")
+    if bookmark.notes:
+        desc += f"[linkding-notes]{html.escape(bookmark.notes)}[/linkding-notes]"
+    tag_names = bookmark.tag_names
+    if bookmark.is_archived:
+        tag_names.append("linkding:archived")
+    tags = ",".join(tag_names)
+    toread = "1" if bookmark.unread else "0"
+    private = "0" if bookmark.shared else "1"
    added = int(bookmark.date_added.timestamp())

-    doc.append(f'<DT><A HREF="{url}" ADD_DATE="{added}" PRIVATE="0" TOREAD="{toread}" TAGS="{tags}">{title}</A>')
+    doc.append(
+        f'<DT><A HREF="{url}" ADD_DATE="{added}" PRIVATE="{private}" TOREAD="{toread}" TAGS="{tags}">{title}</A>'
+    )

    if desc:
-        doc.append(f'<DD>{desc}')
+        doc.append(f"<DD>{desc}")


 def append_list_end(doc: BookmarkDocument):
-    doc.append('</DL><p>')
+    doc.append("</DL><p>")
--- a/bookmarks/services/favicon_loader.py
+++ b/bookmarks/services/favicon_loader.py
@@ -1,6 +1,7 @@
+import logging
+import mimetypes
 import os.path
 import re
-import shutil
 import time
 from pathlib import Path
 from urllib.parse import urlparse
@@ -10,25 +11,46 @@ from django.conf import settings

 max_file_age = 60 * 60 * 24  # 1 day

+logger = logging.getLogger(__name__)
+
+# register mime type for .ico files, which is not included in the default
+# mimetypes of the Docker image
+mimetypes.add_type("image/x-icon", ".ico")
+

 def _ensure_favicon_folder():
    Path(settings.LD_FAVICON_FOLDER).mkdir(parents=True, exist_ok=True)


 def _url_to_filename(url: str) -> str:
-    name = re.sub(r'\W+', '_', url)
-    return f'{name}.png'
+    return re.sub(r"\W+", "_", url)


-def _get_base_url(url: str) -> str:
+def _get_url_parameters(url: str) -> dict:
    parsed_uri = urlparse(url)
-    return f'{parsed_uri.scheme}://{parsed_uri.hostname}'
+    return {
+        # https://example.com/foo?bar -> https://example.com
+        "url": f"{parsed_uri.scheme}://{parsed_uri.hostname}",
+        # https://example.com/foo?bar -> example.com
+        "domain": parsed_uri.hostname,
+    }


 def _get_favicon_path(favicon_file: str) -> Path:
    return Path(os.path.join(settings.LD_FAVICON_FOLDER, favicon_file))


+def _check_existing_favicon(favicon_name: str):
+    # return existing file if a file with the same name, ignoring extension,
+    # exists and is not stale
+    for filename in os.listdir(settings.LD_FAVICON_FOLDER):
+        file_base_name, _ = os.path.splitext(filename)
+        if file_base_name == favicon_name:
+            favicon_path = _get_favicon_path(filename)
+            return filename if not _is_stale(favicon_path) else None
+    return None
+
+
 def _is_stale(path: Path) -> bool:
    stat = path.stat()
    file_age = time.time() - stat.st_mtime
@@ -36,22 +58,26 @@ def _is_stale(path: Path) -> bool:


 def load_favicon(url: str) -> str:
-    # Get base URL so that we can reuse favicons for multiple bookmarks with the same host
-    base_url = _get_base_url(url)
-    favicon_name = _url_to_filename(base_url)
-    favicon_path = _get_favicon_path(favicon_name)
+    url_parameters = _get_url_parameters(url)

-    # Load icon if it doesn't exist yet or has become stale
-    if not favicon_path.exists() or _is_stale(favicon_path):
-        # Create favicon folder if not exists
-        _ensure_favicon_folder()
+    # Create favicon folder if not exists
+    _ensure_favicon_folder()
+    # Use scheme+hostname as favicon filename to reuse icon for all pages on the same domain
+    favicon_name = _url_to_filename(url_parameters["url"])
+    favicon_file = _check_existing_favicon(favicon_name)
+
+    if not favicon_file:
        # Load favicon from provider, save to file
-        favicon_url = settings.LD_FAVICON_PROVIDER.format(url=base_url)
-        response = requests.get(favicon_url, stream=True)
+        favicon_url = settings.LD_FAVICON_PROVIDER.format(**url_parameters)
+        logger.debug(f"Loading favicon from: {favicon_url}")
+        with requests.get(favicon_url, stream=True) as response:
+            content_type = response.headers["Content-Type"]
+            file_extension = mimetypes.guess_extension(content_type)
+            favicon_file = f"{favicon_name}{file_extension}"
+            favicon_path = _get_favicon_path(favicon_file)
+            with open(favicon_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    file.write(chunk)
+        logger.debug(f"Saved favicon as: {favicon_path}")

-        with open(favicon_path, 'wb') as file:
-            shutil.copyfileobj(response.raw, file)
-
-        del response
-
-    return favicon_name
+    return favicon_file
--- a/bookmarks/services/importer.py
+++ b/bookmarks/services/importer.py
@@ -5,7 +5,7 @@ from typing import List
 from django.contrib.auth.models import User
 from django.utils import timezone

-from bookmarks.models import Bookmark, Tag, parse_tag_string
+from bookmarks.models import Bookmark, Tag
 from bookmarks.services import tasks
 from bookmarks.services.parser import parse, NetscapeBookmark
 from bookmarks.utils import parse_timestamp
@@ -20,6 +20,11 @@ class ImportResult:
    failed: int = 0


+@dataclass
+class ImportOptions:
+    map_private_flag: bool = False
+
+
 class TagCache:
    def __init__(self, user: User):
        self.user = user
@@ -50,18 +55,20 @@ class TagCache:
        self.cache[tag.name.lower()] = tag


-def import_netscape_html(html: str, user: User):
+def import_netscape_html(
+    html: str, user: User, options: ImportOptions = ImportOptions()
+) -> ImportResult:
    result = ImportResult()
    import_start = timezone.now()

    try:
        netscape_bookmarks = parse(html)
    except:
-        logging.exception('Could not read bookmarks file.')
+        logging.exception("Could not read bookmarks file.")
        raise

    parse_end = timezone.now()
-    logger.debug(f'Parse duration: {parse_end - import_start}')
+    logger.debug(f"Parse duration: {parse_end - import_start}")

    # Create and cache all tags beforehand
    _create_missing_tags(netscape_bookmarks, user)
@@ -70,7 +77,7 @@ def import_netscape_html(html: str, user: User):
    # Split bookmarks to import into batches, to keep memory usage for bulk operations manageable
    batches = _get_batches(netscape_bookmarks, 200)
    for batch in batches:
-        _import_batch(batch, user, tag_cache, result)
+        _import_batch(batch, user, options, tag_cache, result)

    # Create snapshots for newly imported bookmarks
    tasks.schedule_bookmarks_without_snapshots(user)
@@ -78,7 +85,7 @@ def import_netscape_html(html: str, user: User):
    tasks.schedule_bookmarks_without_favicons(user)

    end = timezone.now()
-    logger.debug(f'Import duration: {end - import_start}')
+    logger.debug(f"Import duration: {end - import_start}")

    return result

@@ -88,8 +95,7 @@ def _create_missing_tags(netscape_bookmarks: List[NetscapeBookmark], user: User)
    tags_to_create = []

    for netscape_bookmark in netscape_bookmarks:
-        tag_names = parse_tag_string(netscape_bookmark.tag_string)
-        for tag_name in tag_names:
+        for tag_name in netscape_bookmark.tag_names:
            tag = tag_cache.get(tag_name)
            if not tag:
                tag = Tag(name=tag_name, owner=user)
@@ -106,7 +112,7 @@ def _get_batches(items: List, batch_size: int):
    num_items = len(items)

    while offset < num_items:
-        batch = items[offset:min(offset + batch_size, num_items)]
+        batch = items[offset : min(offset + batch_size, num_items)]
        if len(batch) > 0:
            batches.append(batch)
        offset = offset + batch_size
@@ -114,7 +120,13 @@ def _get_batches(items: List, batch_size: int):
    return batches


-def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_cache: TagCache, result: ImportResult):
+def _import_batch(
+    netscape_bookmarks: List[NetscapeBookmark],
+    user: User,
+    options: ImportOptions,
+    tag_cache: TagCache,
+    result: ImportResult,
+):
    # Query existing bookmarks
    batch_urls = [bookmark.href for bookmark in netscape_bookmarks]
    existing_bookmarks = Bookmark.objects.filter(owner=user, url__in=batch_urls)
@@ -128,17 +140,23 @@ def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_ca
        try:
            # Lookup existing bookmark by URL, or create new bookmark if there is no bookmark for that URL yet
            bookmark = next(
-                (bookmark for bookmark in existing_bookmarks if bookmark.url == netscape_bookmark.href), None)
+                (
+                    bookmark
+                    for bookmark in existing_bookmarks
+                    if bookmark.url == netscape_bookmark.href
+                ),
+                None,
+            )
            if not bookmark:
                bookmark = Bookmark(owner=user)
                is_update = False
            else:
                is_update = True
            # Copy data from parsed bookmark
-            _copy_bookmark_data(netscape_bookmark, bookmark)
+            _copy_bookmark_data(netscape_bookmark, bookmark, options)
            # Validate bookmark fields, exclude owner to prevent n+1 database query,
            # also there is no specific validation on owner
-            bookmark.clean_fields(exclude=['owner'])
+            bookmark.clean_fields(exclude=["owner"])
            # Schedule for update or insert
            if is_update:
                bookmarks_to_update.append(bookmark)
@@ -147,13 +165,25 @@ def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_ca

            result.success = result.success + 1
        except:
-            shortened_bookmark_tag_str = str(netscape_bookmark)[:100] + '...'
-            logging.exception('Error importing bookmark: ' + shortened_bookmark_tag_str)
+            shortened_bookmark_tag_str = str(netscape_bookmark)[:100] + "..."
+            logging.exception("Error importing bookmark: " + shortened_bookmark_tag_str)
            result.failed = result.failed + 1

    # Bulk update bookmarks in DB
-    Bookmark.objects.bulk_update(bookmarks_to_update,
-                                 ['url', 'date_added', 'date_modified', 'unread', 'title', 'description', 'owner'])
+    Bookmark.objects.bulk_update(
+        bookmarks_to_update,
+        [
+            "url",
+            "date_added",
+            "date_modified",
+            "unread",
+            "shared",
+            "title",
+            "description",
+            "notes",
+            "owner",
+        ],
+    )
    # Bulk insert new bookmarks into DB
    Bookmark.objects.bulk_create(bookmarks_to_create)

@@ -168,18 +198,24 @@ def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_ca
    for netscape_bookmark in netscape_bookmarks:
        # Lookup bookmark by URL again
        bookmark = next(
-            (bookmark for bookmark in existing_bookmarks if bookmark.url == netscape_bookmark.href), None)
+            (
+                bookmark
+                for bookmark in existing_bookmarks
+                if bookmark.url == netscape_bookmark.href
+            ),
+            None,
+        )

        if not bookmark:
            # Something is wrong, we should have just created this bookmark
-            shortened_bookmark_tag_str = str(netscape_bookmark)[:100] + '...'
+            shortened_bookmark_tag_str = str(netscape_bookmark)[:100] + "..."
            logging.warning(
-                f'Failed to assign tags to the bookmark: {shortened_bookmark_tag_str}. Could not find bookmark by URL.')
+                f"Failed to assign tags to the bookmark: {shortened_bookmark_tag_str}. Could not find bookmark by URL."
+            )
            continue

        # Get tag models by string, schedule inserts for bookmark -> tag associations
-        tag_names = parse_tag_string(netscape_bookmark.tag_string)
-        tags = tag_cache.get_all(tag_names)
+        tags = tag_cache.get_all(netscape_bookmark.tag_names)
        for tag in tags:
            relationships.append(BookmarkToTagRelationShip(bookmark=bookmark, tag=tag))

@@ -187,7 +223,9 @@ def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_ca
    BookmarkToTagRelationShip.objects.bulk_create(relationships, ignore_conflicts=True)


-def _copy_bookmark_data(netscape_bookmark: NetscapeBookmark, bookmark: Bookmark):
+def _copy_bookmark_data(
+    netscape_bookmark: NetscapeBookmark, bookmark: Bookmark, options: ImportOptions
+):
    bookmark.url = netscape_bookmark.href
    if netscape_bookmark.date_added:
        bookmark.date_added = parse_timestamp(netscape_bookmark.date_added)
@@ -199,3 +237,9 @@ def _copy_bookmark_data(netscape_bookmark: NetscapeBookmark, bookmark: Bookmark)
        bookmark.title = netscape_bookmark.title
    if netscape_bookmark.description:
        bookmark.description = netscape_bookmark.description
+    if netscape_bookmark.notes:
+        bookmark.notes = netscape_bookmark.notes
+    if options.map_private_flag and not netscape_bookmark.private:
+        bookmark.shared = True
+    if netscape_bookmark.archived:
+        bookmark.is_archived = True
--- a/bookmarks/services/monolith.py
+++ b/bookmarks/services/monolith.py
@@ -0,0 +1,32 @@
+import gzip
+import shutil
+import subprocess
+import os
+
+from django.conf import settings
+
+
+class MonolithError(Exception):
+    pass
+
+
+# Monolith isn't used at the moment, as the local snapshot implementation
+# switched to single-file after the prototype. Keeping this around in case
+# it turns out to be useful in the future.
+def create_snapshot(url: str, filepath: str):
+    monolith_path = settings.LD_MONOLITH_PATH
+    monolith_options = settings.LD_MONOLITH_OPTIONS
+    temp_filepath = filepath + ".tmp"
+
+    try:
+        command = f"{monolith_path} '{url}' {monolith_options} -o {temp_filepath}"
+        subprocess.run(command, check=True, shell=True)
+
+        with open(temp_filepath, "rb") as raw_file, gzip.open(
+            filepath, "wb"
+        ) as gz_file:
+            shutil.copyfileobj(raw_file, gz_file)
+
+        os.remove(temp_filepath)
+    except subprocess.CalledProcessError as error:
+        raise MonolithError(f"Failed to create snapshot: {error.stderr}")
--- a/bookmarks/services/parser.py
+++ b/bookmarks/services/parser.py
@@ -2,15 +2,20 @@ from dataclasses import dataclass
 from html.parser import HTMLParser
 from typing import Dict, List

+from bookmarks.models import parse_tag_string
+

@dataclass
 class NetscapeBookmark:
    href: str
    title: str
    description: str
+    notes: str
    date_added: str
-    tag_string: str
+    tag_names: List[str]
    to_read: bool
+    private: bool
+    archived: bool


 class BookmarkParser(HTMLParser):
@@ -20,27 +25,29 @@ class BookmarkParser(HTMLParser):

        self.current_tag = None
        self.bookmark = None
-        self.href = ''
-        self.add_date = ''
-        self.tags = ''
-        self.title = ''
-        self.description = ''
-        self.toread = ''
+        self.href = ""
+        self.add_date = ""
+        self.tags = ""
+        self.title = ""
+        self.description = ""
+        self.notes = ""
+        self.toread = ""
+        self.private = ""

    def handle_starttag(self, tag: str, attrs: list):
-        name = 'handle_start_' + tag.lower()
+        name = "handle_start_" + tag.lower()
        if name in dir(self):
            getattr(self, name)({k.lower(): v for k, v in attrs})
        self.current_tag = tag

    def handle_endtag(self, tag: str):
-        name = 'handle_end_' + tag.lower()
+        name = "handle_end_" + tag.lower()
        if name in dir(self):
            getattr(self, name)()
        self.current_tag = None

    def handle_data(self, data):
-        name = f'handle_{self.current_tag}_data'
+        name = f"handle_{self.current_tag}_data"
        if name in dir(self):
            getattr(self, name)(data)

@@ -52,33 +59,50 @@ class BookmarkParser(HTMLParser):

    def handle_start_a(self, attrs: Dict[str, str]):
        vars(self).update(attrs)
+        tag_names = parse_tag_string(self.tags)
+        archived = "linkding:archived" in self.tags
+        try:
+            tag_names.remove("linkding:archived")
+        except ValueError:
+            pass
+
        self.bookmark = NetscapeBookmark(
            href=self.href,
-            title='',
-            description='',
+            title="",
+            description="",
+            notes="",
            date_added=self.add_date,
-            tag_string=self.tags,
-            to_read=self.toread == '1'
+            tag_names=tag_names,
+            to_read=self.toread == "1",
+            # Mark as private by default, also when attribute is not specified
+            private=self.private != "0",
+            archived=archived,
        )

    def handle_a_data(self, data):
        self.title = data.strip()

    def handle_dd_data(self, data):
-        self.description = data.strip()
+        desc = data.strip()
+        if "[linkding-notes]" in desc:
+            self.notes = desc.split("[linkding-notes]")[1].split("[/linkding-notes]")[0]
+        self.description = desc.split("[linkding-notes]")[0]

    def add_bookmark(self):
        if self.bookmark:
            self.bookmark.title = self.title
            self.bookmark.description = self.description
+            self.bookmark.notes = self.notes
            self.bookmarks.append(self.bookmark)
        self.bookmark = None
-        self.href = ''
-        self.add_date = ''
-        self.tags = ''
-        self.title = ''
-        self.description = ''
-        self.toread = ''
+        self.href = ""
+        self.add_date = ""
+        self.tags = ""
+        self.title = ""
+        self.description = ""
+        self.notes = ""
+        self.toread = ""
+        self.private = ""


 def parse(html: str) -> List[NetscapeBookmark]:
--- a/bookmarks/services/singlefile.py
+++ b/bookmarks/services/singlefile.py
@@ -0,0 +1,55 @@
+import gzip
+import logging
+import os
+import shutil
+import signal
+import subprocess
+
+from django.conf import settings
+
+
+class SingeFileError(Exception):
+    pass
+
+
+logger = logging.getLogger(__name__)
+
+
+def create_snapshot(url: str, filepath: str):
+    singlefile_path = settings.LD_SINGLEFILE_PATH
+    # singlefile_options = settings.LD_SINGLEFILE_OPTIONS
+    temp_filepath = filepath + ".tmp"
+
+    args = [singlefile_path, url, temp_filepath]
+    try:
+        # Use start_new_session=True to create a new process group
+        process = subprocess.Popen(args, start_new_session=True)
+        process.wait(timeout=60)
+
+        # check if the file was created
+        if not os.path.exists(temp_filepath):
+            raise SingeFileError("Failed to create snapshot")
+
+        with open(temp_filepath, "rb") as raw_file, gzip.open(
+            filepath, "wb"
+        ) as gz_file:
+            shutil.copyfileobj(raw_file, gz_file)
+
+        os.remove(temp_filepath)
+    except subprocess.TimeoutExpired:
+        # First try to terminate properly
+        try:
+            logger.error(
+                "Timeout expired while creating snapshot. Terminating process..."
+            )
+            process.terminate()
+            process.wait(timeout=20)
+            raise SingeFileError("Timeout expired while creating snapshot")
+        except subprocess.TimeoutExpired:
+            # Kill the whole process group, which should also clean up any chromium
+            # processes spawned by single-file
+            logger.error("Timeout expired while terminating. Killing process...")
+            os.killpg(os.getpgid(process.pid), signal.SIGTERM)
+            raise SingeFileError("Timeout expired while creating snapshot")
+    except subprocess.CalledProcessError as error:
+        raise SingeFileError(f"Failed to create snapshot: {error.stderr}")
--- a/bookmarks/services/tags.py
+++ b/bookmarks/services/tags.py
@@ -13,7 +13,7 @@ logger = logging.getLogger(__name__)

 def get_or_create_tags(tag_names: List[str], user: User):
    tags = [get_or_create_tag(tag_name, user) for tag_name in tag_names]
-    return unique(tags, operator.attrgetter('id'))
+    return unique(tags, operator.attrgetter("id"))


 def get_or_create_tag(name: str, user: User):
--- a/bookmarks/services/tasks.py
+++ b/bookmarks/services/tasks.py
@@ -1,25 +1,60 @@
+import functools
 import logging
+import os

 import waybackpy
-from background_task import background
-from background_task.models import Task
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import User
+from django.utils import timezone, formats
+from huey import crontab
+from huey.contrib.djhuey import HUEY as huey
+from huey.exceptions import TaskLockedException
 from waybackpy.exceptions import WaybackError, TooManyRequestsError, NoCDXRecordFound

 import bookmarks.services.wayback
-from bookmarks.models import Bookmark, UserProfile
-from bookmarks.services import favicon_loader
+from bookmarks.models import Bookmark, BookmarkAsset, UserProfile
+from bookmarks.services import favicon_loader, singlefile
 from bookmarks.services.website_loader import DEFAULT_USER_AGENT

 logger = logging.getLogger(__name__)


+# Create custom decorator for Huey tasks that implements exponential backoff
+# Taken from: https://huey.readthedocs.io/en/latest/guide.html#tips-and-tricks
+# Retry 1: 60
+# Retry 2: 240
+# Retry 3: 960
+# Retry 4: 3840
+# Retry 5: 15360
+def task(retries=5, retry_delay=15, retry_backoff=4):
+    def deco(fn):
+        @functools.wraps(fn)
+        def inner(*args, **kwargs):
+            task = kwargs.pop("task")
+            try:
+                return fn(*args, **kwargs)
+            except TaskLockedException as exc:
+                # Task locks are currently only used as workaround to enforce
+                # running specific types of tasks (e.g. singlefile snapshots)
+                # sequentially. In that case don't reduce the number of retries.
+                task.retries = retries
+                raise exc
+            except Exception as exc:
+                task.retry_delay *= retry_backoff
+                raise exc
+
+        return huey.task(retries=retries, retry_delay=retry_delay, context=True)(inner)
+
+    return deco
+
+
 def is_web_archive_integration_active(user: User) -> bool:
    background_tasks_enabled = not settings.LD_DISABLE_BACKGROUND_TASKS
-    web_archive_integration_enabled = \
-        user.profile.web_archive_integration == UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED
+    web_archive_integration_enabled = (
+        user.profile.web_archive_integration
+        == UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED
+    )

    return background_tasks_enabled and web_archive_integration_enabled

@@ -31,31 +66,39 @@ def create_web_archive_snapshot(user: User, bookmark: Bookmark, force_update: bo

 def _load_newest_snapshot(bookmark: Bookmark):
    try:
-        logger.info(f'Load existing snapshot for bookmark. url={bookmark.url}')
-        cdx_api = bookmarks.services.wayback.CustomWaybackMachineCDXServerAPI(bookmark.url)
+        logger.info(f"Load existing snapshot for bookmark. url={bookmark.url}")
+        cdx_api = bookmarks.services.wayback.CustomWaybackMachineCDXServerAPI(
+            bookmark.url
+        )
        existing_snapshot = cdx_api.newest()

        if existing_snapshot:
            bookmark.web_archive_snapshot_url = existing_snapshot.archive_url
-            bookmark.save(update_fields=['web_archive_snapshot_url'])
-            logger.info(f'Using newest snapshot. url={bookmark.url} from={existing_snapshot.datetime_timestamp}')
+            bookmark.save(update_fields=["web_archive_snapshot_url"])
+            logger.info(
+                f"Using newest snapshot. url={bookmark.url} from={existing_snapshot.datetime_timestamp}"
+            )

    except NoCDXRecordFound:
-        logger.info(f'Could not find any snapshots for bookmark. url={bookmark.url}')
+        logger.info(f"Could not find any snapshots for bookmark. url={bookmark.url}")
    except WaybackError as error:
-        logger.error(f'Failed to load existing snapshot. url={bookmark.url}', exc_info=error)
+        logger.error(
+            f"Failed to load existing snapshot. url={bookmark.url}", exc_info=error
+        )


 def _create_snapshot(bookmark: Bookmark):
-    logger.info(f'Create new snapshot for bookmark. url={bookmark.url}...')
-    archive = waybackpy.WaybackMachineSaveAPI(bookmark.url, DEFAULT_USER_AGENT, max_tries=1)
+    logger.info(f"Create new snapshot for bookmark. url={bookmark.url}...")
+    archive = waybackpy.WaybackMachineSaveAPI(
+        bookmark.url, DEFAULT_USER_AGENT, max_tries=1
+    )
    archive.save()
    bookmark.web_archive_snapshot_url = archive.archive_url
-    bookmark.save(update_fields=['web_archive_snapshot_url'])
-    logger.info(f'Successfully created new snapshot for bookmark:. url={bookmark.url}')
+    bookmark.save(update_fields=["web_archive_snapshot_url"])
+    logger.info(f"Successfully created new snapshot for bookmark:. url={bookmark.url}")


-@background()
+@task()
 def _create_web_archive_snapshot_task(bookmark_id: int, force_update: bool):
    try:
        bookmark = Bookmark.objects.get(id=bookmark_id)
@@ -72,16 +115,19 @@ def _create_web_archive_snapshot_task(bookmark_id: int, force_update: bool):
        return
    except TooManyRequestsError:
        logger.error(
-            f'Failed to create snapshot due to rate limiting, trying to load newest snapshot as fallback. url={bookmark.url}')
+            f"Failed to create snapshot due to rate limiting, trying to load newest snapshot as fallback. url={bookmark.url}"
+        )
    except WaybackError as error:
-        logger.error(f'Failed to create snapshot, trying to load newest snapshot as fallback. url={bookmark.url}',
-                     exc_info=error)
+        logger.error(
+            f"Failed to create snapshot, trying to load newest snapshot as fallback. url={bookmark.url}",
+            exc_info=error,
+        )

    # Load the newest snapshot as fallback
    _load_newest_snapshot(bookmark)


-@background()
+@task()
 def _load_web_archive_snapshot_task(bookmark_id: int):
    try:
        bookmark = Bookmark.objects.get(id=bookmark_id)
@@ -99,11 +145,14 @@ def schedule_bookmarks_without_snapshots(user: User):
        _schedule_bookmarks_without_snapshots_task(user.id)


-@background()
+@task()
 def _schedule_bookmarks_without_snapshots_task(user_id: int):
    user = get_user_model().objects.get(id=user_id)
-    bookmarks_without_snapshots = Bookmark.objects.filter(web_archive_snapshot_url__exact='', owner=user)
+    bookmarks_without_snapshots = Bookmark.objects.filter(
+        web_archive_snapshot_url__exact="", owner=user
+    )

+    # TODO: Implement bulk task creation
    for bookmark in bookmarks_without_snapshots:
        # To prevent rate limit errors from the Wayback API only try to load the latest snapshots instead of creating
        # new ones when processing bookmarks in bulk
@@ -121,21 +170,23 @@ def load_favicon(user: User, bookmark: Bookmark):
        _load_favicon_task(bookmark.id)


-@background()
+@task()
 def _load_favicon_task(bookmark_id: int):
    try:
        bookmark = Bookmark.objects.get(id=bookmark_id)
    except Bookmark.DoesNotExist:
        return

-    logger.info(f'Load favicon for bookmark. url={bookmark.url}')
+    logger.info(f"Load favicon for bookmark. url={bookmark.url}")

-    new_favicon = favicon_loader.load_favicon(bookmark.url)
+    new_favicon_file = favicon_loader.load_favicon(bookmark.url)

-    if new_favicon != bookmark.favicon_file:
-        bookmark.favicon_file = new_favicon
-        bookmark.save(update_fields=['favicon_file'])
-        logger.info(f'Successfully updated favicon for bookmark. url={bookmark.url} icon={new_favicon}')
+    if new_favicon_file != bookmark.favicon_file:
+        bookmark.favicon_file = new_favicon_file
+        bookmark.save(update_fields=["favicon_file"])
+        logger.info(
+            f"Successfully updated favicon for bookmark. url={bookmark.url} icon={new_favicon_file}"
+        )


 def schedule_bookmarks_without_favicons(user: User):
@@ -143,17 +194,15 @@ def schedule_bookmarks_without_favicons(user: User):
        _schedule_bookmarks_without_favicons_task(user.id)


-@background()
+@task()
 def _schedule_bookmarks_without_favicons_task(user_id: int):
    user = get_user_model().objects.get(id=user_id)
-    bookmarks = Bookmark.objects.filter(favicon_file__exact='', owner=user)
-    tasks = []
+    bookmarks = Bookmark.objects.filter(favicon_file__exact="", owner=user)

+    # TODO: Implement bulk task creation
    for bookmark in bookmarks:
-        task = Task.objects.new_task(task_name='bookmarks.services.tasks._load_favicon_task', args=(bookmark.id,))
-        tasks.append(task)
-
-    Task.objects.bulk_create(tasks)
+        _load_favicon_task(bookmark.id)
+        pass


 def schedule_refresh_favicons(user: User):
@@ -161,14 +210,88 @@ def schedule_refresh_favicons(user: User):
        _schedule_refresh_favicons_task(user.id)


-@background()
+@task()
 def _schedule_refresh_favicons_task(user_id: int):
    user = get_user_model().objects.get(id=user_id)
    bookmarks = Bookmark.objects.filter(owner=user)
-    tasks = []

+    # TODO: Implement bulk task creation
    for bookmark in bookmarks:
-        task = Task.objects.new_task(task_name='bookmarks.services.tasks._load_favicon_task', args=(bookmark.id,))
-        tasks.append(task)
+        _load_favicon_task(bookmark.id)

-    Task.objects.bulk_create(tasks)
+
+def is_html_snapshot_feature_active() -> bool:
+    return settings.LD_ENABLE_SNAPSHOTS and not settings.LD_DISABLE_BACKGROUND_TASKS
+
+
+def create_html_snapshot(bookmark: Bookmark):
+    if not is_html_snapshot_feature_active():
+        return
+
+    timestamp = formats.date_format(timezone.now(), "SHORT_DATE_FORMAT")
+    asset = BookmarkAsset(
+        bookmark=bookmark,
+        asset_type=BookmarkAsset.TYPE_SNAPSHOT,
+        content_type="text/html",
+        display_name=f"HTML snapshot from {timestamp}",
+        status=BookmarkAsset.STATUS_PENDING,
+    )
+    asset.save()
+
+
+def _generate_snapshot_filename(asset: BookmarkAsset) -> str:
+    def sanitize_char(char):
+        if char.isalnum() or char in ("-", "_", "."):
+            return char
+        else:
+            return "_"
+
+    formatted_datetime = asset.date_created.strftime("%Y-%m-%d_%H%M%S")
+    sanitized_url = "".join(sanitize_char(char) for char in asset.bookmark.url)
+
+    return f"{asset.asset_type}_{formatted_datetime}_{sanitized_url}.html.gz"
+
+
+# singe-file does not support running multiple instances in parallel, so we can
+# not queue up multiple snapshot tasks at once. Instead, schedule a periodic
+# task that grabs a number of pending assets and creates snapshots for them in
+# sequence. The task uses a lock to ensure that a new task isn't scheduled
+# before the previous one has finished.
+@huey.periodic_task(crontab(minute="*"))
+@huey.lock_task("schedule-html-snapshots-lock")
+def _schedule_html_snapshots_task():
+    # Get five pending assets
+    assets = BookmarkAsset.objects.filter(status=BookmarkAsset.STATUS_PENDING).order_by(
+        "date_created"
+    )[:5]
+
+    for asset in assets:
+        _create_html_snapshot_task(asset.id)
+
+
+def _create_html_snapshot_task(asset_id: int):
+    try:
+        asset = BookmarkAsset.objects.get(id=asset_id)
+    except BookmarkAsset.DoesNotExist:
+        return
+
+    logger.info(f"Create HTML snapshot for bookmark. url={asset.bookmark.url}")
+
+    try:
+        filename = _generate_snapshot_filename(asset)
+        filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
+        singlefile.create_snapshot(asset.bookmark.url, filepath)
+        asset.status = BookmarkAsset.STATUS_COMPLETE
+        asset.file = filename
+        asset.gzip = True
+        asset.save()
+        logger.info(
+            f"Successfully created HTML snapshot for bookmark. url={asset.bookmark.url}"
+        )
+    except Exception as error:
+        logger.error(
+            f"Failed to HTML snapshot for bookmark. url={asset.bookmark.url}",
+            exc_info=error,
+        )
+        asset.status = BookmarkAsset.STATUS_FAILURE
+        asset.save()
--- a/bookmarks/services/wayback.py
+++ b/bookmarks/services/wayback.py
@@ -14,8 +14,10 @@ class CustomWaybackMachineCDXServerAPI(waybackpy.WaybackMachineCDXServerAPI):

    def newest(self):
        unix_timestamp = int(time.time())
-        self.closest = waybackpy.utils.unix_timestamp_to_wayback_timestamp(unix_timestamp)
-        self.sort = 'closest'
+        self.closest = waybackpy.utils.unix_timestamp_to_wayback_timestamp(
+            unix_timestamp
+        )
+        self.sort = "closest"
        self.limit = -5

        newest_snapshot = None
@@ -37,4 +39,4 @@ class CustomWaybackMachineCDXServerAPI(waybackpy.WaybackMachineCDXServerAPI):
        super().add_payload(payload)
        # Set fastLatest query param, as we are only using this API to get the latest snapshot and using fastLatest
        # makes searching for latest snapshots faster
-        payload['fastLatest'] = 'true'
+        payload["fastLatest"] = "true"
--- a/Show More
+++ b/Show More