diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 00000000..ce9dfc0a
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: [magreenblatt]
diff --git a/.gitignore b/.gitignore
index e7bc7d07..d9565ba0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -54,4 +54,6 @@ Thumbs.db
 /tools/buildtools/external_bin
 /tools/buildtools/linux64/clang-format
 /tools/buildtools/mac/clang-format
+# Misc working directories
+/tmp
 /tools/buildtools/win/clang-format.exe
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..60a79ab6
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,81 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project overview
+
+JCEF is a Java wrapper around the C++ Chromium Embedded Framework (CEF). It is a hybrid Java + native (C++/Obj-C) project bound together by JNI. JCEF tracks a specific CEF release branch — the active version is set by `CEF_VERSION` in `CMakeLists.txt`, and the matching CEF binary distribution is downloaded by `cmake/DownloadCEF.cmake` into `third_party/cef/` at configure time.
+
+## Build
+
+The build is driven by CMake and **must** run inside a directory literally named `jcef_build/` at the repo root — `tools/run.sh`, `tools/make_distrib.sh`, etc. hard-code that path.
+
+```sh
+mkdir jcef_build && cd jcef_build
+
+# macOS (arm64 host):
+cmake -G "Ninja" -DPROJECT_ARCH="arm64" -DCMAKE_BUILD_TYPE=Release ..
+ninja
+# Or generate Xcode: cmake -G "Xcode" -DPROJECT_ARCH="arm64" ..
+
+# Linux:
+cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Release ..
+ninja
+
+# Windows (x64):
+cmake -G "Visual Studio 17" -A x64 ..
+# build via VS or ninja with vcvars64.bat
+```
+
+Configure-time side effects to be aware of:
+- Downloads + extracts the CEF binary distribution.
+- Generates `native/jcef_version.h` from CEF headers via `tools/make_version_header.py`.
+- Downloads `clang-format` from Google Storage into `tools/buildtools/<platform>/`.
+
+Java compilation differs by platform:
+- **macOS:** the CMake build invokes Ant (`build.xml`) as a post-build step. It produces `jcef.jar` + `jcef-tests.jar`, bundles everything into `jcef_app.app` via `third_party/appbundler`, and copies the CEF framework + helper apps into the bundle. Requires `ant` (`brew install ant`).
+- **Linux/Windows:** Java is compiled separately with `tools/compile.{sh,bat} <platform>` (e.g. `linux64`, `win64`); the CMake build only handles native code.
+
+## Run / test / package
+
+```sh
+# Launch the test app (Linux/Windows). On macOS run jcef_build/native/Release/jcef_app.app.
+tools/run.sh    <platform> <Debug|Release> <simple|detailed> [args...]
+
+# JUnit tests under java/tests/junittests via junit-platform-console-standalone.
+tools/run_tests.sh <platform> <Debug|Release> [extra junit args...]
+
+# Build a redistributable in binary_distrib/<platform>/.
+tools/make_distrib.sh <platform>
+```
+
+`<platform>` is `linux32`, `linux64`, `macosx64`, `win32`, or `win64`.
+
+## Code style
+
+Chromium coding style for both C++ and Java. Run `tools/fix_style.sh [path...]` (which calls `tools/fix_style.py`) to apply clang-format. clang-format is downloaded by CMake into `tools/buildtools/`, so a configure step must have run first.
+
+## Architecture
+
+The project is organized as **Java API ↔ JNI bridge ↔ CEF C++**.
+
+### Java side (`java/org/cef/`)
+- `CefApp` — global singleton; owns CEF process lifecycle and state machine (`CefAppState`).
+- `CefClient` — per-browser client object that fans handler callbacks out to user-registered `Cef*Handler` interfaces.
+- `browser/` — `CefBrowser` interface plus two implementations: `CefBrowserOsr` (off-screen rendering, OpenGL via JOGL) and `CefBrowserWr` (windowed rendering); `CefBrowserFactory` picks one. macOS uses the extra `browser/mac/CefBrowserWindowMac.java`.
+- `handler/` — observer-style callback interfaces (`CefLifeSpanHandler`, `CefLoadHandler`, `CefRequestHandler`, …) each paired with an `*Adapter` no-op base class.
+- `callback/`, `misc/`, `network/` — value/callback types mirrored to native.
+
+### Native side (`native/`)
+- Files ending in `_N.cpp/.h` (e.g. `CefBrowser_N.cpp`) implement the JNI methods of the matching Java class with the `_N` suffix (e.g. `org.cef.browser.CefBrowser_N`). Headers are machine-generated via `javah`/`javac -h` — regenerate with `tools/make_all_jni_headers.{sh,bat} <platform>` (or `make_jni_header.{sh,bat} <platform> <fully.qualified.Class>` for one class). When you add a new `_N` Java class, also add it to `make_all_jni_headers.*`.
+- Non-`_N.cpp` files (`client_handler.cpp`, `*_handler.cpp`, `client_app.cpp`, `context.cpp`, …) implement the CEF C++ side: they receive callbacks from CEF and dispatch them up into Java via the helpers in `jni_util.{h,cpp}` and `jni_scoped_helpers.{h,cpp}`.
+- Platform-specific code is split into `*_linux.cpp`, `*_mac.mm`, `*_win.cpp`, `*_posix.cpp`, plus `temp_window_{x11,mac,win}` and `critical_wait_{posix,win}`. CMake's `APPEND_PLATFORM_SOURCES` selects the right set per OS.
+- `jcef_helper.cpp` builds a separate `jcef_helper`/`jcef Helper` executable — Chromium's multi-process model requires a helper binary for renderer/GPU/etc. processes.
+
+### Build outputs
+- `jcef_build/native/<config>/` — `libjcef.{so,dylib}` / `jcef.dll`, the helper executable(s), and (on macOS) `jcef_app.app` containing the framework + Helper bundles.
+- `out/` — Ant-produced Java class files / jars on macOS; mirrored layout used by `tools/compile.sh` on other platforms.
+
+## Other notes
+
+- macOS app launches require these JVM flags (already wired into `build.xml` and `run.sh`): `--add-opens=java.desktop/sun.{awt,lwawt,lwawt.macosx}=ALL-UNNAMED`, `--add-opens=java.desktop/java.awt=ALL-UNNAMED`, `--enable-native-access=ALL-UNNAMED`. Anything that calls JCEF off-bundle needs the same flags.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3b65a374..a1cd92d8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,8 +11,8 @@
 # CMake-generated project formats that have been tested with JCEF include:
 #
 # Linux:      Ninja, GCC 7.5.0+, Unix Makefiles
-# MacOS:      Ninja, Xcode 12.2 to 13.0
-# Windows:    Ninja, Visual Studio 2019+
+# MacOS:      Ninja, Xcode 13.3 to 16.4
+# Windows:    Ninja, Visual Studio 2022
 #
 # Ninja is a cross-platform open-source tool for running fast builds using
 # pre-installed platform toolchains (GNU, clang, Xcode or MSVC). It can be
@@ -23,7 +23,7 @@
 #
 # The below requirements must be met to build JCEF.
 #
-# - CMake version 3.19 or newer.
+# - CMake version 3.21 or newer.
 #
 # - Linux requirements:
 #   Currently supported distributions include Debian 10 (Buster), Ubuntu 18
@@ -35,15 +35,14 @@
 #     libgtk3.0-dev     (required by the cefclient target only)
 #
 # - MacOS requirements:
-#   Xcode 12.2 to 13.0 building on MacOS 10.15.4 (Catalina) or newer. Only
-#   64-bit builds are supported. The Xcode command-line tools must also be
-#   installed. Newer Xcode versions may not have been been tested and are not
-#   recommended.
+#   Xcode 13.5 to 16.4 building on MacOS 12.0 (Monterey) or newer. The Xcode
+#   command-line tools must also be installed. Newer Xcode versions may not have
+#   been been tested and are not recommended.
 #
 # - Windows requirements:
-#   Visual Studio 2019 or newer building on Windows 7 or newer. Windows 10
-#   64-bit is recommended. Newer versions will likely also work but may not have
-#   been tested.
+#   Visual Studio 2022 building on Windows 10 or newer. Windows 10/11 64-bit is
+#   recommended. Newer versions will likely also work but may not have been
+#   tested.
 #
 # BUILD EXAMPLES
 #
@@ -86,24 +85,24 @@
 #     > ninja
 #
 # To perform a Windows build using a 32-bit CEF binary distribution:
-#   Using the Visual Studio 2019 IDE:
-#     > cmake -G "Visual Studio 16" -A Win32 ..
+#   Using the Visual Studio 2022 IDE:
+#     > cmake -G "Visual Studio 17" -A Win32 ..
 #     Open jcef.sln in Visual Studio and select Build > Build Solution.
 #
-#   Using Ninja with Visual Studio 2019 command-line tools:
+#   Using Ninja with Visual Studio 2022 command-line tools:
 #     (this path may be different depending on your Visual Studio installation)
-#     > "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars32.bat"
+#     > "C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Auxiliary\Build\vcvars32.bat"
 #     > cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Debug ..
 #     > ninja
 #
 # To perform a Windows build using a 64-bit CEF binary distribution:
-#   Using the Visual Studio 2019 IDE:
-#     > cmake -G "Visual Studio 16" -A x64 ..
+#   Using the Visual Studio 2022 IDE:
+#     > cmake -G "Visual Studio 17" -A x64 ..
 #     Open jcef.sln in Visual Studio and select Build > Build Solution.
 #
-#   Using Ninja with Visual Studio 2019 command-line tools:
+#   Using Ninja with Visual Studio 2022 command-line tools:
 #     (this path may be different depending on your Visual Studio installation)
-#     > "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat"
+#     > "C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Auxiliary\Build\vcvars64.bat"
 #     > cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Debug ..
 #     > ninja
 
@@ -111,8 +110,8 @@
 # Shared configuration.
 #
 
-# For VS2019 and Xcode 12+ support.
-cmake_minimum_required(VERSION 3.19)
+# For VS2022 and Xcode 12+ support.
+cmake_minimum_required(VERSION 3.21)
 
 # Only generate Debug and Release configuration types.
 set(CMAKE_CONFIGURATION_TYPES Debug Release)
@@ -130,7 +129,7 @@ set_property(GLOBAL PROPERTY OS_FOLDERS ON)
 
 # Specify the CEF distribution version.
 if(NOT DEFINED CEF_VERSION)
-  set(CEF_VERSION "135.0.20+ge7de5c3+chromium-135.0.7049.85")
+  set(CEF_VERSION "146.0.10+g8219561+chromium-146.0.7680.179")
 endif()
 
 # Determine the platform.
diff --git a/README.md b/README.md
index e2443d49..d6ee5836 100644
--- a/README.md
+++ b/README.md
@@ -2,12 +2,12 @@ The Java Chromium Embedded Framework (JCEF) is a simple framework for embedding
 
 # Quick Links
 
-* Building JCEF - https://bitbucket.org/chromiumembedded/java-cef/wiki/BranchesAndBuilding
+* Building JCEF - https://chromiumembedded.github.io/java-cef/branches_and_building
 * Support Forum - http://magpcss.org/ceforum/viewforum.php?f=17
 * Issue Tracker - https://github.com/chromiumembedded/java-cef/issues
 * Downloads - https://github.com/jcefmaven/jcefbuild
 * Maven/Gradle Artifacts - https://github.com/jcefmaven/jcefmaven
-* Donations - http://www.magpcss.org/ceforum/donate.php
+* Donations - https://github.com/sponsors/magreenblatt
 
 # Introduction
 
@@ -24,7 +24,7 @@ This project provides a Java Wrapper for CEF (JCEF).
 
 # Building JCEF
 
-The JCEF project is an extension of the Chromium Embedded Framework (CEF) project hosted at https://bitbucket.org/chromiumembedded/cef/. JCEF maintains a development branch that tracks the most recent CEF3 release branch. JCEF source code can be downloaded, built and packaged into a binary distribution. Once you have created the binary distribution for your platform you can distribute it as a stand-alone package without further dependencies on the JCEF, CEF or Chromium source code. Visit the [BranchesAndBuilding](https://bitbucket.org/chromiumembedded/java-cef/wiki/BranchesAndBuilding) Wiki page for detailed instructions.
+The JCEF project is an extension of the Chromium Embedded Framework (CEF) project hosted at https://github.com/chromiumembedded/cef. JCEF maintains a development branch that tracks the most recent CEF3 release branch. JCEF source code can be downloaded, built and packaged into a binary distribution. Once you have created the binary distribution for your platform you can distribute it as a stand-alone package without further dependencies on the JCEF, CEF or Chromium source code. Visit the [Branches and Building](https://chromiumembedded.github.io/java-cef/branches_and_building) page for detailed instructions.
 
 # Helping Out
 
@@ -47,9 +47,9 @@ If you would like to contribute source code changes to JCEF please follow the be
 
 \- Create or find an appropriate issue for each distinct bug, feature or change. 
 
-\- Submit a [pull request](https://bitbucket.org/chromiumembedded/java-cef/wiki/ContributingWithGit) or create a patch with your changes and attach it to the JCEF issue. Changes should:
+\- Submit a [pull request](https://chromiumembedded.github.io/java-cef/contributing_with_git) or create a patch with your changes and attach it to the JCEF issue. Changes should:
 
-* Be submitted against the current [JCEF master branch](https://bitbucket.org/chromiumembedded/java-cef/src/?at=master) unless explicitly fixing a bug in a CEF release branch.
+* Be submitted against the current [JCEF master branch](https://github.com/chromiumembedded/java-cef/tree/master) unless explicitly fixing a bug in a CEF release branch.
 * Follow the style of existing JCEF source files. In general JCEF uses the [Chromium coding style](http://www.chromium.org/developers/coding-style).
 * Include new or modified unit tests as appropriate to the functionality.
 * Not include unnecessary or unrelated changes.
\ No newline at end of file
diff --git a/appveyor.yml b/appveyor.yml
index 8c94201f..1be24c4a 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,7 +1,7 @@
 # This is a configuration file for the continuous delivery service provided
 # by AppVeyor.com. Its purpose is to automatically build both the 32
 # and 64 bit versions of the Java Chromium Embedded Framework (JCEF).
-# Please refer to https://bitbucket.org/chromiumembedded/java-cef
+# Please refer to https://github.com/chromiumembedded/java-cef
 # for more information on JCEF.
 
 os: Visual Studio 2015
diff --git a/build.xml b/build.xml
index 010b5c57..e7a77073 100644
--- a/build.xml
+++ b/build.xml
@@ -74,6 +74,11 @@
       </classpath>
       <classpath dir="third_party/junit" includes="junit*.jar"/>
       <option value="-Djava.library.path=$APP_ROOT/Contents/Java/:$APP_ROOT/Contents/Frameworks/Chromium Embedded Framework.framework/Libraries" />
+      <option value="--add-opens=java.desktop/sun.awt=ALL-UNNAMED" />
+      <option value="--add-opens=java.desktop/sun.lwawt=ALL-UNNAMED" />
+      <option value="--add-opens=java.desktop/sun.lwawt.macosx=ALL-UNNAMED" />
+      <option value="--add-opens=java.desktop/java.awt=ALL-UNNAMED" />
+      <option value="--enable-native-access=ALL-UNNAMED" />
     </bundleapp>
   </target>
 </project>
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 00000000..1a89654d
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,12 @@
+The Java Chromium Embedded Framework (JCEF) is a simple framework for embedding Chromium-based browsers in other applications using the Java programming language. Visit the [Project Overview page](https://github.com/chromiumembedded/java-cef) for more information.
+
+# Documentation
+
+* [Branches And Building](branches_and_building.md) - Information about JCEF branches and instructions for downloading, building and packaging source code.
+* [Contributing With Git](contributing_with_git.md) - How to contribute code changes to JCEF using Git.
+* [Building Open JDK](building_openjdk.md) - Instructions for building OpenJDK locally for use when debugging Java/JCEF issues.
+
+# External Links
+
+* Support Forum - <http://magpcss.org/ceforum/viewforum.php?f=17>
+* Donations - <http://www.magpcss.org/ceforum/donate.php>
\ No newline at end of file
diff --git a/docs/_config.yml b/docs/_config.yml
new file mode 100644
index 00000000..8f614367
--- /dev/null
+++ b/docs/_config.yml
@@ -0,0 +1,3 @@
+title: JCEF Documentation
+description: Java Chromium Embedded Framework documentation
+theme: jekyll-theme-minimal
diff --git a/docs/assets/css/style.scss b/docs/assets/css/style.scss
new file mode 100644
index 00000000..2e22cfe2
--- /dev/null
+++ b/docs/assets/css/style.scss
@@ -0,0 +1,221 @@
+---
+---
+
+@import "{{ site.theme }}";
+
+/* Reduce sidebar width */
+header,
+footer {
+  width: 180px;
+  padding-right: 10px;
+}
+
+section {
+  width: calc(100% - 200px);
+  margin-left: 200px;
+  max-width: 900px !important;
+}
+
+.wrapper {
+  width: 900px !important;
+}
+
+/* Smaller header text */
+header h1 {
+  font-size: 1.5em;
+}
+
+/* Fix footer text wrapping */
+header p,
+header small {
+  word-wrap: break-word;
+  overflow-wrap: break-word;
+  white-space: normal;
+  max-width: 100%;
+  font-size: 0.75em;
+  display: block;
+}
+
+/* Prevent link hover from adding bold (causes layout shift) */
+a:hover {
+  font-weight: inherit;
+}
+
+/* Mobile: hide sidebar, full width content */
+@media print, screen and (max-width: 720px) {
+  header {
+    width: auto;
+    padding-right: 0;
+  }
+  section {
+    width: 100%;
+    margin-left: 0;
+    max-width: 100% !important;
+  }
+  .wrapper {
+    width: auto !important;
+    max-width: 100% !important;
+  }
+}
+
+/* Dark mode support */
+@media (prefers-color-scheme: dark) {
+  body,
+  .wrapper {
+    background-color: #1a1a1a !important;
+    color: #d0d0d0 !important;
+  }
+
+  header,
+  section {
+    background-color: #1a1a1a !important;
+  }
+
+  a {
+    color: #6db3f2 !important;
+  }
+
+  a:hover {
+    color: #9dcbf5 !important;
+  }
+
+  h1, h2, h3, h4, h5, h6 {
+    color: #f0f0f0 !important;
+    border-bottom-color: #444 !important;
+  }
+
+  /* Inline code */
+  code {
+    background-color: #2a2a2a !important;
+    color: #f0a050 !important;
+    border: none !important;
+    border-radius: 3px !important;
+  }
+
+  /* Code blocks */
+  pre {
+    background-color: #252525 !important;
+    border: 1px solid #3a3a3a !important;
+    color: #d0d0d0 !important;
+  }
+
+  pre code {
+    background-color: transparent !important;
+    color: #d0d0d0 !important;
+  }
+
+  blockquote {
+    border-left-color: #555 !important;
+    color: #a0a0a0 !important;
+  }
+
+  hr {
+    border-color: #444 !important;
+    background-color: #444 !important;
+  }
+
+  table th,
+  table td {
+    border-color: #444 !important;
+  }
+
+  table th {
+    background-color: #333 !important;
+    color: #f0f0f0 !important;
+    font-weight: bold !important;
+  }
+
+  table tr:nth-child(even) {
+    background-color: #222 !important;
+  }
+
+  /* Lists */
+  ul, ol, li {
+    color: #d0d0d0 !important;
+  }
+
+  /* Strong/bold */
+  strong, b {
+    color: #e8e8e8 !important;
+  }
+
+  /* Syntax highlighting for code blocks (Rouge/Pygments) */
+  .highlight {
+    background-color: #252525 !important;
+  }
+
+  /* Error tokens - remove error highlighting */
+  .highlight .err {
+    background-color: transparent !important;
+    color: #d4d4d4 !important;
+  }
+
+  /* Comments */
+  .highlight .c, .highlight .c1, .highlight .cm, .highlight .cs {
+    color: #6a9955 !important;
+    font-style: italic;
+  }
+
+  /* Keywords */
+  .highlight .k, .highlight .kd, .highlight .kn, .highlight .kp,
+  .highlight .kr, .highlight .kt, .highlight .kc {
+    color: #569cd6 !important;
+  }
+
+  /* Strings */
+  .highlight .s, .highlight .s1, .highlight .s2, .highlight .sb,
+  .highlight .sc, .highlight .sd, .highlight .se, .highlight .sh,
+  .highlight .si, .highlight .sx, .highlight .sr, .highlight .ss,
+  .highlight .dl {
+    color: #ce9178 !important;
+    background-color: transparent !important;
+  }
+
+  /* Numbers */
+  .highlight .m, .highlight .mi, .highlight .mf, .highlight .mh,
+  .highlight .mo, .highlight .il {
+    color: #b5cea8 !important;
+  }
+
+  /* Operators */
+  .highlight .o, .highlight .ow {
+    color: #d4d4d4 !important;
+  }
+
+  /* Punctuation */
+  .highlight .p {
+    color: #d4d4d4 !important;
+  }
+
+  /* Names/identifiers */
+  .highlight .n, .highlight .na, .highlight .nb, .highlight .nc,
+  .highlight .no, .highlight .nd, .highlight .ni, .highlight .ne,
+  .highlight .nf, .highlight .nl, .highlight .nn, .highlight .nt,
+  .highlight .nv, .highlight .nx {
+    color: #dcdcaa !important;
+  }
+
+  /* Class names */
+  .highlight .nc {
+    color: #4ec9b0 !important;
+  }
+
+  /* Function names */
+  .highlight .nf {
+    color: #dcdcaa !important;
+  }
+
+  /* Preprocessor */
+  .highlight .cp, .highlight .cpf {
+    color: #c586c0 !important;
+  }
+
+  /* Generic */
+  .highlight .ge {
+    font-style: italic;
+  }
+
+  .highlight .gs {
+    font-weight: bold;
+  }
+}
diff --git a/docs/branches_and_building.md b/docs/branches_and_building.md
new file mode 100644
index 00000000..4d72a6bc
--- /dev/null
+++ b/docs/branches_and_building.md
@@ -0,0 +1,139 @@
+This page lists notes for JCEF releases.
+
+**Contents**
+
+- [Background](#background)
+- [Development](#development)
+- [Building from Source Code](#building-from-source-code)
+  - [Building with Docker or GitHub Actions](#building-with-docker-or-github-actions)
+  - [Building Manually](#building-manually)
+    - [Downloading Source Code](#downloading-source-code)
+    - [Building](#building)
+    - [Packaging](#packaging)
+
+---
+
+# Background
+
+The JCEF project is an extension of the Chromium Embedded Framework project hosted at <https://github.com/chromiumembedded/cef>. JCEF maintains a development branch that tracks the most recent CEF release branch. JCEF source code (both native code and Java code) can be built manually as described below.
+
+# Development
+
+Ongoing development of JCEF occurs on the [master branch](https://github.com/chromiumembedded/java-cef/tree/master). This location tracks the current CEF3 release branch.
+
+# Building from Source Code
+
+Building JCEF from source code is currently supported on Windows, Linux and MacOS for 64-bit Oracle Java targets. 32-bit builds are also possible on Windows and Linux but they are untested.
+
+To build JCEF from source code you should begin by installing the build prerequisites for your operating system and development environment. For all platforms this includes:
+
+* [CMake](http://cmake.org/download/) version 3.21 or newer.
+* [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git).
+* [Java](https://java.com/en/download/) version 7 to 14.
+* [Python](https://www.python.org/downloads/) version 2.6+ or 3+.
+
+For Linux platforms:
+
+* Currently supported distributions include Debian 10 (Buster), Ubuntu 18 (Bionic Beaver), and related. Ubuntu 18.04 64-bit with GCC 7.5.0+ is recommended. Newer versions will likely also work but may not have been tested. Required packages include: build-essential, libgtk-3-dev.
+
+For MacOS platforms:
+
+* [Apache Ant](https://ant.apache.org/bindownload.cgi) is required to build the Java app bundle.
+* Java version newer than 8u121 is required.
+* Xcode 13.5 to 16.4 building on MacOS 12.0 (Monterey) or newer. The Xcode command-line tools must also be installed.
+
+For Windows platforms:
+
+* Visual Studio 2022 building on Windows 10 or newer. Windows 10/11 64-bit is recommended.
+
+## Building with Docker or GitHub Actions
+
+For a quick and easy build setup, you can run your builds on Docker (Linux/Windows) or use GitHub Actions (with Docker). The [jcefbuild repository on GitHub](https://github.com/jcefmaven/jcefbuild) can be forked and used to compile your own custom sources, providing one-line build scripts for each platform, Docker environments for Linux and Windows, as well as GitHub Actions workflows for all platforms. It also adds support for more build
+architectures (arm64 + arm/v6 on Linux, arm64 on Windows). For more information, visit the repository readme file.
+
+## Building Manually
+
+Building can also be performed as a series of manual steps.
+
+### Downloading Source Code
+
+Download JCEF source code using Git.
+
+```sh
+# The JCEF source code will exist at `/path/to/java-cef/src`
+cd /path/to/java-cef
+git clone https://github.com/chromiumembedded/java-cef.git src
+```
+
+### Building
+
+1\. Run CMake to generate platform-specific project files and then build the resulting native targets. See CMake output for any additional steps that may be necessary. For example, to generate a Release build of the `jcef` and `jcef_helper` targets:
+
+```sh
+# Enter the JCEF source code directory.
+cd /path/to/java-cef/src
+
+# Create and enter the `jcef_build` directory.
+# The `jcef_build` directory name is required by other JCEF tooling
+# and should not be changed.
+mkdir jcef_build && cd jcef_build
+
+# Linux: Generate 64-bit Unix Makefiles.
+cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release ..
+# Build using Make.
+make -j4
+
+# MacOS: Generate 64-bit Xcode project files.
+cmake -G "Xcode" -DPROJECT_ARCH="x86_64" ..
+# Open jcef.xcodeproj in Xcode
+# - Select Scheme > Edit Scheme and change the "Build Configuration" to "Release"
+# - Select Product > Build.
+
+# MacOS: Generate ARM64 Xcode project files.
+cmake -G "Xcode" -DPROJECT_ARCH="arm64" ..
+# Open jcef.xcodeproj in Xcode
+# - Select Scheme > Edit Scheme and change the "Build Configuration" to "Release"
+# - Select Product > Build.
+
+# Windows: Generate 64-bit VS2022 project files.
+cmake -G "Visual Studio 17" -A x64 ..
+# Open jcef.sln in Visual Studio
+# - Select Build > Configuration Manager and change the "Active solution configuration" to "Release"
+# - Select Build > Build Solution.
+```
+
+JCEF supports a number of different project formats via CMake including [Ninja](http://martine.github.io/ninja/). See comments in the top-level [CMakeLists.txt](https://github.com/chromiumembedded/java-cef/blob/master/CMakeLists.txt) file for additional CMake usage instructions.
+
+2\. On Windows and Linux build the JCEF Java classes using the _compile.[bat\|sh]_ tool.
+
+```sh
+cd /path/to/java-cef/src/tools
+compile.bat win64
+```
+
+On MacOS the JCEF Java classes are already built by the CMake project.
+
+3\. On Windows and Linux test that the resulting build works using the _run.[bat\|sh]_ tool. You can either run the simple example (see java/simple/MainFrame.java) or the detailed one (see java/detailed/MainFrame.java) by appending "detailed" or "simple" to the _run.[bat\|sh]_ tool. This example assumes that the "Release" configuration was built in step 1 and that you want to use the detailed example.
+
+```sh
+cd /path/to/java-cef/src/tools
+run.bat win64 Release detailed
+```
+
+On MacOS run jcef\_app for the detailed example. Either use the command-line or double-click on jcef\_app in Finder.
+
+```sh
+cd /path/to/java-cef/src/jcef_build/native/Release
+open jcef_app.app
+```
+
+### Packaging
+
+After building the Release configurations you can use the _make\_distrib.[bat\|sh]_ script to create a binary distribution.
+
+```sh
+cd /path/to/java-cef/src/tools
+make_distrib.bat win64
+```
+
+If the process succeeds a binary distribution package will be created in the /path/to/java-cef/src/binary\_distrib directory. See the README.txt file in that directory for usage instructions.
\ No newline at end of file
diff --git a/docs/building_openjdk.md b/docs/building_openjdk.md
new file mode 100644
index 00000000..721c3fbc
--- /dev/null
+++ b/docs/building_openjdk.md
@@ -0,0 +1,513 @@
+This page provides information about building OpenJDK locally for use in debugging JCEF.
+
+**Contents**
+
+- [Overview](#overview)
+- [OpenJDK on Windows](#openjdk-on-windows)
+  - [Install prerequisite software](#install-prerequisite-software)
+  - [Build Freetype2](#build-freetype2)
+  - [Setup MinGW](#setup-mingw)
+  - [Download OpenJDK sources](#download-openjdk-sources)
+  - [Patch OpenJDK sources](#patch-openjdk-sources)
+  - [Configure OpenJDK](#configure-openjdk)
+  - [Build OpenJDK](#build-openjdk)
+  - [Run JCEF with OpenJDK](#run-jcef-with-openjdk)
+- [OpenJDK on Linux](#openjdk-on-linux)
+  - [Mixed mode debugging with GDB](#mixed-mode-debugging-with-gdb)
+
+---
+
+# Overview
+
+[OpenJDK](http://openjdk.java.net/) is the open source project on which the Oracle JDK is based. Oracle does not provide debugging symbols for the JDK. Consequently it is necessary to build OpenJDK locally in order to debug issues that trace into JDK code. General instructions for building OpenJDK are available [here](http://hg.openjdk.java.net/build-infra/jdk8/raw-file/tip/README-builds.html), however it is recommended that you follow the below steps when building on Windows.
+
+# OpenJDK on Windows
+
+Building OpenJDK on Windows is a many-step process. Below are instructions for creating a 32-bit or 64-bit build of OpenJDK at version 8u60 on Windows 7 or newer using Visual Studio 2013.
+
+## Install prerequisite software
+
+OpenJDK requires the following software. Install all software at the default location.
+
+* Visual Studio 2013 Update 4 Professional. Other versions may work but are untested.
+* [Java 8 Development Kit](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html). Choose the architecture version that matches the desired OpenJDK build (e.g. choose the x64 version if creating a 64-bit OpenJDK build).
+* [Mercurial](https://www.mercurial-scm.org/wiki/Download).
+
+## Build Freetype2
+
+OpenJDK requires Freetype2 which should be built locally for best results [[*]](http://stackoverflow.com/questions/6207176/compiling-freetype-to-dll-as-opposed-to-static-library) [[*]](https://technfun.wordpress.com/2015/08/03/building-openjdk-8-for-windows-using-msys/).
+
+1\. Download Freetype2 source code in the 2.x series. For example, [freetype-2.6.2.tar.gz](http://sourceforge.net/projects/freetype/files/freetype2/2.6.2/).
+
+2\. Extract the archive contents to "C:\code\freetype-2.6.2-src"
+
+3\. Open Visual Studio 2013 and load the "C:\code\freetype-2.6.2-src\builds\windows\vc2010\freetype.sln" solution file.
+
+4\. Select Build > Configuration Manager from the top menu:
+
+* Change configuration to "Release".
+* Change platform to either "Win32" or "x64" to match the desired OpenJDK build.
+
+5\. Right click on the "freetype" solution, select Properties, and in the General tab:
+
+* Change Configuration Type to "Dynamic Library (.dll)".
+* Change Target Name to "freetype" (remove the version number).
+
+6\. Open the ftoption.h file and add the following lines near the "DLL export compilation" remarks section:
+
+```
+#define FT_EXPORT(x) __declspec(dllexport) x
+#define FT_BASE(x) __declspec(dllexport) x
+```
+
+7\. Build the project. You should now have "C:\code\freetype-2.6.2-src\objs\vc2010\[Win32\|x64]\freetype.[dll\|lib]" files.
+
+8\. Create a new "C:\code\freetype-2.6.2-src\lib" directory and copy the freetype.[dll\|lib] files into it.
+
+## Setup MinGW
+
+OpenJDK can be built using MinGW or Cygwin on Windows. This is how to setup the MinGW build environment.
+
+1\. Install MinGW using [mingw-get-setup.exe](http://sourceforge.net/projects/mingw/files/Installer/). Install to the default location (C:\MinGW).
+
+2\. Use the "C:\MinGW\bin\mingw-get.exe install <package>" command to install the following packages:
+
+* msys-autoconf
+* msys-base
+* msys-bsdcpio
+* msys-make
+* msys-mktemp
+* msys-unzip
+* msys-zip
+
+3\. Create a "C:\MinGW\msys\1.0\etc\fstab" file with the following contents:
+
+```
+#Win32_Path		Mount_Point
+c:/mingw		/mingw
+c:/		      /c
+```
+
+4\. Create a "C:\MinGW\msys\1.0\home\\[User]\\.profile" file ([User] is your Windows user name) with the following contents:
+
+```sh
+export PATH="$PATH:/C/Program Files/Mercurial"
+```
+
+5\. Run "C:\MinGW\msys\1.0\msys.bat" to enter the MinGW shell.
+
+## Download OpenJDK sources
+
+Run the following commands in the MinGW shell to download the OpenJDK source code for version 8u60.
+
+```sh
+cd /c/code
+hg clone http://hg.openjdk.java.net/jdk8u/jdk8u60/ openjdk8
+cd openjdk8
+bash ./get_source.sh
+```
+
+## Patch OpenJDK sources
+
+JDK version 8 does not officially support building with VS2013. However, the build should succeed if you apply the below patches. These patches resolve the following issues:
+
+* The cpio utility does not exist in MinGW. Change "cpio" to "bsdcpio" in basics.m4 [[*]](https://bugs.openjdk.java.net/browse/JDK-8022177).
+* MinGW installs autoconf 2.68. Change the version requirement in configure.ac [[*]](https://technfun.wordpress.com/2015/08/03/building-openjdk-8-for-windows-using-msys/).
+* Configure cannot find msvcr100.dll with correct architecture. Fix the logic in toolchain_windows.m4 [[*]](http://cr.openjdk.java.net/~simonis/webrevs/8022177/).
+* ad_x86_64_misc.obj : error LNK2011: precompiled object not linked in. Fix compile.make and vm.make to link against _build_pch_file.obj [[*]](https://bugs.openjdk.java.net/browse/JDK-8043492).
+* LNK2038: mismatch detected for 'RuntimeLibrary'. Remove _STATIC_CPPLIB defines in toolchain.m4 [[*]](http://hg.openjdk.java.net/jdk9/client/rev/39ee0ee4f890).
+* The make command hangs during the build process. Disable multiple jobs in spec.gmk.in [[*]](https://bugs.openjdk.java.net/browse/JDK-8022177).
+* The value "IMVERSION" of attribute "version" in element "assemblyIdentity" is invalid (SxS manifest issue). Add a version number to java.manifest [[*]](https://bugs.openjdk.java.net/browse/JDK-8128079).
+
+```
+--- common/autoconf/basics.m4  Thu Jan 28 18:46:45 2016
++++ common/autoconf/basics.m4  Thu Jan 28 16:44:34 2016
+@@ -279,7 +279,7 @@
+   BASIC_REQUIRE_PROG(CMP, cmp)
+   BASIC_REQUIRE_PROG(COMM, comm)
+   BASIC_REQUIRE_PROG(CP, cp)
+-  BASIC_REQUIRE_PROG(CPIO, cpio)
++  BASIC_REQUIRE_PROG(CPIO, bsdcpio)
+   BASIC_REQUIRE_PROG(CUT, cut)
+   BASIC_REQUIRE_PROG(DATE, date)
+   BASIC_REQUIRE_PROG(DIFF, [gdiff diff])
+
+--- common/autoconf/configure.ac   Thu Jan 28 18:46:37 2016
++++ common/autoconf/configure.ac   Thu Jan 28 16:44:53 2016
+@@ -30,7 +30,7 @@
+ ###############################################################################
+
+
+-AC_PREREQ([2.69])
++AC_PREREQ([2.68])
+ AC_INIT(OpenJDK, jdk8, build-dev@openjdk.java.net,,http://openjdk.java.net)
+
+ AC_CONFIG_AUX_DIR([build-aux])
+
+--- common/autoconf/toolchain_windows.m4   Thu Jan 28 18:46:29 2016
++++ common/autoconf/toolchain_windows.m4   Thu Jan 28 16:46:42 2016
+@@ -240,12 +240,22 @@
+     # Need to check if the found msvcr is correct architecture
+     AC_MSG_CHECKING([found msvcr100.dll architecture])
+     MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
++    if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
++      # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
++      # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
++      if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
++        CORRECT_MSVCR_ARCH="PE32 executable"
++      else
++        CORRECT_MSVCR_ARCH="PE32+ executable"
++      fi
++    else
+     if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+       CORRECT_MSVCR_ARCH=386
+     else
+       CORRECT_MSVCR_ARCH=x86-64
+     fi
+-    if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP $CORRECT_MSVCR_ARCH 2>&1 > /dev/null; then
++    fi
++    if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+       AC_MSG_RESULT([ok])
+       MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
+       AC_MSG_CHECKING([for msvcr100.dll])
+
+--- hotspot/make/windows/makefiles/vm.make Thu Jan 28 18:46:14 2016
++++ hotspot/make/windows/makefiles/vm.make     Thu Jan 28 17:00:04 2016
+@@ -128,8 +128,8 @@
+
+ !if "$(USE_PRECOMPILED_HEADER)" != "0"
+ CXX_USE_PCH=/Fp"vm.pch" /Yu"precompiled.hpp"
+-!if "$(COMPILER_NAME)" == "VS2012"
+-# VS2012 requires this object file to be listed:
++!if "$(COMPILER_NAME)" == "VS2012" || "$(COMPILER_NAME)" == "VS2013"
++# VS2012 and VS2013 require this object file to be listed:
+ LD_FLAGS=$(LD_FLAGS) _build_pch_file.obj
+ !endif
+ !else
+
+--- hotspot/make/windows/makefiles/compile.make    Thu Jan 28 18:46:06 2016
++++ hotspot/make/windows/makefiles/compile.make    Thu Jan 28 17:07:44 2016
+@@ -147,6 +147,9 @@
+ !if "$(MSC_VER)" == "1700"
+ COMPILER_NAME=VS2012
+ !endif
++!if "$(MSC_VER)" == "1800"
++COMPILER_NAME=VS2013
++!endif
+ !endif
+
+ # By default, we do not want to use the debug version of the msvcrt.dll file
+
+--- common/autoconf/toolchain.m4   Thu Jan 28 18:45:57 2016
++++ common/autoconf/toolchain.m4   Thu Jan 28 17:54:04 2016
+@@ -998,7 +998,7 @@
+       ;;
+     cl )
+       CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
+-      -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
++      -DWIN32_LEAN_AND_MEAN \
+       -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
+       -DWIN32 -DIAL"
+       case $OPENJDK_TARGET_CPU in
+
+--- common/autoconf/spec.gmk.in    Thu Jan 28 18:45:47 2016
++++ common/autoconf/spec.gmk.in    Thu Jan 28 17:57:06 2016
+@@ -267,7 +267,7 @@
+ SJAVAC_SERVER_DIR:=@SJAVAC_SERVER_DIR@
+
+ # Number of parallel jobs to use for compilation
+-JOBS?=@JOBS@
++JOBS?=1
+
+ FREETYPE_LIBS:=@FREETYPE_LIBS@
+ FREETYPE_CFLAGS:=@FREETYPE_CFLAGS@
+
+--- jdk/src/windows/resource/java.manifest  Thu Jan 28 18:45:19 2016
++++ jdk/src/windows/resource/java.manifest  Thu Jan 28 18:36:40 2016
+@@ -4,7 +4,7 @@
+           xmlns:asmv3="urn:schemas-microsoft-com:asm.v3"
+ >
+ <assemblyIdentity
+-    version="IMVERSION"
++    version="8.0.60.0"
+     processorArchitecture="X86"
+     name="Oracle Corporation, Java(tm) 2 Standard Edition"
+     type="win32"
+
+```
+
+## Configure OpenJDK
+
+Run the following commands in the MinGW shell to configure OpenJDK. If you installed all of the required packages and applied the above patches correctly the configure command should succeed. If you experience errors then debug the problem before proceeding further.
+
+To disable all optimizations in the debug build use `--with-debug-level=slowdebug` instead of `--enable-debug` on the configure line. The resulting folder will then be `windows-*-normal-server-slowdebug` instead of `windows-*-normal-server-fastdebug`.
+
+```sh
+cd /c/code/openjdk8
+
+# OpenJDK expects the "VS100COMNTOOLS" variable which is set by the VS2010 install.
+# Set it to use the VS2013 install instead.
+export VS100COMNTOOLS=$VS120COMNTOOLS
+
+# Don't compress symbol files into .diz ("debug info zip") files.
+export ZIP_DEBUGINFO_FILES=0
+
+# 32-bit build.
+# Explicitly specify the 32-bit boot JDK path and increase the Java memory limit.
+bash ./configure --enable-debug --with-target-bits=32 –-with-freetype=/c/code/freetype-2.6.2-src -with-boot-jdk=/c/Program\ Files\ \(x86\)/Java/jdk1.8.0_66/ --with-boot-jdk-jvmargs="-Xmx6G -enableassertions"
+
+# 64-bit build.
+bash ./configure --enable-debug --with-target-bits=64 –-with-freetype=/c/code/freetype-2.6.2-src
+```
+
+## Build OpenJDK
+
+Run the following commands in the MinGW shell to build OpenJDK. VS2013 doesn't create .manifest files so adding MT= disables running of the mt.exe tool. The build should take approximately 20 minutes on a fast machine. The resulting JDK will be output to "C:\code\openjdk8\build\windows-x86_64-normal-server-fastdebug\images\j2sdk-image" (or the 32-bit path as appropriate).
+
+```sh
+cd /c/code/openjdk8
+
+make all MT=
+```
+
+## Run JCEF with OpenJDK
+
+To use the resulting JDK build with JCEF follow these steps.
+
+1\. Create a Debug build of JCEF as described on the [Branches And Building](branches_and_building.md) page.
+
+2\. Download Debug Symbols for the CEF version from <https://cef-builds.spotifycdn.com/index.html> and extract libcef.dll.pdb to "src\jcef_build\native\Debug".
+
+3\. Edit JCEF's "src\tools\run.bat" script. Replace the "java" command with "C:\code\openjdk8\build\windows-x86_64-normal-server-fastdebug\jdk\bin\java" (or the 32-bit path as appropriate).
+
+4\. Run the script:
+
+```
+run.bat win64 Debug detailed
+```
+
+5\. Open Visual Studio 2013 and load the "src\jcef_build\jcef.sln" solution file.
+
+6\. Select Debug > Attach to process.. from the top menu and choose the "java.exe" process.
+
+7\. Wait for the application to crash. Get a call stack with debug symbols like [this](https://github.com/chromiumembedded/java-cef/issues/157).
+
+8\. To delay Java startup long enough to attach the debugger add the following code at the top of the `main(String [] args)` method in "src\java\tests\detailed\MainFrame.java":
+
+```
+try { Thread.sleep(10000); /* delay 10 seconds */ } catch(InterruptedException e) {}
+```
+
+# OpenJDK on Linux
+
+Issues on Linux can be diagnosed using a local debug build of OpenJDK based on [these instructions](http://cr.openjdk.java.net/~ihse/demo-new-build-readme/common/doc/building.html#getting-the-source-code). You will need to build JDK8 on an Ubuntu 14.04 machine because a 3.x series kernel is required by the build configuration.
+
+```sh
+# Install dependencies
+> sudo apt-get update --fix-missing
+> sudo apt-get install build-essential mercurial openjdk-7-jdk libx11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev libelf-dev libffi-dev libcups2-dev
+# Download source code
+> hg clone http://hg.openjdk.java.net/jdk8/jdk8
+> cd jdk8
+> bash get_source.sh
+# Configure
+> bash configure --enable-debug --disable-zip-debug-info --disable-ccache
+# Build
+> make images
+# Test that it runs
+> ./build/linux-x86_64-normal-server-fastdebug/jdk/bin/java -version
+```
+
+For GDB to successfully load OpenJDK debug symbols you need to run using the binaries in the ./build/linux-x86_64-normal-server-fastdebug/jdk/bin directory (where the *.debuginfo files exist). For example, by setting the following environment variables:
+
+```sh
+export JAVA_HOME=/home/marshall/code/openjdk/jdk8/build/linux-x86_64-normal-server-fastdebug/jdk  
+export PATH=/home/marshall/code/openjdk/jdk8/build/linux-x86_64-normal-server-fastdebug/jdk/bin:$PATH
+```
+
+## Mixed mode debugging with GDB
+
+[This link](http://progdoc.de/papers/Joker2014/joker2014.html#(5)) describes how to get mixed native and Java stack traces using GDB. It's also useful to add System.out.println messages to code under the jdk/src directory and re-build.
+
+Here's a patch that launches the JCEF sample apps using GDB and Java debug settings:
+
+```
+diff --git tools/run.sh tools/run.sh
+index 1a58940..466afdb 100755
+--- tools/run.sh
++++ tools/run.sh
+@@ -32,7 +32,7 @@ else
+     shift
+     shift
+ 
+-    LD_PRELOAD=$LIB_PATH/libcef.so java -cp "$CLS_PATH" -Djava.library.path=$LIB_PATH tests.$RUN_TYPE.MainFrame "$@"
++    LD_PRELOAD=$LIB_PATH/libcef.so gdb --args java -Dsun.awt.disablegrab=true -Xdebug -Xint -cp "$CLS_PATH" -Djava.library.path=$LIB_PATH tests.$RUN_TYPE.MainFrame "$@"
+   fi
+ fi
+ 
+```
+
+Here's a patch that adds a CefApp.debugBreak() method that can be used to trigger a native breakpoint from Java code:
+
+```cpp
+diff --git java/org/cef/CefApp.java java/org/cef/CefApp.java
+index 4545c68..a7135f2 100644
+--- java/org/cef/CefApp.java
++++ java/org/cef/CefApp.java
+@@ -543,6 +543,14 @@ public class CefApp extends CefAppHandlerAdapter {
+         return library_path;
+     }
+ 
++    /**
++     * Trigger a breakpoint in the native debugger.
++     */
++    public static final void debugBreak() {
++        N_DebugBreak();
++    }
++
++    private final static native void N_DebugBreak();
+     private final static native boolean N_Startup();
+     private final native boolean N_PreInitialize();
+     private final native boolean N_Initialize(
+diff --git native/CefApp.cpp native/CefApp.cpp
+index 39a14d8..0f61a1c 100644
+--- native/CefApp.cpp
++++ native/CefApp.cpp
+@@ -6,6 +6,7 @@
+ 
+ #include <string>
+ 
++#include "include/base/cef_logging.h"
+ #include "include/cef_app.h"
+ #include "include/cef_version.h"
+ 
+@@ -104,3 +105,8 @@ JNIEXPORT jboolean JNICALL Java_org_cef_CefApp_N_1Startup(JNIEnv*, jclass) {
+ #endif  // defined(OS_MACOSX)
+   return JNI_TRUE;
+ }
++
++JNIEXPORT void JNICALL Java_org_cef_CefApp_N_1DebugBreak(JNIEnv*, jclass) {
++  DCHECK(false) << "CefApp.DebugBreak";
++}
++
+diff --git native/CefApp.h native/CefApp.h
+index bf1c1ef..081ffd8 100644
+--- native/CefApp.h
++++ native/CefApp.h
+@@ -74,6 +74,13 @@ Java_org_cef_CefApp_N_1ClearSchemeHandlerFactories(JNIEnv*, jobject);
+  */
+ JNIEXPORT jboolean JNICALL Java_org_cef_CefApp_N_1Startup(JNIEnv*, jclass);
+ 
++/*
++ * Class:     org_cef_CefApp
++ * Method:    N_DebugBreak
++ * Signature: ()V
++ */
++JNIEXPORT void JNICALL Java_org_cef_CefApp_N_1DebugBreak(JNIEnv*, jclass);
++
+ #ifdef __cplusplus
+ }
+ #endif
+```
+
+Example GDB usage in combination with the above patches:
+
+```sh
+$ ./run.sh linux64 Debug detailed
+(gdb) r
+
+0x00007ffff2736a07 in operator() () at ../../base/logging.cc:874
+874	../../base/logging.cc: No such file or directory.
+(gdb) bt
+#0  0x00007ffff2736a07 in operator() () at ../../base/logging.cc:874
+#1  ~LogMessage () at ../../base/logging.cc:874
+#2  0x00007ffff2627b6b in cef_log () at ../../cef/libcef/common/base_impl.cc:333
+#3  0x00007fffc4d151e5 in cef::logging::LogMessage::~LogMessage (this=0x7fffc41b2470, __in_chrg=<optimized out>)
+    at /home/marshall/code/java-cef/src/third_party/cef/cef_binary_3.3626.1883.g00e6af4_linux64/libcef_dll/base/cef_logging.cc:187
+#4  0x00007fffc4cc62bd in Java_org_cef_CefApp_N_1DebugBreak () at /home/marshall/code/java-cef/src/native/CefApp.cpp:110
+#5  0x00007fffcd0262e7 in ?? ()
+#6  0x00007fffdc38d000 in ?? ()
+#7  0x00007fffc41b2618 in ?? ()
+#8  0x00007fffe0a1c298 in ?? ()
+#9  0x00007fffc41b2670 in ?? ()
+#10 0x00007fffe0a1e230 in ?? ()
+#11 0x0000000000000000 in ?? ()
+
+(gdb) call help()
+
+"Executing help"
+basic
+  pp(void* p)   - try to make sense of p
+  pv(intptr_t p)- ((PrintableResourceObj*) p)->print()
+  ps()          - print current thread stack
+  pss()         - print all thread stacks
+  pm(int pc)    - print Method* given compiled PC
+  findm(intptr_t pc) - finds Method*
+  find(intptr_t x)   - finds & prints nmethod/stub/bytecode/oop based on pointer into it
+misc.
+  flush()       - flushes the log file
+  events()      - dump events from ring buffers
+compiler debugging
+  debug()       - to set things up for compiler debugging
+  ndebug()      - undo debug
+
+(gdb) call ps()
+
+"Executing ps"
+ for thread: "AWT-EventQueue-0" #9 prio=6 os_prio=0 tid=0x00007fffdc38d000 nid=0xb818 runnable [0x00007fffc41b2000]
+   java.lang.Thread.State: RUNNABLE
+   JavaThread state: _thread_in_native
+Thread: 0x00007fffdc38d000  [0xb818] State: _running _has_called_back 0 _at_poll_safepoint 0
+   JavaThread state: _thread_in_native
+
+ 1 - frame( sp=0x00007fffc41b2610, unextended_sp=0x00007fffc41b2610, fp=0x00007fffc41b2658, pc=0x00007fffcd026233)
+org.cef.CefApp.N_DebugBreak(Native Method)
+ 2 - frame( sp=0x00007fffc41b2668, unextended_sp=0x00007fffc41b2678, fp=0x00007fffc41b26b8, pc=0x00007fffcd007500)
+[Thread 0x7fff527fc700 (LWP 47146) exited]
+org.cef.CefApp.debugBreak(CefApp.java:550)
+ 3 - frame( sp=0x00007fffc41b26c8, unextended_sp=0x00007fffc41b26c8, fp=0x00007fffc41b2708, pc=0x00007fffcd007500)
+tests.simple.MainFrame$6.windowDeactivated(MainFrame.java:188)
+ 4 - frame( sp=0x00007fffc41b2718, unextended_sp=0x00007fffc41b2718, fp=0x00007fffc41b2768, pc=0x00007fffcd007545)
+java.awt.AWTEventMulticaster.windowDeactivated(AWTEventMulticaster.java:399)
+ 5 - frame( sp=0x00007fffc41b2778, unextended_sp=0x00007fffc41b2778, fp=0x00007fffc41b27c8, pc=0x00007fffcd007545)
+java.awt.AWTEventMulticaster.windowDeactivated(AWTEventMulticaster.java:399)
+ 6 - frame( sp=0x00007fffc41b27d8, unextended_sp=0x00007fffc41b27d8, fp=0x00007fffc41b2828, pc=0x00007fffcd007545)
+java.awt.Window.processWindowEvent(Window.java:2073)
+ 7 - frame( sp=0x00007fffc41b2838, unextended_sp=0x00007fffc41b2840, fp=0x00007fffc41b2890, pc=0x00007fffcd007500)
+javax.swing.JFrame.processWindowEvent(JFrame.java:297)
+ 8 - frame( sp=0x00007fffc41b28a0, unextended_sp=0x00007fffc41b28a0, fp=0x00007fffc41b28f0, pc=0x00007fffcd007500)
+java.awt.Window.processEvent(Window.java:2017)
+ 9 - frame( sp=0x00007fffc41b2900, unextended_sp=0x00007fffc41b2900, fp=0x00007fffc41b2950, pc=0x00007fffcd007500)
+java.awt.Component.dispatchEventImpl(Component.java:4883)
+10 - frame( sp=0x00007fffc41b2960, unextended_sp=0x00007fffc41b2990, fp=0x00007fffc41b29e0, pc=0x00007fffcd007500)
+java.awt.Container.dispatchEventImpl(Container.java:2292)
+11 - frame( sp=0x00007fffc41b29f0, unextended_sp=0x00007fffc41b2a00, fp=0x00007fffc41b2a50, pc=0x00007fffcd007500)
+java.awt.Window.dispatchEventImpl(Window.java:2739)
+12 - frame( sp=0x00007fffc41b2a60, unextended_sp=0x00007fffc41b2a60, fp=0x00007fffc41b2ab0, pc=0x00007fffcd007500)
+java.awt.Component.dispatchEvent(Component.java:4705)
+13 - frame( sp=0x00007fffc41b2ac0, unextended_sp=0x00007fffc41b2ac0, fp=0x00007fffc41b2b10, pc=0x00007fffcd007500)
+java.awt.KeyboardFocusManager.redispatchEvent(KeyboardFocusManager.java:1954)
+14 - frame( sp=0x00007fffc41b2b20, unextended_sp=0x00007fffc41b2b20, fp=0x00007fffc41b2b78, pc=0x00007fffcd007500)
+java.awt.DefaultKeyboardFocusManager.typeAheadAssertions(DefaultKeyboardFocusManager.java:995)
+15 - frame( sp=0x00007fffc41b2b88, unextended_sp=0x00007fffc41b2bb0, fp=0x00007fffc41b2c08, pc=0x00007fffcd006e80)
+java.awt.DefaultKeyboardFocusManager.dispatchEvent(DefaultKeyboardFocusManager.java:685)
+16 - frame( sp=0x00007fffc41b2c18, unextended_sp=0x00007fffc41b2c60, fp=0x00007fffc41b2cb0, pc=0x00007fffcd006e80)
+java.awt.Component.dispatchEventImpl(Component.java:4754)
+17 - frame( sp=0x00007fffc41b2cc0, unextended_sp=0x00007fffc41b2cf0, fp=0x00007fffc41b2d40, pc=0x00007fffcd007500)
+java.awt.Container.dispatchEventImpl(Container.java:2292)
+18 - frame( sp=0x00007fffc41b2d50, unextended_sp=0x00007fffc41b2d60, fp=0x00007fffc41b2db0, pc=0x00007fffcd007500)
+java.awt.Window.dispatchEventImpl(Window.java:2739)
+19 - frame( sp=0x00007fffc41b2dc0, unextended_sp=0x00007fffc41b2dc0, fp=0x00007fffc41b2e10, pc=0x00007fffcd007500)
+java.awt.Component.dispatchEvent(Component.java:4705)
+20 - frame( sp=0x00007fffc41b2e20, unextended_sp=0x00007fffc41b2e20, fp=0x00007fffc41b2e70, pc=0x00007fffcd007500)
+java.awt.EventQueue.dispatchEventImpl(EventQueue.java:746)
+21 - frame( sp=0x00007fffc41b2e80, unextended_sp=0x00007fffc41b2e80, fp=0x00007fffc41b2ed8, pc=0x00007fffcd007500)
+java.awt.EventQueue.access$400(EventQueue.java:97)
+22 - frame( sp=0x00007fffc41b2ee8, unextended_sp=0x00007fffc41b2ee8, fp=0x00007fffc41b2f40, pc=0x00007fffcd007500)
+java.awt.EventQueue$3.run(EventQueue.java:697)
+23 - frame( sp=0x00007fffc41b2f50, unextended_sp=0x00007fffc41b2f50, fp=0x00007fffc41b2f98, pc=0x00007fffcd007430)
+java.awt.EventQueue$3.run(EventQueue.java:691)
+C frame (sp=0x00007fffc41b2fa8 unextended sp=0x00007fffc41b2fa8, fp=0x00007fffc41b3010, real_fp=0x00007fffc41b3010, pc=0x00007fffcd000671)
+(~Stub::call_stub)
+     BufferBlob (0x00007fffcd0003d0) used for StubRoutines (1)
+```
\ No newline at end of file
diff --git a/docs/contributing_with_git.md b/docs/contributing_with_git.md
new file mode 100644
index 00000000..3de958af
--- /dev/null
+++ b/docs/contributing_with_git.md
@@ -0,0 +1,234 @@
+This page provides information about using Git to contribute code changes to JCEF.
+
+**Contents**
+
+- [Overview](#overview)
+- [Initial Setup](#initial-setup)
+- [Working With Private Changes](#working-with-private-changes)
+  - [Creating a Branch](#creating-a-branch)
+  - [Creating a Commit](#creating-a-commit)
+  - [Modifying a Commit](#modifying-a-commit)
+  - [Rebasing on Upstream Changes](#rebasing-on-upstream-changes)
+  - [Deleting a Branch](#deleting-a-branch)
+  - [Cleaning a Checkout](#cleaning-a-checkout)
+- [Working With Pull Requests](#working-with-pull-requests)
+  - [Coding Style](#coding-style)
+  - [Creating a Pull Request](#creating-a-pull-request)
+  - [Reviewing a Pull Request](#reviewing-a-pull-request)
+
+---
+
+# Overview
+
+The JCEF project uses the Git source code management system hosted via GitHub. The easiest way to contribute changes to JCEF is by creating your own personal fork of the JCEF Git repository and submitting pull requests with your proposed modifications. This document is intended as a quick-start guide for developers who already have some familiarity with Git. If you are completely new to Git you might want to review the series of [Git tutorials](https://docs.github.com/en/get-started/getting-started-with-git) provided by GitHub.
+
+# Initial Setup
+
+Git can maintain your changes both locally and on a remote server. To work with Git efficiently the remote server locations must be configured properly.
+
+1\. Log into GitHub and create a forked version of the java-cef repository using the Fork button at <https://github.com/chromiumembedded/java-cef>.
+
+2\. Check out JCEF source code as described on the [Branches And Building](branches_and_building.md) page.
+
+3\. Change the remote origin of the JCEF checkout so that it points to your personal forked repository. This is the remote server location that the `git push` and `git pull` commands will operate on by default.
+
+```sh
+cd /path/to/java-cef
+
+# Replace <UserName> with your GitHub user name.
+git remote set-url origin https://github.com/<UserName>/java-cef.git
+```
+
+4\. Set the remote upstream of the JCEF checkout so that you can merge changes from the main JCEF repository.
+
+```sh
+git remote add upstream https://github.com/chromiumembedded/java-cef.git
+```
+
+5\. Verify that the remotes are configured correctly.
+
+```sh
+git remote -v
+```
+
+You should see output like the following:
+
+```
+origin    https://github.com/<UserName>/java-cef.git (fetch)
+origin    https://github.com/<UserName>/java-cef.git (push)
+upstream    https://github.com/chromiumembedded/java-cef.git (fetch)
+upstream    https://github.com/chromiumembedded/java-cef.git (push)
+```
+
+6\. Configure your name and email address.
+
+```sh
+git config user.name "User Name"
+git config user.email user@example.com
+```
+
+7\. Configure the correct handling of line endings in the repository.
+
+```sh
+# Use this value on Windows. Files will be converted to CRLF line endings
+# in the working directory and LF line endings in the object database.
+git config core.autocrlf true
+
+# Use this value on other platforms. Files will be unchanged in the working
+# directory and converted to LF line endings in the object database.
+git config core.autocrlf input
+
+# Cause Git to abort actions on files with mixed line endings if the change is
+# not reversible (e.g. changes to binary files that are accidentally classified
+# as text).
+git config core.safecrlf true
+```
+
+# Working With Private Changes
+
+You can now commit changes to your personal repository and merge upstream changes from the main JCEF repository. To facilitate creation of a pull request or the sharing of your code changes with other developers you should make your changes in a branch.
+
+## Creating a Branch
+
+Create a new personal branch for your changes.
+
+```sh
+# Start with the branch that your changes will be based upon.
+git checkout master
+
+# Create a new personal branch for your changes.
+# Replace <BranchName> with your new branch name.
+git checkout -b <BranchName>
+```
+
+## Creating a Commit
+
+After making local modifications you can commit them to your personal branch.
+
+```sh
+# For example, add a specified file by path.
+git add path/to/file.txt
+
+# For example, add all existing files that have been modified or deleted.
+git add -u
+
+# Commit the modifications locally.
+git commit -m "A good description of the fix (issue #1234)"
+
+# Push the modifications to your personal remote repository.
+git push origin <BranchName>
+```
+
+## Modifying a Commit
+
+You can also modify an existing commit if you need to make additional changes.
+
+```sh
+# For example, add all existing files that have been modified or deleted.
+git add -u
+
+# Update the current HEAD commit with the changes.
+git commit --amend
+
+# Push the modifications to your personal remote repository.
+# Using the `--force` argument is not recommended if multiple people are sharing the
+# same branch.
+git push origin <BranchName> --force
+```
+
+## Rebasing on Upstream Changes
+
+The main JCEF repository will receive additional commits over time. You will want to include these changes in your personal repository. To keep Git history correct (showing upstream JCEF commits on the JCEF branch instead of on your personal branch) you will need to rebase the local JCEF branch before rebasing your local personal branch.
+
+```sh
+# Fetch changes from the main JCEF repository. This does not apply them to any
+# particular branch.
+git fetch upstream
+
+# Check out the local JCEF branch that tracks the upstream JCEF branch.
+git checkout master
+
+# Rebase your local JCEF branch on top of the upstream JCEF branch.
+# After this command your local JCEF branch should be identical to the upstream JCEF branch.
+git rebase upstream/master
+
+# Check out the personal branch that you want to update with changes from the JCEF branch.
+# Replace <BranchName> with the name of your branch.
+git checkout <BranchName>
+
+# Rebase your personal branch on top of the local JCEF branch.
+# After this command your local commits will come after all JCEF commits on the same branch.
+git rebase master
+
+# Push the modifications to your personal remote repository.
+git push origin <BranchName>
+```
+
+You may get merge conflicts if your personal changes conflict with changes made to the main JCEF repository. For instructions on resolving merge conflicts see [this article](https://help.github.com/articles/resolving-merge-conflicts-after-a-git-rebase/).
+
+For more information on using the rebase command go [here](https://www.atlassian.com/git/tutorials/merging-vs-rebasing).
+
+## Deleting a Branch
+
+Once you no longer need a branch you can delete it both locally and remotely. Do not delete branches that are associated with open pull requests.
+
+```sh
+# Delete the branch locally.
+git branch -D <BranchName>
+
+# Delete the branch remotely.
+git push origin --delete <BranchName>
+```
+
+## Cleaning a Checkout
+
+You can remove all local changes from your checkout using the below commands.
+
+```sh
+# Check the current state of the repository before deleting anything.
+git status
+
+# Remove all non-committed files and directories from the local checkout.
+git clean -dffx
+
+# Remove all local commits from the current branch and reset branch state to match
+# origin/master. Replace "origin/master" with a different remote branch name as appropriate.
+git reset --hard origin/master
+```
+
+# Working With Pull Requests
+
+Once your personal changes are complete you can request that they be merged into the main JCEF repository. This is done using a pull request. Before submitting a pull request you should:
+
+* Rebase your changes on the upstream JCEF branch (see "Rebasing on Upstream Changes").
+* Fix any coding style issues (see "Coding Style").
+* Find or create an appropriate issue in the [JCEF issue tracker](https://github.com/chromiumembedded/java-cef/issues). Make sure the issue number is referenced in your commit description.
+* Include new or modified unit tests as appropriate to the functionality.
+* Remove unnecessary or unrelated changes.
+
+## Coding Style
+
+JCEF uses the [Chromium coding style](https://chromium.googlesource.com/chromium/src/+/master/styleguide/styleguide.md). Changes to files should match the existing style in that file.
+
+## Creating a Pull Request
+
+Pull requests can only be created from a public repository that was [forked](https://docs.github.com/articles/fork-a-repo) using the GitHub interface. Push your branch to your fork and then create the pull request as described [here](https://docs.github.com/articles/creating-a-pull-request-from-a-fork). Pull requests will only be accepted if they meet the requirements described above.
+
+```sh
+# Push your branch to your fork for PR submission.
+git push origin <BranchName>
+```
+
+## Reviewing a Pull Request
+
+Your pull request will be reviewed by one or more JCEF developers. Please address any comments and update your pull request. The easiest way to update a pull request is by pushing new commits to the same branch -- those new commits will be automatically reflected in the pull request. Once your changes are deemed acceptable they will be squashed and merged into the main JCEF repository.
+
+The contents of a pull request can also be downloaded as a patch file and applied to your local Git checkout:
+
+```sh
+# Download the patch file (replace {pull_no} with the PR number).
+curl -L https://github.com/chromiumembedded/java-cef/pull/{pull_no}.diff -o name.patch
+
+# Apply the patch file to your local Git checkout.
+git apply name.patch
+```
diff --git a/java/org/cef/CefSettings.java b/java/org/cef/CefSettings.java
index 83bb1fcc..e956cce1 100644
--- a/java/org/cef/CefSettings.java
+++ b/java/org/cef/CefSettings.java
@@ -219,6 +219,21 @@ public ColorType clone() {
      */
     public int remote_debugging_port = 0;
 
+    /**
+     * Specify an ID to enable Chrome policy management via Platform and OS-user
+     * policies. On Windows, this is a registry key like
+     * "SOFTWARE\\Policies\\Google\\Chrome". On MacOS, this is a bundle ID like
+     * "com.google.Chrome". On Linux, this is an absolute directory path like
+     * "/etc/opt/chrome/policies". Only supported with Chrome style. See
+     * https://support.google.com/chrome/a/answer/9037717 for details.
+     *
+     * Chrome Browser Cloud Management integration, when enabled via the
+     * "enable-chrome-browser-cloud-management" command-line flag, will also use
+     * the specified ID. See https://support.google.com/chrome/a/answer/9116814
+     * for details.
+     */
+    public String chrome_policy_id;
+
     /**
      * The number of stack trace frames to capture for uncaught exceptions.
      * Specify a positive value to enable the CefV8ContextHandler::
@@ -270,6 +285,7 @@ public CefSettings clone() {
         tmp.resources_dir_path = resources_dir_path;
         tmp.locales_dir_path = locales_dir_path;
         tmp.remote_debugging_port = remote_debugging_port;
+        tmp.chrome_policy_id = chrome_policy_id;
         tmp.uncaught_exception_stack_size = uncaught_exception_stack_size;
         if (background_color != null) tmp.background_color = background_color.clone();
         tmp.cookieable_schemes_list = cookieable_schemes_list;
diff --git a/java/org/cef/browser/CefBrowser.java b/java/org/cef/browser/CefBrowser.java
index 96f8e1ab..0ba05b48 100644
--- a/java/org/cef/browser/CefBrowser.java
+++ b/java/org/cef/browser/CefBrowser.java
@@ -49,6 +49,13 @@ public interface CefBrowser {
      */
     public CefRenderHandler getRenderHandler();
 
+    /**
+     * Retrieves the request context used by this browser instance. May be the
+     * global request context if this browser does not have a specific request
+     * context.
+     */
+    public CefRequestContext getRequestContext();
+
     /**
      * Get an implementation of CefWindowHandler if any.
      * @return An instance of CefWindowHandler or null.
diff --git a/java/org/cef/browser/CefBrowser_N.java b/java/org/cef/browser/CefBrowser_N.java
index e46327f1..c89e2968 100644
--- a/java/org/cef/browser/CefBrowser_N.java
+++ b/java/org/cef/browser/CefBrowser_N.java
@@ -68,8 +68,9 @@ protected String getUrl() {
         return url_;
     }
 
-    protected CefRequestContext getRequestContext() {
-        return request_context_;
+    @Override
+    public CefRequestContext getRequestContext() {
+        return request_context_ != null ? request_context_ : CefRequestContext.getGlobalContext();
     }
 
     protected CefBrowser_N getParentBrowser() {
diff --git a/java/org/cef/browser/CefDevToolsClient.java b/java/org/cef/browser/CefDevToolsClient.java
index ee119469..3fed09f5 100644
--- a/java/org/cef/browser/CefDevToolsClient.java
+++ b/java/org/cef/browser/CefDevToolsClient.java
@@ -36,6 +36,7 @@ public void onDevToolsMethodResult(
                     future.completeExceptionally(
                             new DevToolsException("DevTools method failed", result));
                 }
+                removeQueuedCommand(messageId);
             }
 
             @Override
@@ -62,6 +63,10 @@ private CompletableFuture<String> getQueuedCommand(Integer messageId) {
         return queuedCommands_.computeIfAbsent(messageId, key -> new CompletableFuture<>());
     }
 
+    private void removeQueuedCommand(Integer messageId) {
+        queuedCommands_.remove(messageId);
+    }
+
     /**
      * Execute a method call over the DevTools protocol. See the <a
      * href=https://chromedevtools.github.io/devtools-protocol/> DevTools protocol documentation</a>
diff --git a/java/org/cef/browser/CefRequestContext.java b/java/org/cef/browser/CefRequestContext.java
index 26fa66aa..38ccef04 100644
--- a/java/org/cef/browser/CefRequestContext.java
+++ b/java/org/cef/browser/CefRequestContext.java
@@ -6,6 +6,9 @@
 
 import org.cef.handler.CefRequestContextHandler;
 
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * A request context provides request handling for a set of related browser
  * objects. A request context is specified when creating a new browser object
@@ -50,4 +53,48 @@ public static final CefRequestContext createContext(CefRequestContextHandler han
      * Returns the handler for this context if any.
      */
     public abstract CefRequestContextHandler getHandler();
+
+    /**
+     * Returns true if a preference with the specified |name| exists.
+     * <p>
+     * This method must be called on the browser process UI thread, otherwise it will always return
+     * false. It is easiest to ensure the correct calling thread by using a callback method invoked
+     * by the browser process UI thread, such as CefLifeSpanHandler.onAfterCreated(CefBrowser), to
+     * configure the preferences.
+     */
+    public abstract boolean hasPreference(String name);
+
+    /**
+     * Returns the value for the preference with the specified |name|. Returns
+     * NULL if the preference does not exist.
+     * This method must be called on the browser process UI thread, otherwise it will always return
+     * null.
+     */
+    public abstract Object getPreference(String name);
+
+    /**
+     * Returns all preferences as a dictionary. If |includeDefaults| is true then
+     * preferences currently at their default value will be included. The returned
+     * object can be modified but modifications will not persist. This method must
+     * be called on the browser process UI thread, otherwise it will always return null.
+     */
+    public abstract Map<String, Object> getAllPreferences(boolean includeDefaults);
+
+    /**
+     * Returns true if the preference with the specified |name| can be modified
+     * using setPreference. As one example preferences set via the command-line
+     * usually cannot be modified. This method must be called on the browser
+     * process UI thread, otherwise it will always return false.
+     */
+    public abstract boolean canSetPreference(String name);
+
+    /**
+     * Set the |value| associated with preference |name|. Returns null if the
+     * value is set successfully, an error string otherwise. If |value| is NULL the
+     * preference will be restored to its default value. If setting the preference
+     * fails then a detailed description of the problem will be returned.
+     * This method must be called on the browser process UI thread, otherwise it will always return
+     * an error string.
+     */
+    public abstract String setPreference(String name, Object value);
 }
diff --git a/java/org/cef/browser/CefRequestContext_N.java b/java/org/cef/browser/CefRequestContext_N.java
index 622a9ab5..6e26e7dd 100644
--- a/java/org/cef/browser/CefRequestContext_N.java
+++ b/java/org/cef/browser/CefRequestContext_N.java
@@ -6,6 +6,10 @@
 
 import org.cef.callback.CefNative;
 import org.cef.handler.CefRequestContextHandler;
+import org.cef.misc.StringRef;
+
+import java.util.HashMap;
+import java.util.Map;
 
 class CefRequestContext_N extends CefRequestContext implements CefNative {
     // Used internally to store a pointer to the CEF object.
@@ -73,6 +77,56 @@ public boolean isGlobal() {
         return false;
     }
 
+    @Override
+    public boolean hasPreference(String name) {
+        try {
+            return N_HasPreference(name);
+        } catch (UnsatisfiedLinkError ule) {
+            ule.printStackTrace();
+        }
+        return false;
+    }
+
+    @Override
+    public Object getPreference(String name) {
+        try {
+            return N_GetPreference(name);
+        } catch (UnsatisfiedLinkError ule) {
+            ule.printStackTrace();
+        }
+        return null;
+    }
+
+    @Override
+    public Map<String, Object> getAllPreferences(boolean includeDefaults) {
+        try {
+            return N_GetAllPreferences(includeDefaults);
+        } catch (UnsatisfiedLinkError ule) {
+            ule.printStackTrace();
+        }
+        return new HashMap<String, Object>();
+    }
+
+    @Override
+    public boolean canSetPreference(String name) {
+        try {
+            return N_CanSetPreference(name);
+        } catch (UnsatisfiedLinkError ule) {
+            ule.printStackTrace();
+        }
+        return false;
+    }
+
+    @Override
+    public String setPreference(String name, Object value) {
+        try {
+            return N_SetPreference(name, value);
+        } catch (UnsatisfiedLinkError ule) {
+            ule.printStackTrace();
+            return ule.getMessage();
+        }
+    }
+
     @Override
     public CefRequestContextHandler getHandler() {
         return handler;
@@ -82,5 +136,10 @@ public CefRequestContextHandler getHandler() {
     private final static native CefRequestContext_N N_CreateContext(
             CefRequestContextHandler handler);
     private final native boolean N_IsGlobal();
+    private final native boolean N_HasPreference(String name);
+    private final native Object N_GetPreference(String name);
+    private final native Map<String, Object> N_GetAllPreferences(boolean includeDefaults);
+    private final native boolean N_CanSetPreference(String name);
+    private final native String N_SetPreference(String name, Object value);
     private final native void N_CefRequestContext_DTOR();
 }
diff --git a/java/org/cef/callback/CefDragData.java b/java/org/cef/callback/CefDragData.java
index 0d13029f..25a55471 100644
--- a/java/org/cef/callback/CefDragData.java
+++ b/java/org/cef/callback/CefDragData.java
@@ -127,6 +127,12 @@ public static final CefDragData create() {
      */
     public abstract boolean getFileNames(Vector<String> names);
 
+    /**
+     * Retrieve the list of file paths that are being dragged into the browser
+     * window.
+     */
+    public abstract boolean getFilePaths(Vector<String> paths);
+
     /**
      * Set the link URL that is being dragged.
      * @param url The link URL to be set.
diff --git a/java/org/cef/callback/CefDragData_N.java b/java/org/cef/callback/CefDragData_N.java
index 9f6e0fee..e56867d1 100644
--- a/java/org/cef/callback/CefDragData_N.java
+++ b/java/org/cef/callback/CefDragData_N.java
@@ -179,6 +179,16 @@ public boolean getFileNames(Vector<String> names) {
         return false;
     }
 
+    @Override
+    public boolean getFilePaths(Vector<String> paths) {
+        try {
+            return N_GetFilePaths(N_CefHandle, paths);
+        } catch (UnsatisfiedLinkError ule) {
+            ule.printStackTrace();
+        }
+        return false;
+    }
+
     public void setLinkURL(String url) {
         try {
             N_SetLinkURL(N_CefHandle, url);
@@ -259,6 +269,7 @@ public void addFile(String path, String displayName) {
     private final native int N_GetFileContents(long self, OutputStream writer);
     private final native String N_GetFileName(long self);
     private final native boolean N_GetFileNames(long self, Vector<String> names);
+    private final native boolean N_GetFilePaths(long self, Vector<String> paths);
     private final native void N_SetLinkURL(long self, String url);
     private final native void N_SetLinkTitle(long self, String title);
     private final native void N_SetLinkMetadata(long self, String data);
diff --git a/java/org/cef/callback/CefResourceReadCallback.java b/java/org/cef/callback/CefResourceReadCallback.java
new file mode 100644
index 00000000..01e23436
--- /dev/null
+++ b/java/org/cef/callback/CefResourceReadCallback.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+package org.cef.callback;
+
+/**
+ * Callback interface used for asynchronous resource reading.
+ */
+public interface CefResourceReadCallback {
+    /**
+     * Callback for asynchronous continuation of Read(). If |bytes_read| == 0
+     * the response will be considered complete. If |bytes_read| > 0 then Read()
+     * will be called again until the request is complete (based on either the
+     * result or the expected content length). If |bytes_read| < 0 then the
+     * request will fail and the |bytes_read| value will be treated as the error
+     * code.
+     */
+    void Continue(int bytes_read);
+
+    /**
+     * Returns the byte buffer to write data into before calling #Continue(int).
+     */
+    public byte[] getBuffer();
+}
diff --git a/java/org/cef/callback/CefResourceReadCallback_N.java b/java/org/cef/callback/CefResourceReadCallback_N.java
new file mode 100644
index 00000000..f00c69d6
--- /dev/null
+++ b/java/org/cef/callback/CefResourceReadCallback_N.java
@@ -0,0 +1,46 @@
+// Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+package org.cef.callback;
+
+class CefResourceReadCallback_N extends CefNativeAdapter implements CefResourceReadCallback {
+    // The native buffer where to copy the data to.
+    private long N_NativeBufferRef;
+
+    // The Java buffer which the application is expected to fill with data.
+    private byte[] N_JavaBuffer;
+
+    CefResourceReadCallback_N() {}
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+
+    public void setBufferRefs(long nativeBufferRef, byte[] javaBuffer) {
+        N_NativeBufferRef = nativeBufferRef;
+        N_JavaBuffer = javaBuffer;
+    }
+
+    @Override
+    public byte[] getBuffer() {
+        return N_JavaBuffer;
+    }
+
+    @Override
+    public void Continue(int bytes_read) {
+        try {
+            if (N_NativeBufferRef != 0 && N_JavaBuffer != null) {
+                N_Continue(getNativeRef(null), bytes_read, N_NativeBufferRef, N_JavaBuffer);
+                N_NativeBufferRef = 0;
+                N_JavaBuffer = null;
+            }
+        } catch (UnsatisfiedLinkError ule) {
+            ule.printStackTrace();
+        }
+    }
+
+    private final native void N_Continue(
+            long self, int bytes_read, long nativeBufferRef, byte[] javaBuffer);
+}
diff --git a/java/org/cef/callback/CefResourceSkipCallback.java b/java/org/cef/callback/CefResourceSkipCallback.java
new file mode 100644
index 00000000..75022ce0
--- /dev/null
+++ b/java/org/cef/callback/CefResourceSkipCallback.java
@@ -0,0 +1,18 @@
+// Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+package org.cef.callback;
+
+/**
+ * Callback interface used for asynchronous resource skipping.
+ */
+public interface CefResourceSkipCallback {
+    /**
+     * Callback for asynchronous continuation of Skip(). If |bytes_skipped| > 0
+     * then either Skip() will be called again until the requested number of
+     * bytes have been skipped or the request will proceed. If |bytes_skipped|
+     * <= 0 the request will fail with ERR_REQUEST_RANGE_NOT_SATISFIABLE.
+     */
+    void Continue(long bytes_skipped);
+}
diff --git a/java/org/cef/callback/CefResourceSkipCallback_N.java b/java/org/cef/callback/CefResourceSkipCallback_N.java
new file mode 100644
index 00000000..eae840e5
--- /dev/null
+++ b/java/org/cef/callback/CefResourceSkipCallback_N.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+package org.cef.callback;
+
+class CefResourceSkipCallback_N extends CefNativeAdapter implements CefResourceSkipCallback {
+    CefResourceSkipCallback_N() {}
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+
+    @Override
+    public void Continue(long bytes_skipped) {
+        try {
+            N_Continue(getNativeRef(null), bytes_skipped);
+        } catch (UnsatisfiedLinkError ule) {
+            ule.printStackTrace();
+        }
+    }
+
+    private final native void N_Continue(long self, long bytes_skipped);
+}
diff --git a/java/org/cef/handler/CefDialogHandler.java b/java/org/cef/handler/CefDialogHandler.java
index 12ffdea7..13f6218d 100644
--- a/java/org/cef/handler/CefDialogHandler.java
+++ b/java/org/cef/handler/CefDialogHandler.java
@@ -20,6 +20,7 @@ public interface CefDialogHandler {
     enum FileDialogMode {
         FILE_DIALOG_OPEN, //!< Requires that the file exists before allowing the user to pick it.
         FILE_DIALOG_OPEN_MULTIPLE, //!< Like Open, but allows picking multiple files to open.
+        FILE_DIALOG_OPEN_FOLDER, //!< Like Open, but selects a folder to open.
         FILE_DIALOG_SAVE //!< Allows picking a nonexistent file, and prompts to overwrite if the
                          //! file already exists.
     }
diff --git a/java/org/cef/handler/CefLoadHandler.java b/java/org/cef/handler/CefLoadHandler.java
index 4f0bb831..a70faf0f 100644
--- a/java/org/cef/handler/CefLoadHandler.java
+++ b/java/org/cef/handler/CefLoadHandler.java
@@ -56,7 +56,6 @@ enum ErrorCode {
         ERR_ADDRESS_UNREACHABLE(-109),
         ERR_SSL_CLIENT_AUTH_CERT_NEEDED(-110),
         ERR_TUNNEL_CONNECTION_FAILED(-111),
-        ERR_NO_SSL_VERSIONS_ENABLED(-112),
         ERR_SSL_VERSION_OR_CIPHER_MISMATCH(-113),
         ERR_SSL_RENEGOTIATION_REQUESTED(-114),
         ERR_PROXY_AUTH_UNSUPPORTED(-115),
@@ -80,13 +79,10 @@ enum ErrorCode {
         ERR_NAME_RESOLUTION_FAILED(-137),
         ERR_NETWORK_ACCESS_DENIED(-138),
         ERR_TEMPORARILY_THROTTLED(-139),
-        ERR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT(-140),
         ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED(-141),
         ERR_MSG_TOO_BIG(-142),
         ERR_WS_PROTOCOL_ERROR(-145),
         ERR_ADDRESS_IN_USE(-147),
-        ERR_SSL_HANDSHAKE_NOT_COMPLETED(-148),
-        ERR_SSL_BAD_PEER_PUBLIC_KEY(-149),
         ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN(-150),
         ERR_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED(-151),
         ERR_SSL_DECRYPT_ERROR_ALERT(-153),
@@ -151,9 +147,6 @@ enum ErrorCode {
         ERR_MALFORMED_IDENTITY(-329),
         ERR_CONTENT_DECODING_FAILED(-330),
         ERR_NETWORK_IO_SUSPENDED(-331),
-        ERR_SYN_REPLY_NOT_RECEIVED(-332),
-        ERR_ENCODING_CONVERSION_FAILED(-333),
-        ERR_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT(-334),
         ERR_NO_SUPPORTED_PROXIES(-336),
         ERR_HTTP2_PROTOCOL_ERROR(-337),
         ERR_INVALID_AUTH_CREDENTIALS(-338),
@@ -228,7 +221,6 @@ enum ErrorCode {
         ERR_CERT_DATABASE_CHANGED(-714),
         ERR_DNS_MALFORMED_RESPONSE(-800),
         ERR_DNS_SERVER_REQUIRES_TCP(-801),
-        ERR_DNS_SERVER_FAILED(-802),
         ERR_DNS_TIMED_OUT(-803),
         ERR_DNS_CACHE_MISS(-804),
         ERR_DNS_SEARCH_EMPTY(-805),
diff --git a/java/org/cef/handler/CefResourceHandler.java b/java/org/cef/handler/CefResourceHandler.java
index 72f9f30d..24908f6a 100644
--- a/java/org/cef/handler/CefResourceHandler.java
+++ b/java/org/cef/handler/CefResourceHandler.java
@@ -5,15 +5,21 @@
 package org.cef.handler;
 
 import org.cef.callback.CefCallback;
+import org.cef.callback.CefResourceReadCallback;
+import org.cef.callback.CefResourceSkipCallback;
+import org.cef.misc.BoolRef;
 import org.cef.misc.IntRef;
+import org.cef.misc.LongRef;
 import org.cef.misc.StringRef;
 import org.cef.network.CefCookie;
 import org.cef.network.CefRequest;
 import org.cef.network.CefResponse;
 
 /**
- * Implement this interface to handle custom resource requests. The methods of
- * this class will always be called on the IO thread.
+ * Implement this interface to handle custom resource requests. This interface is a "new" API and an
+ * old API in one: the deprecated methods are part of the old API. The new API allows for parallel
+ * processing of requests, because it does not channel all reads through a dedicated IO thread, and
+ * it allows for skipping of bytes as part of handling Range requests.
  */
 public interface CefResourceHandler {
     /**
@@ -23,9 +29,22 @@ public interface CefResourceHandler {
      * @param callback Callback to continue or cancel the request.
      * @return True to handle the request and call CefCallback.Continue() once the response header
      *         information is available.
+     * @deprecated Use open() instead
      */
     boolean processRequest(CefRequest request, CefCallback callback);
 
+    /**
+     * Open the response stream. This and related (getResponseHeaders, read, skip) methods will be
+     * called in sequence but not from a dedicated thread. <p> For backwards compatibility set
+     * |handleRequest| to false and return false and the processRequest() method will be called.
+     * @param request The request itself. Cannot be modified in this callback. Instance only valid
+     *         within the scope of this method.
+     * @param handleRequest Set to true to handle/cancel the request immediately
+     * @param callback Callback to continue or cancel the request at a later time
+     * @return True to handle the request
+     */
+    boolean open(CefRequest request, BoolRef handleRequest, CefCallback callback);
+
     /**
      * Retrieve response header information. If the response length is not known set
      * |responseLength| to -1 and readResponse() will be called until it returns false. If the
@@ -49,9 +68,41 @@ public interface CefResourceHandler {
      * @param bytesRead Number of bytes written to the buffer.
      * @param callback Callback to execute if data will be available asynchronously.
      * @return True if more data is or will be available.
+     * @deprecated Use read() instead
      */
     boolean readResponse(byte[] dataOut, int bytesToRead, IntRef bytesRead, CefCallback callback);
 
+    /**
+     * Read response data. If data is available immediately copy up to |bytesToRead| bytes into
+     * |dataOut|, set |bytesRead| to the number of bytes copied, and return true. To read the data
+     * at a later time store |dataOut|, set |bytesRead| to 0, return true and call the callback when
+     * the data is available. To indicate response completion set |bytesRead| to 0 and return false.
+     * To indicate failure set |bytesRead| to <0 (e.g. -2 for ERR_FAILED) and return false. <p> For
+     * backwards compatibility set |bytesRead| to -1 and return false and the readResponse() method
+     * will be called.
+     * @param dataOut Write data to this buffer. Buffer remains valid until either an immediate
+     *         response is delivered (return true) or the callback is called later when data is
+     *         available (return false).
+     * @param bytesToRead Size of the buffer.
+     * @param bytesRead Number of bytes written to the buffer.
+     * @param callback Callback to execute if data will be available asynchronously.
+     * @return True if more data is or will be available.
+     */
+    boolean read(
+            byte[] dataOut, int bytesToRead, IntRef bytesRead, CefResourceReadCallback callback);
+
+    /**
+     * Skip response data when requested by a Range header. Skip over and discard |bytesToSkip|
+     * bytes of response data. If data is available immediately set |bytesSkipped| to the number of
+     * bytes skipped and return true. To read the data at a later time set |bytesSkipped| to 0,
+     * return true and execute |callback| when the data is available. To indicate failure set
+     * |bytesSkipped| to < 0 (e.g. -2 for ERR_FAILED) and return false.
+     * @param bytesToSkip Number of bytes to skip.
+     * @param bytesSkipped Number of bytes skipped.
+     * @param callback Callback to execute if data will be skipped asynchronously.
+     */
+    boolean skip(long bytesToSkip, LongRef bytesSkipped, CefResourceSkipCallback callback);
+
     /**
      * Request processing has been canceled.
      */
diff --git a/java/org/cef/handler/CefResourceHandlerAdapter.java b/java/org/cef/handler/CefResourceHandlerAdapter.java
index 9458bb2b..5360597e 100644
--- a/java/org/cef/handler/CefResourceHandlerAdapter.java
+++ b/java/org/cef/handler/CefResourceHandlerAdapter.java
@@ -5,7 +5,11 @@
 package org.cef.handler;
 
 import org.cef.callback.CefCallback;
+import org.cef.callback.CefResourceReadCallback;
+import org.cef.callback.CefResourceSkipCallback;
+import org.cef.misc.BoolRef;
 import org.cef.misc.IntRef;
+import org.cef.misc.LongRef;
 import org.cef.misc.StringRef;
 import org.cef.network.CefCookie;
 import org.cef.network.CefRequest;
@@ -22,6 +26,13 @@ public boolean processRequest(CefRequest request, CefCallback callback) {
         return false;
     }
 
+    @Override
+    public boolean open(CefRequest request, BoolRef handleRequest, CefCallback callback) {
+        // Enables backwards compatibility by default by calling processRequest.
+        handleRequest.set(false);
+        return false;
+    }
+
     @Override
     public void getResponseHeaders(
             CefResponse response, IntRef responseLength, StringRef redirectUrl) {}
@@ -32,6 +43,20 @@ public boolean readResponse(
         return false;
     }
 
+    @Override
+    public boolean read(
+            byte[] dataOut, int bytesToRead, IntRef bytesRead, CefResourceReadCallback callback) {
+        // Enables backwards compatibility by default by calling readResponse.
+        bytesRead.set(-1);
+        return false;
+    }
+
+    @Override
+    public boolean skip(long bytesToSkip, LongRef bytesSkipped, CefResourceSkipCallback callback) {
+        bytesSkipped.set(-2);
+        return false;
+    }
+
     @Override
     public void cancel() {}
 }
diff --git a/java/org/cef/misc/LongRef.java b/java/org/cef/misc/LongRef.java
new file mode 100644
index 00000000..5a7b6630
--- /dev/null
+++ b/java/org/cef/misc/LongRef.java
@@ -0,0 +1,26 @@
+// Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+package org.cef.misc;
+
+/**
+ * Helper class for passing long values by reference.
+ */
+public class LongRef {
+    private long value_;
+
+    public LongRef() {}
+
+    public LongRef(long value) {
+        value_ = value;
+    }
+
+    public void set(long value) {
+        value_ = value;
+    }
+
+    public long get() {
+        return value_;
+    }
+}
diff --git a/java/org/cef/network/CefPostDataElement.java b/java/org/cef/network/CefPostDataElement.java
index 2d32219a..576e940d 100644
--- a/java/org/cef/network/CefPostDataElement.java
+++ b/java/org/cef/network/CefPostDataElement.java
@@ -16,7 +16,7 @@ public static enum Type {
         PDE_TYPE_EMPTY,
         PDE_TYPE_BYTES,
         PDE_TYPE_FILE,
-        PDF_TYPE_NUM_VALUES, // probably should be PDE_TYPE, but wrong in CEF too
+        PDE_TYPE_NUM_VALUES,
     }
 
     // This CTOR can't be called directly. Call method create() instead.
diff --git a/java/tests/detailed/MainFrame.java b/java/tests/detailed/MainFrame.java
index 7377a2d1..77d76aba 100644
--- a/java/tests/detailed/MainFrame.java
+++ b/java/tests/detailed/MainFrame.java
@@ -296,8 +296,8 @@ public void onTakeFocus(CefBrowser browser, boolean next) {
                 "https://www.w3schools.com/howto/tryit.asp?filename=tryhow_js_fullscreen2");
         menuBar.addBookmarkSeparator();
         menuBar.addBookmark(
-                "javachromiumembedded", "https://bitbucket.org/chromiumembedded/java-cef");
-        menuBar.addBookmark("chromiumembedded", "https://bitbucket.org/chromiumembedded/cef");
+                "javachromiumembedded", "https://github.com/chromiumembedded/java-cef");
+        menuBar.addBookmark("chromiumembedded", "https://github.com/chromiumembedded/cef");
         setJMenuBar(menuBar);
     }
 
diff --git a/java/tests/detailed/dialog/DevToolsDialog.java b/java/tests/detailed/dialog/DevToolsDialog.java
deleted file mode 100644
index 07a61809..00000000
--- a/java/tests/detailed/dialog/DevToolsDialog.java
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright (c) 2014 The Chromium Embedded Framework Authors. All rights
-// reserved. Use of this source code is governed by a BSD-style license that
-// can be found in the LICENSE file.
-
-package tests.detailed.dialog;
-
-import org.cef.browser.CefBrowser;
-
-import java.awt.BorderLayout;
-import java.awt.Frame;
-import java.awt.Point;
-import java.awt.event.ComponentAdapter;
-import java.awt.event.ComponentEvent;
-
-import javax.swing.JDialog;
-
-@SuppressWarnings("serial")
-public class DevToolsDialog extends JDialog {
-    private final CefBrowser browser_;
-    public DevToolsDialog(Frame owner, String title, CefBrowser browser) {
-        this(owner, title, browser, null);
-    }
-
-    public DevToolsDialog(Frame owner, String title, CefBrowser browser, Point inspectAt) {
-        super(owner, title, false);
-        browser_ = browser;
-
-        setLayout(new BorderLayout());
-        setSize(800, 600);
-        setLocation(owner.getLocation().x + 20, owner.getLocation().y + 20);
-
-        browser.openDevTools(inspectAt);
-
-        addComponentListener(new ComponentAdapter() {
-            @Override
-            public void componentHidden(ComponentEvent e) {
-                dispose();
-            }
-        });
-    }
-
-    @Override
-    public void dispose() {
-        browser_.closeDevTools();
-        super.dispose();
-    }
-}
diff --git a/java/tests/detailed/handler/ClientSchemeHandler.java b/java/tests/detailed/handler/ClientSchemeHandler.java
index 2ee156ff..c3e5ecbf 100644
--- a/java/tests/detailed/handler/ClientSchemeHandler.java
+++ b/java/tests/detailed/handler/ClientSchemeHandler.java
@@ -5,7 +5,9 @@
 package tests.detailed.handler;
 
 import org.cef.callback.CefCallback;
+import org.cef.callback.CefResourceReadCallback;
 import org.cef.handler.CefResourceHandlerAdapter;
+import org.cef.misc.BoolRef;
 import org.cef.misc.IntRef;
 import org.cef.misc.StringRef;
 import org.cef.network.CefRequest;
@@ -33,7 +35,8 @@ public ClientSchemeHandler() {
     }
 
     @Override
-    public synchronized boolean processRequest(CefRequest request, CefCallback callback) {
+    public synchronized boolean open(
+            CefRequest request, BoolRef handleRequest, CefCallback callback) {
         boolean handled = false;
         String url = request.getURL();
         if (url.indexOf("handler.html") != -1) {
@@ -77,9 +80,10 @@ public synchronized boolean processRequest(CefRequest request, CefCallback callb
             }
         }
 
+        // All requests are handled immediately
+        handleRequest.set(true);
+
         if (handled) {
-            // Indicate the headers are available.
-            callback.Continue();
             return true;
         }
 
@@ -97,8 +101,8 @@ public void getResponseHeaders(
     }
 
     @Override
-    public synchronized boolean readResponse(
-            byte[] data_out, int bytes_to_read, IntRef bytes_read, CefCallback callback) {
+    public synchronized boolean read(byte[] data_out, int bytes_to_read, IntRef bytes_read,
+            CefResourceReadCallback callback) {
         boolean has_data = false;
 
         if (offset_ < data_.length) {
diff --git a/java/tests/detailed/handler/ResourceHandler.java b/java/tests/detailed/handler/ResourceHandler.java
index 4a36e0ee..5bc55308 100644
--- a/java/tests/detailed/handler/ResourceHandler.java
+++ b/java/tests/detailed/handler/ResourceHandler.java
@@ -1,8 +1,10 @@
 package tests.detailed.handler;
 
 import org.cef.callback.CefCallback;
+import org.cef.callback.CefResourceReadCallback;
 import org.cef.handler.CefLoadHandler;
 import org.cef.handler.CefResourceHandlerAdapter;
+import org.cef.misc.BoolRef;
 import org.cef.misc.IntRef;
 import org.cef.misc.StringRef;
 import org.cef.network.CefRequest;
@@ -25,11 +27,11 @@ public class ResourceHandler extends CefResourceHandlerAdapter {
             + "</html>");
 
     @Override
-    public boolean processRequest(CefRequest request, CefCallback callback) {
+    public boolean open(CefRequest request, BoolRef handleRequest, CefCallback callback) {
         System.out.println("processRequest: " + request);
 
         startPos = 0;
-        callback.Continue();
+        handleRequest.set(true);
         return true;
     }
 
@@ -44,8 +46,8 @@ public void getResponseHeaders(
     }
 
     @Override
-    public boolean readResponse(
-            byte[] data_out, int bytes_to_read, IntRef bytes_read, CefCallback callback) {
+    public boolean read(byte[] data_out, int bytes_to_read, IntRef bytes_read,
+            CefResourceReadCallback callback) {
         int length = html.length();
         if (startPos >= length) return false;
 
diff --git a/java/tests/detailed/handler/ResourceSetErrorHandler.java b/java/tests/detailed/handler/ResourceSetErrorHandler.java
index bc3dd129..005cb702 100644
--- a/java/tests/detailed/handler/ResourceSetErrorHandler.java
+++ b/java/tests/detailed/handler/ResourceSetErrorHandler.java
@@ -3,6 +3,7 @@
 import org.cef.callback.CefCallback;
 import org.cef.handler.CefLoadHandler.ErrorCode;
 import org.cef.handler.CefResourceHandlerAdapter;
+import org.cef.misc.BoolRef;
 import org.cef.misc.IntRef;
 import org.cef.misc.StringRef;
 import org.cef.network.CefRequest;
@@ -10,9 +11,9 @@
 
 public class ResourceSetErrorHandler extends CefResourceHandlerAdapter {
     @Override
-    public boolean processRequest(CefRequest request, CefCallback callback) {
+    public boolean open(CefRequest request, BoolRef handleRequest, CefCallback callback) {
         System.out.println("processRequest: " + request);
-        callback.Continue();
+        handleRequest.set(true);
         return true;
     }
 
diff --git a/java/tests/detailed/handler/SearchSchemeHandler.java b/java/tests/detailed/handler/SearchSchemeHandler.java
index 8a5c80e1..3f9b1e5b 100644
--- a/java/tests/detailed/handler/SearchSchemeHandler.java
+++ b/java/tests/detailed/handler/SearchSchemeHandler.java
@@ -7,6 +7,7 @@
 import org.cef.browser.CefBrowser;
 import org.cef.callback.CefCallback;
 import org.cef.handler.CefResourceHandlerAdapter;
+import org.cef.misc.BoolRef;
 import org.cef.network.CefRequest;
 
 /**
@@ -26,7 +27,7 @@ public SearchSchemeHandler(CefBrowser browser) {
     }
 
     @Override
-    public boolean processRequest(CefRequest request, CefCallback callback) {
+    public boolean open(CefRequest request, BoolRef handleRequest, CefCallback callback) {
         // cut away "scheme://"
         String requestUrl = request.getURL();
         String newUrl = requestUrl.substring(scheme.length() + 3);
@@ -43,6 +44,7 @@ public boolean processRequest(CefRequest request, CefCallback callback) {
             newRequest.setFirstPartyForCookies(newUrl);
             browser_.loadRequest(newRequest);
         }
+        handleRequest.set(true);
         return false;
     }
 }
diff --git a/java/tests/detailed/ui/MenuBar.java b/java/tests/detailed/ui/MenuBar.java
index 0ed8bf1a..79ecc095 100644
--- a/java/tests/detailed/ui/MenuBar.java
+++ b/java/tests/detailed/ui/MenuBar.java
@@ -22,8 +22,6 @@
 import java.awt.FlowLayout;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
-import java.awt.event.ComponentAdapter;
-import java.awt.event.ComponentEvent;
 import java.awt.event.WindowEvent;
 import java.awt.image.BufferedImage;
 import java.io.File;
@@ -52,7 +50,6 @@
 import tests.detailed.BrowserFrame;
 import tests.detailed.MainFrame;
 import tests.detailed.dialog.CookieManagerDialog;
-import tests.detailed.dialog.DevToolsDialog;
 import tests.detailed.dialog.DownloadDialog;
 import tests.detailed.dialog.SearchDialog;
 import tests.detailed.dialog.ShowTextDialog;
@@ -62,7 +59,7 @@
 @SuppressWarnings("serial")
 public class MenuBar extends JMenuBar {
     class SaveAs implements CefStringVisitor {
-        private PrintWriter fileWriter_;
+        private final PrintWriter fileWriter_;
 
         public SaveAs(String fName) throws FileNotFoundException, UnsupportedEncodingException {
             fileWriter_ = new PrintWriter(fName, "UTF-8");
@@ -367,15 +364,7 @@ public void actionPerformed(ActionEvent e) {
         showDevTools.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
-                DevToolsDialog devToolsDlg = new DevToolsDialog(owner_, "DEV Tools", browser_);
-                devToolsDlg.addComponentListener(new ComponentAdapter() {
-                    @Override
-                    public void componentHidden(ComponentEvent e) {
-                        showDevTools.setEnabled(true);
-                    }
-                });
-                devToolsDlg.setVisible(true);
-                showDevTools.setEnabled(false);
+                browser.openDevTools();
             }
         });
         testMenu.add(showDevTools);
@@ -431,11 +420,14 @@ public void actionPerformed(ActionEvent e) {
                 reparentButton.addActionListener(new ActionListener() {
                     @Override
                     public void actionPerformed(ActionEvent e) {
-                        if (reparentPending_) return;
+                        if (reparentPending_) {
+                            return;
+                        }
                         reparentPending_ = true;
 
                         if (reparentButton.getText().equals("Reparent <")) {
                             owner_.removeBrowser(new Runnable() {
+                                @Override
                                 public void run() {
                                     newFrame.add(browser_.getUIComponent(), BorderLayout.CENTER);
                                     newFrame.setBrowser(browser_);
@@ -445,6 +437,7 @@ public void run() {
                             });
                         } else {
                             newFrame.removeBrowser(new Runnable() {
+                                @Override
                                 public void run() {
                                     JRootPane rootPane = (JRootPane) owner_.getComponent(0);
                                     Container container = rootPane.getContentPane();
@@ -540,12 +533,16 @@ public void run() {
     }
 
     public void addBookmark(String name, String URL) {
-        if (bookmarkMenu_ == null) return;
+        if (bookmarkMenu_ == null) {
+            return;
+        }
 
         // Test if the bookmark already exists. If yes, update URL
         Component[] entries = bookmarkMenu_.getMenuComponents();
         for (Component itemEntry : entries) {
-            if (!(itemEntry instanceof JMenuItem)) continue;
+            if (!(itemEntry instanceof JMenuItem)) {
+                continue;
+            }
 
             JMenuItem item = (JMenuItem) itemEntry;
             if (item.getText().equals(name)) {
diff --git a/native/CMakeLists.txt b/native/CMakeLists.txt
index aef58415..cdcd1ef4 100644
--- a/native/CMakeLists.txt
+++ b/native/CMakeLists.txt
@@ -62,6 +62,10 @@ set(JCEF_SRCS
   CefCallback_N.h
   CefRequestContext_N.cpp
   CefRequestContext_N.h
+  CefResourceReadCallback_N.cpp
+  CefResourceReadCallback_N.h
+  CefResourceSkipCallback_N.cpp
+  CefResourceSkipCallback_N.h
   CefResponse_N.cpp
   CefResponse_N.h
   CefSchemeRegistrar_N.cpp
@@ -276,6 +280,15 @@ endif()
 #
 
 if(OS_MAC)
+  # Find the ant executable, including Homebrew paths.
+  find_program(ANT_EXECUTABLE ant
+    HINTS /opt/homebrew/bin /usr/local/bin
+    )
+  if(NOT ANT_EXECUTABLE)
+    message(FATAL_ERROR "ant not found. Install with: brew install ant")
+  endif()
+  message(STATUS "Using ant: ${ANT_EXECUTABLE}")
+
   # Avoid CMP0042 policy errors.
   set(CMAKE_MACOSX_RPATH 1)
 
@@ -291,11 +304,6 @@ if(OS_MAC)
   set(EXECUTABLE_NAME "${JCEF_APP_NAME}")
   set(PRODUCT_NAME "${JCEF_APP_NAME}")
 
-  if(USE_SANDBOX)
-    # Logical target used to link the cef_sandbox library.
-    ADD_LOGICAL_TARGET("cef_sandbox_lib" "${CEF_SANDBOX_LIB_DEBUG}" "${CEF_SANDBOX_LIB_RELEASE}")
-  endif()
-
   # JCEF library target.
   add_library(${JCEF_TARGET} SHARED ${JCEF_RESOURCES_SRCS} ${JCEF_SRCS})
   SET_EXECUTABLE_TARGET_PROPERTIES(${JCEF_TARGET})
@@ -303,6 +311,11 @@ if(OS_MAC)
   target_link_libraries(${JCEF_TARGET} libcef_dll_wrapper ${CEF_STANDARD_LIBS}  ${JNI_LIBRARIES})
   target_include_directories(${JCEF_TARGET} PUBLIC ${JNI_INCLUDE_DIRS})
 
+  # Use ad-hoc code signing for the dynamic library (required by Xcode 14+).
+  set_target_properties(${JCEF_TARGET} PROPERTIES
+    XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "-"
+    )
+
   # Compile flags specific to the JCEF library target.
   # USING_JAVA          = Add the USING_JAVA define.
   target_compile_definitions(${JCEF_TARGET} PRIVATE "USING_JAVA")
@@ -315,7 +328,7 @@ if(OS_MAC)
     TARGET ${JCEF_TARGET}
     POST_BUILD
     # Build the main app bundle.
-    COMMAND ant
+    COMMAND ${ANT_EXECUTABLE}
             -buildfile ${CMAKE_SOURCE_DIR}
             -Djdk7.path=${JAVA_DIR}
             -Dout.path=${CEF_TARGET_OUT_DIR}
@@ -365,12 +378,9 @@ if(OS_MAC)
     set_target_properties(${_helper_target} PROPERTIES
       MACOSX_BUNDLE_INFO_PLIST ${_helper_info_plist}
       OUTPUT_NAME ${_helper_output_name}
+      XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "-"
       )
 
-    if(USE_SANDBOX)
-      target_link_libraries(${_helper_target} cef_sandbox_lib)
-    endif()
-
     # Add the Helper as a dependency of the main executable target.
     add_dependencies(${JCEF_TARGET} "${_helper_target}")
 
diff --git a/native/CefBrowser_N.cpp b/native/CefBrowser_N.cpp
index 0e5f8118..ceea3a61 100644
--- a/native/CefBrowser_N.cpp
+++ b/native/CefBrowser_N.cpp
@@ -1580,6 +1580,10 @@ Java_org_cef_browser_CefBrowser_1N_N_1RunFileDialog(JNIEnv* env,
                             "org/cef/handler/CefDialogHandler$FileDialogMode",
                             "FILE_DIALOG_OPEN_MULTIPLE")) {
     mode = FILE_DIALOG_OPEN_MULTIPLE;
+  } else if (IsJNIEnumValue(env, jmode,
+                            "org/cef/handler/CefDialogHandler$FileDialogMode",
+                            "FILE_DIALOG_OPEN_FOLDER")) {
+    mode = FILE_DIALOG_OPEN_FOLDER;
   } else if (IsJNIEnumValue(env, jmode,
                             "org/cef/handler/CefDialogHandler$FileDialogMode",
                             "FILE_DIALOG_SAVE")) {
diff --git a/native/CefDragData_N.cpp b/native/CefDragData_N.cpp
index cf7e6c21..f9132087 100644
--- a/native/CefDragData_N.cpp
+++ b/native/CefDragData_N.cpp
@@ -190,6 +190,25 @@ Java_org_cef_callback_CefDragData_1N_N_1GetFileNames(JNIEnv* env,
   return JNI_TRUE;
 }
 
+JNIEXPORT jboolean JNICALL
+Java_org_cef_callback_CefDragData_1N_N_1GetFilePaths(JNIEnv* env,
+                                                     jobject obj,
+                                                     jlong self,
+                                                     jobject jfilePaths) {
+  CefRefPtr<CefDragData> dragData = GetSelf(self);
+  if (!dragData)
+    return JNI_FALSE;
+
+  std::vector<CefString> filePaths;
+  if (!dragData->GetFilePaths(filePaths))
+    return JNI_FALSE;
+
+  for (size_t i = 0; i < filePaths.size(); ++i) {
+    AddJNIStringToVector(env, jfilePaths, filePaths.at(i));
+  }
+  return JNI_TRUE;
+}
+
 JNIEXPORT void JNICALL
 Java_org_cef_callback_CefDragData_1N_N_1SetLinkURL(JNIEnv* env,
                                                    jobject obj,
diff --git a/native/CefDragData_N.h b/native/CefDragData_N.h
index e7f223d9..36ae14c1 100644
--- a/native/CefDragData_N.h
+++ b/native/CefDragData_N.h
@@ -151,6 +151,17 @@ Java_org_cef_callback_CefDragData_1N_N_1GetFileNames(JNIEnv*,
                                                      jlong,
                                                      jobject);
 
+/*
+ * Class:     org_cef_callback_CefDragData_N
+ * Method:    N_GetFilePaths
+ * Signature: (JLjava/util/Vector;)Z
+ */
+JNIEXPORT jboolean JNICALL
+Java_org_cef_callback_CefDragData_1N_N_1GetFilePaths(JNIEnv*,
+                                                     jobject,
+                                                     jlong,
+                                                     jobject);
+
 /*
  * Class:     org_cef_callback_CefDragData_N
  * Method:    N_SetLinkURL
diff --git a/native/CefPostDataElement_N.cpp b/native/CefPostDataElement_N.cpp
index 63f4e695..414e7a55 100644
--- a/native/CefPostDataElement_N.cpp
+++ b/native/CefPostDataElement_N.cpp
@@ -99,7 +99,7 @@ Java_org_cef_network_CefPostDataElement_1N_N_1GetType(JNIEnv* env,
     JNI_CASE(env, "org/cef/network/CefPostDataElement$Type", PDE_TYPE_FILE,
              jtype);
     JNI_CASE(env, "org/cef/network/CefPostDataElement$Type",
-             PDF_TYPE_NUM_VALUES, jtype);
+             PDE_TYPE_NUM_VALUES, jtype);
   }
   return jtype;
 }
diff --git a/native/CefRequestContext_N.cpp b/native/CefRequestContext_N.cpp
index 3f22cfd5..db6b2dd4 100644
--- a/native/CefRequestContext_N.cpp
+++ b/native/CefRequestContext_N.cpp
@@ -56,6 +56,104 @@ Java_org_cef_browser_CefRequestContext_1N_N_1IsGlobal(JNIEnv* env,
   return context->IsGlobal() ? JNI_TRUE : JNI_FALSE;
 }
 
+JNIEXPORT jboolean JNICALL
+Java_org_cef_browser_CefRequestContext_1N_N_1HasPreference(JNIEnv* env,
+                                                           jobject obj,
+                                                           jstring jname) {
+  CefRefPtr<CefRequestContext> context =
+      GetCefFromJNIObject<CefRequestContext>(env, obj, "CefRequestContext");
+  if (!context.get())
+    return JNI_FALSE;
+
+  CefString name = GetJNIString(env, jname);
+  return context->HasPreference(name) ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_cef_browser_CefRequestContext_1N_N_1GetPreference(JNIEnv* env,
+                                                           jobject obj,
+                                                           jstring jname) {
+  CefRefPtr<CefRequestContext> context =
+      GetCefFromJNIObject<CefRequestContext>(env, obj, "CefRequestContext");
+  if (!context.get())
+    return nullptr;
+
+  CefString name = GetJNIString(env, jname);
+  CefRefPtr<CefValue> value = context->GetPreference(name);
+  if (!value)
+    return nullptr;
+
+  return NewJNIObjectFromCefValue(env, value);
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_cef_browser_CefRequestContext_1N_N_1GetAllPreferences(
+    JNIEnv* env,
+    jobject obj,
+    jboolean includeDefaults) {
+  CefRefPtr<CefRequestContext> context =
+      GetCefFromJNIObject<CefRequestContext>(env, obj, "CefRequestContext");
+  if (!context.get())
+    return nullptr;
+
+  CefRefPtr<CefDictionaryValue> value =
+      context->GetAllPreferences(includeDefaults == JNI_TRUE);
+  if (!value)
+    return nullptr;
+
+  jobject jmap = NewJNIHashMap(env);
+  CefDictionaryValue::KeyList keys;
+  value->GetKeys(keys);
+  for (const CefString& key : keys) {
+    jstring jkey = NewJNIString(env, key);
+    jobject jvalue = NewJNIObjectFromCefValue(env, value->GetValue(key));
+    JNI_CALL_VOID_METHOD(
+        env, jmap, "put",
+        "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", jkey,
+        jvalue);
+  }
+  return jmap;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_cef_browser_CefRequestContext_1N_N_1CanSetPreference(JNIEnv* env,
+                                                              jobject obj,
+                                                              jstring jname) {
+  CefRefPtr<CefRequestContext> context =
+      GetCefFromJNIObject<CefRequestContext>(env, obj, "CefRequestContext");
+  if (!context.get())
+    return JNI_FALSE;
+
+  CefString name = GetJNIString(env, jname);
+  return context->CanSetPreference(name) ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_cef_browser_CefRequestContext_1N_N_1SetPreference(JNIEnv* env,
+                                                           jobject obj,
+                                                           jstring jname,
+                                                           jobject jvalue) {
+  if (!CefCurrentlyOn(TID_UI))
+    return NewJNIString(env, "called on invalid thread");
+
+  CefRefPtr<CefRequestContext> context =
+      GetCefFromJNIObject<CefRequestContext>(env, obj, "CefRequestContext");
+  if (!context.get())
+    return NewJNIString(env, "no request context");
+
+  CefString name = GetJNIString(env, jname);
+  CefRefPtr<CefValue> value = GetCefValueFromJNIObject(env, jvalue);
+  if (!value)
+    return NewJNIString(env, "no value to set");
+
+  CefString error;
+  bool result = context->SetPreference(name, value, error);
+  if (!result)
+    return NewJNIString(env, error);
+
+  return nullptr;
+}
+
 JNIEXPORT void JNICALL
 Java_org_cef_browser_CefRequestContext_1N_N_1CefRequestContext_1DTOR(
     JNIEnv* env,
diff --git a/native/CefRequestContext_N.h b/native/CefRequestContext_N.h
index 18dade6e..407cc778 100644
--- a/native/CefRequestContext_N.h
+++ b/native/CefRequestContext_N.h
@@ -34,6 +34,57 @@ Java_org_cef_browser_CefRequestContext_1N_N_1CreateContext(JNIEnv*,
 JNIEXPORT jboolean JNICALL
 Java_org_cef_browser_CefRequestContext_1N_N_1IsGlobal(JNIEnv*, jobject);
 
+/*
+ * Class:     org_cef_browser_CefRequestContext_N
+ * Method:    N_HasPreference
+ * Signature: (Ljava/lang/String;)Z
+ */
+JNIEXPORT jboolean JNICALL
+Java_org_cef_browser_CefRequestContext_1N_N_1HasPreference(JNIEnv*,
+                                                           jobject,
+                                                           jstring);
+
+/*
+ * Class:     org_cef_browser_CefRequestContext_N
+ * Method:    N_GetPreference
+ * Signature: (Ljava/lang/String;)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL
+Java_org_cef_browser_CefRequestContext_1N_N_1GetPreference(JNIEnv*,
+                                                           jobject,
+                                                           jstring);
+
+/*
+ * Class:     org_cef_browser_CefRequestContext_N
+ * Method:    N_GetAllPreferences
+ * Signature: (Z)Ljava/util/Map;
+ */
+JNIEXPORT jobject JNICALL
+Java_org_cef_browser_CefRequestContext_1N_N_1GetAllPreferences(JNIEnv*,
+                                                               jobject,
+                                                               jboolean);
+
+/*
+ * Class:     org_cef_browser_CefRequestContext_N
+ * Method:    N_CanSetPreference
+ * Signature: (Ljava/lang/String;)Z
+ */
+JNIEXPORT jboolean JNICALL
+Java_org_cef_browser_CefRequestContext_1N_N_1CanSetPreference(JNIEnv*,
+                                                              jobject,
+                                                              jstring);
+
+/*
+ * Class:     org_cef_browser_CefRequestContext_N
+ * Method:    N_SetPreference
+ * Signature: (Ljava/lang/String;Ljava/lang/Object;Lorg/cef;)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL
+Java_org_cef_browser_CefRequestContext_1N_N_1SetPreference(JNIEnv*,
+                                                           jobject,
+                                                           jstring,
+                                                           jobject);
+
 /*
  * Class:     org_cef_browser_CefRequestContext_N
  * Method:    N_CefRequestContext_DTOR
diff --git a/native/CefResourceReadCallback_N.cpp b/native/CefResourceReadCallback_N.cpp
new file mode 100644
index 00000000..4eebcda4
--- /dev/null
+++ b/native/CefResourceReadCallback_N.cpp
@@ -0,0 +1,49 @@
+// Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+#include "CefResourceReadCallback_N.h"
+#include "include/cef_resource_handler.h"
+#include "jni_scoped_helpers.h"
+
+namespace {
+
+CefRefPtr<CefResourceReadCallback> GetSelf(jlong self) {
+  return reinterpret_cast<CefResourceReadCallback*>(self);
+}
+
+void ClearSelf(JNIEnv* env, jobject obj) {
+  // Clear the reference added in ResourceHandler.
+  SetCefForJNIObject<CefResourceReadCallback>(env, obj, nullptr,
+                                              "CefResourceReadCallback");
+}
+
+}  // namespace
+
+JNIEXPORT void JNICALL
+Java_org_cef_callback_CefResourceReadCallback_1N_N_1Continue(
+    JNIEnv* env,
+    jobject obj,
+    jlong self,
+    jint bytes_read,
+    jlong nativeBufferRef,
+    jbyteArray javaBuffer) {
+  CefRefPtr<CefResourceReadCallback> callback = GetSelf(self);
+  if (!callback)
+    return;
+
+  void* data_out = reinterpret_cast<void*>(nativeBufferRef);
+
+  if (bytes_read > 0) {
+    jsize max_bytes = env->GetArrayLength(javaBuffer);
+    jbyte* jbyte = env->GetByteArrayElements(javaBuffer, nullptr);
+    if (jbyte) {
+      memmove(data_out, jbyte,
+              (bytes_read < max_bytes ? bytes_read : max_bytes));
+      env->ReleaseByteArrayElements(javaBuffer, jbyte, JNI_ABORT);
+    }
+  }
+
+  callback->Continue(bytes_read);
+  ClearSelf(env, obj);
+}
diff --git a/native/CefResourceReadCallback_N.h b/native/CefResourceReadCallback_N.h
new file mode 100644
index 00000000..1a12bbfe
--- /dev/null
+++ b/native/CefResourceReadCallback_N.h
@@ -0,0 +1,26 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_cef_callback_CefResourceReadCallback_N */
+
+#ifndef _Included_org_cef_callback_CefResourceReadCallback_N
+#define _Included_org_cef_callback_CefResourceReadCallback_N
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_cef_callback_CefResourceReadCallback_N
+ * Method:    N_Continue
+ * Signature: (JI)V
+ */
+JNIEXPORT void JNICALL
+Java_org_cef_callback_CefResourceReadCallback_1N_N_1Continue(JNIEnv*,
+                                                             jobject,
+                                                             jlong,
+                                                             jint,
+                                                             jlong,
+                                                             jbyteArray);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/native/CefResourceSkipCallback_N.cpp b/native/CefResourceSkipCallback_N.cpp
new file mode 100644
index 00000000..9f2b20c4
--- /dev/null
+++ b/native/CefResourceSkipCallback_N.cpp
@@ -0,0 +1,34 @@
+// Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+#include "CefResourceSkipCallback_N.h"
+#include "include/cef_resource_handler.h"
+#include "jni_scoped_helpers.h"
+
+namespace {
+
+CefRefPtr<CefResourceSkipCallback> GetSelf(jlong self) {
+  return reinterpret_cast<CefResourceSkipCallback*>(self);
+}
+
+void ClearSelf(JNIEnv* env, jobject obj) {
+  // Clear the reference added in ResourceHandler.
+  SetCefForJNIObject<CefResourceSkipCallback>(env, obj, nullptr,
+                                              "CefResourceSkipCallback");
+}
+
+}  // namespace
+
+JNIEXPORT void JNICALL
+Java_org_cef_callback_CefResourceSkipCallback_1N_N_1Continue(
+    JNIEnv* env,
+    jobject obj,
+    jlong self,
+    jlong bytes_skipped) {
+  CefRefPtr<CefResourceSkipCallback> callback = GetSelf(self);
+  if (!callback)
+    return;
+  callback->Continue(bytes_skipped);
+  ClearSelf(env, obj);
+}
diff --git a/native/CefResourceSkipCallback_N.h b/native/CefResourceSkipCallback_N.h
new file mode 100644
index 00000000..2de2e119
--- /dev/null
+++ b/native/CefResourceSkipCallback_N.h
@@ -0,0 +1,24 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_cef_callback_CefResourceSkipCallback_N */
+
+#ifndef _Included_org_cef_callback_CefResourceSkipCallback_N
+#define _Included_org_cef_callback_CefResourceSkipCallback_N
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_cef_callback_CefResourceSkipCallback_N
+ * Method:    N_Continue
+ * Signature: (JJ)V
+ */
+JNIEXPORT void JNICALL
+Java_org_cef_callback_CefResourceSkipCallback_1N_N_1Continue(JNIEnv*,
+                                                             jobject,
+                                                             jlong,
+                                                             jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/native/context.cpp b/native/context.cpp
index beb553f1..2fa324f3 100644
--- a/native/context.cpp
+++ b/native/context.cpp
@@ -109,6 +109,11 @@ CefSettings GetJNISettings(JNIEnv* env, jobject obj) {
   }
   GetJNIFieldInt(env, cls, obj, "remote_debugging_port",
                  &settings.remote_debugging_port);
+  if (GetJNIFieldString(env, cls, obj, "chrome_policy_id", &tmp) &&
+      !tmp.empty()) {
+    CefString(&settings.chrome_policy_id) = tmp;
+    tmp.clear();
+  }
   GetJNIFieldInt(env, cls, obj, "uncaught_exception_stack_size",
                  &settings.uncaught_exception_stack_size);
   jobject obj_col = nullptr;
diff --git a/native/dialog_handler.cpp b/native/dialog_handler.cpp
index 883f675f..eb26e562 100644
--- a/native/dialog_handler.cpp
+++ b/native/dialog_handler.cpp
@@ -58,6 +58,8 @@ bool DialogHandler::OnFileDialog(
                FILE_DIALOG_OPEN, jmode);
       JNI_CASE(env, "org/cef/handler/CefDialogHandler$FileDialogMode",
                FILE_DIALOG_OPEN_MULTIPLE, jmode);
+      JNI_CASE(env, "org/cef/handler/CefDialogHandler$FileDialogMode",
+               FILE_DIALOG_OPEN_FOLDER, jmode);
       JNI_CASE(env, "org/cef/handler/CefDialogHandler$FileDialogMode",
                FILE_DIALOG_SAVE, jmode);
   }
diff --git a/native/jni_scoped_helpers.cpp b/native/jni_scoped_helpers.cpp
index b73fa580..f6613641 100644
--- a/native/jni_scoped_helpers.cpp
+++ b/native/jni_scoped_helpers.cpp
@@ -112,6 +112,14 @@ jobject NewJNIIntRef(JNIEnv* env, int initValue) {
   return jintRef.Release();
 }
 
+jobject NewJNILongRef(JNIEnv* env, int64_t initValue) {
+  ScopedJNIObjectLocal jlongRef(env, "org/cef/misc/LongRef");
+  if (!jlongRef)
+    return nullptr;
+  SetJNILongRef(env, jlongRef, initValue);
+  return jlongRef.Release();
+}
+
 jobject NewJNIStringRef(JNIEnv* env, const CefString& initValue) {
   ScopedJNIObjectLocal jstringRef(env, "org/cef/misc/StringRef");
   if (!jstringRef)
@@ -433,6 +441,24 @@ ScopedJNICallback::ScopedJNICallback(JNIEnv* env, CefRefPtr<CefCallback> obj)
                                    "org/cef/callback/CefCallback_N",
                                    "CefCallback") {}
 
+ScopedJNIResourceReadCallback::ScopedJNIResourceReadCallback(
+    JNIEnv* env,
+    CefRefPtr<CefResourceReadCallback> obj)
+    : ScopedJNIObject<CefResourceReadCallback>(
+          env,
+          obj,
+          "org/cef/callback/CefResourceReadCallback_N",
+          "CefResourceReadCallback") {}
+
+ScopedJNIResourceSkipCallback::ScopedJNIResourceSkipCallback(
+    JNIEnv* env,
+    CefRefPtr<CefResourceSkipCallback> obj)
+    : ScopedJNIObject<CefResourceSkipCallback>(
+          env,
+          obj,
+          "org/cef/callback/CefResourceSkipCallback_N",
+          "CefResourceSkipCallback") {}
+
 ScopedJNIBoolRef::ScopedJNIBoolRef(JNIEnv* env, bool value)
     : ScopedJNIBase<jobject>(env) {
   jhandle_ = NewJNIBoolRef(env, value);
@@ -453,6 +479,16 @@ ScopedJNIIntRef::operator int() const {
   return GetJNIIntRef(env_, jhandle_);
 }
 
+ScopedJNILongRef::ScopedJNILongRef(JNIEnv* env, int64_t value)
+    : ScopedJNIBase<jobject>(env) {
+  jhandle_ = NewJNILongRef(env, value);
+  DCHECK(jhandle_);
+}
+
+ScopedJNILongRef::operator int64_t() const {
+  return GetJNILongRef(env_, jhandle_);
+}
+
 ScopedJNIStringRef::ScopedJNIStringRef(JNIEnv* env, const CefString& value)
     : ScopedJNIBase<jobject>(env) {
   jhandle_ = NewJNIStringRef(env, value);
diff --git a/native/jni_scoped_helpers.h b/native/jni_scoped_helpers.h
index 9ad28094..3e73e45c 100644
--- a/native/jni_scoped_helpers.h
+++ b/native/jni_scoped_helpers.h
@@ -822,6 +822,26 @@ class ScopedJNICallback : public ScopedJNIObject<CefCallback> {
   ScopedJNICallback(JNIEnv* env, CefRefPtr<CefCallback> obj = nullptr);
 };
 
+// JNI CefResourceReadCallback object.
+class ScopedJNIResourceReadCallback
+    : public ScopedJNIObject<CefResourceReadCallback> {
+ public:
+  // If |obj| is nullptr the SetHandle method should be used.
+  ScopedJNIResourceReadCallback(
+      JNIEnv* env,
+      CefRefPtr<CefResourceReadCallback> obj = nullptr);
+};
+
+// JNI CefResourceSkipCallback object.
+class ScopedJNIResourceSkipCallback
+    : public ScopedJNIObject<CefResourceSkipCallback> {
+ public:
+  // If |obj| is nullptr the SetHandle method should be used.
+  ScopedJNIResourceSkipCallback(
+      JNIEnv* env,
+      CefRefPtr<CefResourceSkipCallback> obj = nullptr);
+};
+
 // JNI BoolRef object.
 class ScopedJNIBoolRef : public ScopedJNIBase<jobject> {
  public:
@@ -840,6 +860,15 @@ class ScopedJNIIntRef : public ScopedJNIBase<jobject> {
   operator int() const;
 };
 
+// JNI LongRef object.
+class ScopedJNILongRef : public ScopedJNIBase<jobject> {
+ public:
+  ScopedJNILongRef(JNIEnv* env, int64_t value);
+
+  // Implicit retrieval of the underlying value.
+  operator int64_t() const;
+};
+
 // JNI StringRef object.
 class ScopedJNIStringRef : public ScopedJNIBase<jobject> {
  public:
diff --git a/native/jni_util.cpp b/native/jni_util.cpp
index 9d948330..02e24a51 100644
--- a/native/jni_util.cpp
+++ b/native/jni_util.cpp
@@ -99,6 +99,12 @@ int GetJNIIntRef(JNIEnv* env, jobject jintRef) {
   return intRefRes;
 }
 
+int64_t GetJNILongRef(JNIEnv* env, jobject jlongRef) {
+  jlong longRefRes = -1;
+  JNI_CALL_METHOD(env, jlongRef, "get", "()J", Long, longRefRes);
+  return longRefRes;
+}
+
 CefString GetJNIStringRef(JNIEnv* env, jobject jstringRef) {
   ScopedJNIStringResult str(env);
   JNI_CALL_METHOD(env, jstringRef, "get", "()Ljava/lang/String;", Object, str);
@@ -114,6 +120,10 @@ void SetJNIIntRef(JNIEnv* env, jobject jintRef, int intValue) {
   JNI_CALL_VOID_METHOD(env, jintRef, "set", "(I)V", intValue);
 }
 
+void SetJNILongRef(JNIEnv* env, jobject jlongRef, int64_t longValue) {
+  JNI_CALL_VOID_METHOD(env, jlongRef, "set", "(J)V", longValue);
+}
+
 void SetJNIStringRef(JNIEnv* env,
                      jobject jstringRef,
                      const CefString& stringValue) {
@@ -270,6 +280,25 @@ void SetJNIStringMultiMap(JNIEnv* env,
   }
 }
 
+void* GetJNIByteBufferData(JNIEnv* env, jobject jbyteBuffer) {
+  if (!jbyteBuffer)
+    return nullptr;
+
+  void* data = nullptr;
+  jlong capacity = env->GetDirectBufferCapacity(jbyteBuffer);
+  if (capacity > 0) {
+    data = env->GetDirectBufferAddress(jbyteBuffer);
+  }
+  return data;
+}
+
+size_t GetJNIByteBufferLength(JNIEnv* env, jobject jbyteBuffer) {
+  if (!jbyteBuffer)
+    return 0;
+
+  return static_cast<size_t>(env->GetDirectBufferCapacity(jbyteBuffer));
+}
+
 CefMessageRouterConfig GetJNIMessageRouterConfig(JNIEnv* env, jobject jConfig) {
   CefMessageRouterConfig config;
 
@@ -287,6 +316,127 @@ CefMessageRouterConfig GetJNIMessageRouterConfig(JNIEnv* env, jobject jConfig) {
   return config;
 }
 
+CefRefPtr<CefValue> GetCefValueFromJNIObject(JNIEnv* env, jobject obj) {
+  if (!obj)
+    return nullptr;
+
+  if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/lang/Boolean"))) {
+    return GetCefValueFromJNIBoolean(env, obj);
+  } else if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/lang/Integer"))) {
+    return GetCefValueFromJNIInteger(env, obj);
+  } else if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/lang/Double"))) {
+    return GetCefValueFromJNIDouble(env, obj);
+  } else if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/lang/String"))) {
+    return GetCefValueFromJNIString(env, obj);
+  } else if (env->IsInstanceOf(obj,
+                               ScopedJNIClass(env, "java/nio/ByteBuffer"))) {
+    return GetCefValueFromJNIByteBuffer(env, obj);
+  } else if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/util/Map"))) {
+    return GetCefValueFromJNIMap(env, obj);
+  } else if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/util/List"))) {
+    return GetCefValueFromJNIList(env, obj);
+  } else {
+    return nullptr;
+  }
+}
+
+CefRefPtr<CefValue> GetCefValueFromJNIBoolean(JNIEnv* env, const jobject& obj) {
+  CefRefPtr<CefValue> value = CefValue::Create();
+  value->SetBool(GetJNIBoolean(env, obj));
+  return value;
+}
+
+CefRefPtr<CefValue> GetCefValueFromJNIInteger(JNIEnv* env, const jobject& obj) {
+  CefRefPtr<CefValue> value = CefValue::Create();
+  value->SetInt(GetJNIInteger(env, obj));
+  return value;
+}
+
+CefRefPtr<CefValue> GetCefValueFromJNIDouble(JNIEnv* env, const jobject& obj) {
+  CefRefPtr<CefValue> value = CefValue::Create();
+  value->SetDouble(GetJNIDouble(env, obj));
+  return value;
+}
+
+CefRefPtr<CefValue> GetCefValueFromJNIString(JNIEnv* env, const jobject& obj) {
+  CefRefPtr<CefValue> value = CefValue::Create();
+  value->SetString(GetJNIString(env, static_cast<jstring>(obj)));
+  return value;
+}
+
+CefRefPtr<CefValue> GetCefValueFromJNIByteBuffer(JNIEnv* env,
+                                                 const jobject& obj) {
+  CefRefPtr<CefValue> value = CefValue::Create();
+  CefRefPtr<CefBinaryValue> binary = CefBinaryValue::Create(
+      GetJNIByteBufferData(env, obj), GetJNIByteBufferLength(env, obj));
+  value->SetBinary(binary);
+  return value;
+}
+
+CefRefPtr<CefValue> GetCefValueFromJNIMap(JNIEnv* env, const jobject& obj) {
+  CefRefPtr<CefDictionaryValue> dict = CefDictionaryValue::Create();
+
+  ScopedJNIObjectResult entrySet(env);
+  JNI_CALL_METHOD(env, obj, "entrySet", "()Ljava/util/Set;", Object, entrySet);
+
+  ScopedJNIObjectResult iterator(env);
+  JNI_CALL_METHOD(env, entrySet, "iterator", "()Ljava/util/Iterator;", Object,
+                  iterator);
+
+  jboolean hasNext = JNI_FALSE;
+  JNI_CALL_METHOD(env, iterator, "hasNext", "()Z", Boolean, hasNext);
+
+  while (hasNext == JNI_TRUE) {
+    ScopedJNIObjectResult next(env);
+    JNI_CALL_METHOD(env, iterator, "next", "()Ljava/lang/Object;", Object,
+                    next);
+
+    ScopedJNIObjectResult entryKey(env);
+    JNI_CALL_METHOD(env, next, "getKey", "()Ljava/lang/Object;", Object,
+                    entryKey);
+    CefString key = GetJNIString(env, static_cast<jstring>(entryKey.get()));
+
+    ScopedJNIObjectResult entryValue(env);
+    JNI_CALL_METHOD(env, next, "getValue", "()Ljava/lang/Object;", Object,
+                    entryValue);
+    jobject jvalue = entryValue.get();
+    CefRefPtr<CefValue> cef_value = GetCefValueFromJNIObject(env, jvalue);
+    dict->SetValue(key, cef_value);
+
+    JNI_CALL_METHOD(env, iterator, "hasNext", "()Z", Boolean, hasNext);
+  }
+
+  CefRefPtr<CefValue> value = CefValue::Create();
+  return value;
+}
+
+CefRefPtr<CefValue> GetCefValueFromJNIList(JNIEnv* env, const jobject& obj) {
+  CefRefPtr<CefListValue> list = CefListValue::Create();
+
+  ScopedJNIObjectResult iterator(env);
+  JNI_CALL_METHOD(env, obj, "iterator", "()Ljava/util/Iterator;", Object,
+                  iterator);
+
+  jboolean hasNext = JNI_FALSE;
+  JNI_CALL_METHOD(env, iterator, "hasNext", "()Z", Boolean, hasNext);
+
+  long index = 0;
+  while (hasNext == JNI_TRUE) {
+    ScopedJNIObjectResult next(env);
+    JNI_CALL_METHOD(env, iterator, "next", "()Ljava/lang/Object;", Object,
+                    next);
+    jobject jvalue = next.get();
+    CefRefPtr<CefValue> cef_value = GetCefValueFromJNIObject(env, jvalue);
+    list->SetValue(index, cef_value);
+    index++;
+    JNI_CALL_METHOD(env, iterator, "hasNext", "()Z", Boolean, hasNext);
+  }
+
+  CefRefPtr<CefValue> value = CefValue::Create();
+  value->SetList(list);
+  return value;
+}
+
 jobject NewJNIErrorCode(JNIEnv* env, cef_errorcode_t errorCode) {
   ScopedJNIObjectResult jerrorCode(env);
   switch (errorCode) {
@@ -371,8 +521,6 @@ jobject NewJNIErrorCode(JNIEnv* env, cef_errorcode_t errorCode) {
                ERR_SSL_CLIENT_AUTH_CERT_NEEDED, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_TUNNEL_CONNECTION_FAILED, jerrorCode);
-      JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
-               ERR_NO_SSL_VERSIONS_ENABLED, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_SSL_VERSION_OR_CIPHER_MISMATCH, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
@@ -419,8 +567,6 @@ jobject NewJNIErrorCode(JNIEnv* env, cef_errorcode_t errorCode) {
                ERR_NETWORK_ACCESS_DENIED, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_TEMPORARILY_THROTTLED, jerrorCode);
-      JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
-               ERR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_MSG_TOO_BIG,
@@ -429,10 +575,6 @@ jobject NewJNIErrorCode(JNIEnv* env, cef_errorcode_t errorCode) {
                ERR_WS_PROTOCOL_ERROR, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_ADDRESS_IN_USE, jerrorCode);
-      JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
-               ERR_SSL_HANDSHAKE_NOT_COMPLETED, jerrorCode);
-      JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
-               ERR_SSL_BAD_PEER_PUBLIC_KEY, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
@@ -519,8 +661,6 @@ jobject NewJNIErrorCode(JNIEnv* env, cef_errorcode_t errorCode) {
                ERR_CERT_VALIDITY_TOO_LONG, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_CERTIFICATE_TRANSPARENCY_REQUIRED, jerrorCode);
-      JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
-               ERR_CERT_SYMANTEC_LEGACY, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_CERT_KNOWN_INTERCEPTION_BLOCKED, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_CERT_END,
@@ -561,12 +701,6 @@ jobject NewJNIErrorCode(JNIEnv* env, cef_errorcode_t errorCode) {
                ERR_CONTENT_DECODING_FAILED, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_NETWORK_IO_SUSPENDED, jerrorCode);
-      JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
-               ERR_SYN_REPLY_NOT_RECEIVED, jerrorCode);
-      JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
-               ERR_ENCODING_CONVERSION_FAILED, jerrorCode);
-      JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
-               ERR_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_NO_SUPPORTED_PROXIES, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
@@ -716,8 +850,6 @@ jobject NewJNIErrorCode(JNIEnv* env, cef_errorcode_t errorCode) {
                ERR_DNS_MALFORMED_RESPONSE, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_DNS_SERVER_REQUIRES_TCP, jerrorCode);
-      JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
-               ERR_DNS_SERVER_FAILED, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
                ERR_DNS_TIMED_OUT, jerrorCode);
       JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
@@ -736,6 +868,162 @@ jobject NewJNIErrorCode(JNIEnv* env, cef_errorcode_t errorCode) {
   return jerrorCode.Release();
 }
 
+jobject NewJNIBoolean(JNIEnv* env, const bool value) {
+  ScopedJNIClass cls(env, "java/lang/Boolean");
+  if (!cls)
+    return nullptr;
+
+  jmethodID method =
+      env->GetStaticMethodID(cls, "valueOf", "(Z)Ljava/lang/Boolean;");
+  if (!method)
+    return nullptr;
+
+  return env->CallStaticObjectMethod(cls, method, value ? JNI_TRUE : JNI_FALSE);
+}
+
+jboolean GetJNIBoolean(JNIEnv* env, jobject obj) {
+  if (obj) {
+    jboolean value = JNI_FALSE;
+    JNI_CALL_METHOD(env, obj, "booleanValue", "()Z", Boolean, value);
+    return value;
+  }
+  return JNI_FALSE;
+}
+
+jobject NewJNIInteger(JNIEnv* env, const int value) {
+  ScopedJNIClass cls(env, "java/lang/Integer");
+  if (!cls)
+    return nullptr;
+
+  jmethodID method =
+      env->GetStaticMethodID(cls, "valueOf", "(I)Ljava/lang/Integer;");
+  if (!method)
+    return nullptr;
+
+  return env->CallStaticObjectMethod(cls, method, value);
+}
+
+jint GetJNIInteger(JNIEnv* env, jobject obj) {
+  if (obj) {
+    jint value = 0;
+    JNI_CALL_METHOD(env, obj, "intValue", "()I", Int, value);
+    return value;
+  }
+  return 0;
+}
+
+jobject NewJNIDouble(JNIEnv* env, const double value) {
+  ScopedJNIClass cls(env, "java/lang/Double");
+  if (!cls)
+    return nullptr;
+
+  jmethodID method =
+      env->GetStaticMethodID(cls, "valueOf", "(D)Ljava/lang/Double;");
+  if (!method)
+    return nullptr;
+
+  return env->CallStaticObjectMethod(cls, method, value);
+}
+
+jdouble GetJNIDouble(JNIEnv* env, jobject obj) {
+  if (obj) {
+    jdouble value = 0;
+    JNI_CALL_METHOD(env, obj, "doubleValue", "()D", Double, value);
+    return value;
+  }
+  return 0;
+}
+
+jobject NewJNIByteBuffer(JNIEnv* env, const void* data, size_t size) {
+  ScopedJNIClass cls(env, "java/nio/ByteBuffer");
+  if (!cls)
+    return nullptr;
+
+  jmethodID method =
+      env->GetStaticMethodID(cls, "wrap", "([B)Ljava/nio/ByteBuffer;");
+  if (!method)
+    return nullptr;
+
+  jbyteArray array = env->NewByteArray((jsize)size);
+  if (!array)
+    return nullptr;
+
+  env->SetByteArrayRegion(array, 0, (jsize)size,
+                          reinterpret_cast<const jbyte*>(data));
+  return env->CallStaticObjectMethod(cls, method, array);
+}
+
+jobject NewJNIHashMap(JNIEnv* env) {
+  ScopedJNIClass cls(env, "java/util/HashMap");
+  if (!cls)
+    return nullptr;
+
+  jmethodID method = env->GetMethodID(cls, "<init>", "()V");
+  if (!method)
+    return nullptr;
+
+  return env->NewObject(cls, method);
+}
+
+jobject NewJNIArrayList(JNIEnv* env) {
+  ScopedJNIClass cls(env, "java/util/ArrayList");
+  if (!cls)
+    return nullptr;
+
+  jmethodID method = env->GetMethodID(cls, "<init>", "()V");
+  if (!method)
+    return nullptr;
+
+  return env->NewObject(cls, method);
+}
+
+jobject NewJNIObjectFromCefValue(JNIEnv* env, const CefRefPtr<CefValue> value) {
+  switch (value->GetType()) {
+    case VTYPE_NULL:
+      return nullptr;
+    case VTYPE_BOOL:
+      return NewJNIBoolean(env, value->GetBool());
+    case VTYPE_INT:
+      return NewJNIInteger(env, value->GetInt());
+    case VTYPE_DOUBLE:
+      return NewJNIDouble(env, value->GetDouble());
+    case VTYPE_STRING:
+      return NewJNIString(env, value->GetString());
+    case VTYPE_BINARY:
+      return NewJNIByteBuffer(env, value->GetBinary()->GetRawData(),
+                              value->GetBinary()->GetSize());
+    case VTYPE_DICTIONARY: {
+      jobject jmap = NewJNIHashMap(env);
+      CefRefPtr<CefDictionaryValue> dict = value->GetDictionary();
+      CefDictionaryValue::KeyList keys;
+      dict->GetKeys(keys);
+      for (const CefString& key : keys) {
+        jstring jkey = NewJNIString(env, key);
+        jobject jvalue = NewJNIObjectFromCefValue(env, dict->GetValue(key));
+        JNI_CALL_VOID_METHOD(
+            env, jmap, "put",
+            "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", jkey,
+            jvalue);
+      }
+      return jmap;
+    }
+    case VTYPE_LIST: {
+      jobject jlist = NewJNIArrayList(env);
+      CefRefPtr<CefListValue> list = value->GetList();
+      const size_t size = list->GetSize();
+      for (size_t i = 0; i < size; ++i) {
+        jobject jvalue = NewJNIObjectFromCefValue(env, list->GetValue(i));
+        JNI_CALL_VOID_METHOD(env, jlist, "add", "(Ljava/lang/Object;)Z",
+                             jvalue);
+      }
+      return jlist;
+    }
+    default:
+      NOTREACHED();
+      return nullptr;
+  }
+}
+
 cef_errorcode_t GetJNIErrorCode(JNIEnv* env, jobject jerrorCode) {
   cef_errorcode_t errorCode = ERR_NONE;
 
diff --git a/native/jni_util.h b/native/jni_util.h
index dd9ba18b..6028427c 100644
--- a/native/jni_util.h
+++ b/native/jni_util.h
@@ -39,11 +39,13 @@ jobject NewJNIObject(JNIEnv* env, const char* class_name, const char* sig, ...);
 // Retrieve primitive reference values
 bool GetJNIBoolRef(JNIEnv* env, jobject jboolRef);
 int GetJNIIntRef(JNIEnv* env, jobject jintRef);
+int64_t GetJNILongRef(JNIEnv* env, jobject jlongRef);
 CefString GetJNIStringRef(JNIEnv* env, jobject jstringRef);
 
 // Set primitive reference values
 void SetJNIBoolRef(JNIEnv* env, jobject jboolRef, bool boolValue);
 void SetJNIIntRef(JNIEnv* env, jobject jintRef, int intValue);
+void SetJNILongRef(JNIEnv* env, jobject jlongRef, int64_t longValue);
 void SetJNIStringRef(JNIEnv* env,
                      jobject jstringRef,
                      const CefString& initValue);
@@ -87,12 +89,38 @@ void SetJNIStringMultiMap(JNIEnv* env,
                           jobject jheaderMap,
                           const std::multimap<CefString, CefString>& vals);
 
+void* GetJNIByteBufferData(JNIEnv* env, jobject jbyteBuffer);
+size_t GetJNIByteBufferLength(JNIEnv* env, jobject jbyteBuffer);
+
 CefMessageRouterConfig GetJNIMessageRouterConfig(JNIEnv* env, jobject jConfig);
 
+CefRefPtr<CefValue> GetCefValueFromJNIObject(JNIEnv* env, jobject obj);
+CefRefPtr<CefValue> GetCefValueFromJNIBoolean(JNIEnv* env, const jobject& obj);
+CefRefPtr<CefValue> GetCefValueFromJNIInteger(JNIEnv* env, const jobject& obj);
+CefRefPtr<CefValue> GetCefValueFromJNIDouble(JNIEnv* env, const jobject& obj);
+CefRefPtr<CefValue> GetCefValueFromJNIString(JNIEnv* env, const jobject& obj);
+CefRefPtr<CefValue> GetCefValueFromJNIByteBuffer(JNIEnv* env,
+                                                 const jobject& obj);
+CefRefPtr<CefValue> GetCefValueFromJNIMap(JNIEnv* env, const jobject& obj);
+CefRefPtr<CefValue> GetCefValueFromJNIList(JNIEnv* env, const jobject& obj);
+
 // Create a new JNI error code.
 jobject NewJNIErrorCode(JNIEnv* env, cef_errorcode_t errorCode);
 cef_errorcode_t GetJNIErrorCode(JNIEnv* env, jobject jerrorCode);
 
+jobject NewJNIBoolean(JNIEnv* env, const bool value);
+jobject NewJNIInteger(JNIEnv* env, const int value);
+jobject NewJNIDouble(JNIEnv* env, const double value);
+jobject NewJNIByteBuffer(JNIEnv* env, const void* data, size_t size);
+jobject NewJNIHashMap(JNIEnv* env);
+jobject NewJNIArrayList(JNIEnv* env);
+
+jobject NewJNIObjectFromCefValue(JNIEnv* env, const CefRefPtr<CefValue> value);
+
+jboolean GetJNIBoolean(JNIEnv* env, jobject jbool);
+jint GetJNIInteger(JNIEnv* env, jobject jint);
+jdouble GetJNIDouble(JNIEnv* env, jobject jdouble);
+
 bool GetJNIFieldObject(JNIEnv* env,
                        jclass cls,
                        jobject obj,
diff --git a/native/resource_handler.cpp b/native/resource_handler.cpp
index 1c0d1c54..a8943016 100644
--- a/native/resource_handler.cpp
+++ b/native/resource_handler.cpp
@@ -35,6 +35,36 @@ bool ResourceHandler::ProcessRequest(CefRefPtr<CefRequest> request,
   return (jresult != JNI_FALSE);
 }
 
+bool ResourceHandler::Open(CefRefPtr<CefRequest> request,
+                           bool& handle_request,
+                           CefRefPtr<CefCallback> callback) {
+  ScopedJNIEnv env;
+  if (!env)
+    return false;
+
+  ScopedJNIRequest jrequest(env, request);
+  jrequest.SetTemporary();
+  ScopedJNIBoolRef jhandleRequest(env, handle_request);
+  ScopedJNICallback jcallback(env, callback);
+  jboolean jresult = JNI_FALSE;
+
+  JNI_CALL_METHOD(env, handle_, "open",
+                  "(Lorg/cef/network/CefRequest;Lorg/cef/misc/BoolRef;Lorg/cef/"
+                  "callback/CefCallback;)Z",
+                  Boolean, jresult, jrequest.get(), jhandleRequest.get(),
+                  jcallback.get());
+
+  if (jresult == JNI_FALSE) {
+    // If the Java method returns "false" the callback won't be used and
+    // the reference can therefore be removed.
+    jcallback.SetTemporary();
+  }
+
+  handle_request = jhandleRequest;
+
+  return (jresult != JNI_FALSE);
+}
+
 void ResourceHandler::GetResponseHeaders(CefRefPtr<CefResponse> response,
                                          int64_t& response_length,
                                          CefString& redirectUrl) {
@@ -94,6 +124,78 @@ bool ResourceHandler::ReadResponse(void* data_out,
   return result;
 }
 
+bool ResourceHandler::Read(void* data_out,
+                           int bytes_to_read,
+                           int& bytes_read,
+                           CefRefPtr<CefResourceReadCallback> callback) {
+  ScopedJNIEnv env;
+  if (!env)
+    return false;
+
+  ScopedJNIIntRef jbytesRead(env, bytes_read);
+  jbyteArray jbytes = env->NewByteArray(bytes_to_read);
+  ScopedJNIResourceReadCallback jcallback(env, callback);
+
+  // This callback must retain a reference to the data_out buffer
+  JNI_CALL_VOID_METHOD(env, jcallback.get(), "setBufferRefs", "(J[B)V",
+                       (jlong)data_out, jbytes);
+
+  jboolean jresult = JNI_FALSE;
+
+  JNI_CALL_METHOD(
+      env, handle_, "read",
+      "([BILorg/cef/misc/IntRef;Lorg/cef/callback/CefResourceReadCallback;)Z",
+      Boolean, jresult, jbytes, bytes_to_read, jbytesRead.get(),
+      jcallback.get());
+
+  bytes_read = jbytesRead;
+
+  bool result = (jresult != JNI_FALSE);
+  if (!result || bytes_read > 0) {
+    // The callback won't be used and the reference can therefore be removed.
+    jcallback.SetTemporary();
+  }
+
+  if (bytes_read > 0) {
+    jbyte* jbyte = env->GetByteArrayElements(jbytes, nullptr);
+    if (jbyte) {
+      memmove(data_out, jbyte,
+              (bytes_read < bytes_to_read ? bytes_read : bytes_to_read));
+      env->ReleaseByteArrayElements(jbytes, jbyte, JNI_ABORT);
+    }
+  }
+  env->DeleteLocalRef(jbytes);
+
+  return result;
+}
+
+bool ResourceHandler::Skip(int64_t bytes_to_skip,
+                           int64_t& bytes_skipped,
+                           CefRefPtr<CefResourceSkipCallback> callback) {
+  ScopedJNIEnv env;
+  if (!env)
+    return false;
+
+  ScopedJNILongRef jbytesSkipped(env, bytes_skipped);
+  ScopedJNIResourceSkipCallback jcallback(env, callback);
+  jboolean jresult = JNI_FALSE;
+
+  JNI_CALL_METHOD(
+      env, handle_, "skip",
+      "(JLorg/cef/misc/LongRef;Lorg/cef/callback/CefResourceSkipCallback;)Z",
+      Boolean, jresult, bytes_to_skip, jbytesSkipped.get(), jcallback.get());
+
+  bytes_skipped = jbytesSkipped;
+
+  bool result = (jresult != JNI_FALSE);
+  if (!result || bytes_skipped > 0) {
+    // The callback won't be used and the reference can therefore be removed.
+    jcallback.SetTemporary();
+  }
+
+  return result;
+}
+
 void ResourceHandler::Cancel() {
   ScopedJNIEnv env;
   if (!env)
diff --git a/native/resource_handler.h b/native/resource_handler.h
index bcc2f2cf..bb9c0e11 100644
--- a/native/resource_handler.h
+++ b/native/resource_handler.h
@@ -20,6 +20,9 @@ class ResourceHandler : public CefResourceHandler {
   // CefResourceHandler methods:
   bool ProcessRequest(CefRefPtr<CefRequest> request,
                       CefRefPtr<CefCallback> callback) override;
+  bool Open(CefRefPtr<CefRequest> request,
+            bool& handle_request,
+            CefRefPtr<CefCallback> callback) override;
   void GetResponseHeaders(CefRefPtr<CefResponse> response,
                           int64_t& response_length,
                           CefString& redirectUrl) override;
@@ -27,6 +30,13 @@ class ResourceHandler : public CefResourceHandler {
                     int bytes_to_read,
                     int& bytes_read,
                     CefRefPtr<CefCallback> callback) override;
+  bool Read(void* data_out,
+            int bytes_to_read,
+            int& bytes_read,
+            CefRefPtr<CefResourceReadCallback> callback) override;
+  bool Skip(int64_t bytes_to_skip,
+            int64_t& bytes_skipped,
+            CefRefPtr<CefResourceSkipCallback> callback) override;
   void Cancel() override;
 
  protected:
diff --git a/native/util_mac.mm b/native/util_mac.mm
index f7da32aa..55eac976 100644
--- a/native/util_mac.mm
+++ b/native/util_mac.mm
@@ -456,9 +456,12 @@ void CefShutdownOnMainThread() {
 }
 
 void CefDoMessageLoopWorkOnMainThread() {
-  [[CefHandler class] performSelectorOnMainThread:@selector(doMessageLoopWork)
-                                       withObject:nil
-                                    waitUntilDone:NO];
+  [[CefHandler class]
+      performSelector:@selector(doMessageLoopWork)
+             onThread:[NSThread mainThread]
+           withObject:nil
+        waitUntilDone:NO
+                modes:@[ NSDefaultRunLoopMode, NSEventTrackingRunLoopMode ]];
 }
 
 void SetVisibility(CefWindowHandle handle, bool isVisible) {
diff --git a/third_party/appbundler/README.jcef b/third_party/appbundler/README.jcef
index 0067cccd..2384e4f1 100644
--- a/third_party/appbundler/README.jcef
+++ b/third_party/appbundler/README.jcef
@@ -1,7 +1,7 @@
 Name: Java Application Bundler 
 Short Name: appbundler
 URL: https://github.com/TheInfiniteKind/appbundler/
-Version: 1.0 (commit ad6782ea)
+Version: 1.0 (commit b0857c9b)
 License: GPL-2.0
 
 Description:
@@ -11,7 +11,5 @@ See the project URL for related documentation.
 
 Local Modifications:
 1. Clone the repo using Git.
-2. Apply the Apple Silicon support patch from
-   https://github.com/TheInfiniteKind/appbundler/issues/75
-3. Run `ant` from the top-level directory.
-4. Copy the resulting /appbundler/bin/appbundler-1.0ea.jar file to this directory.
+2. Run `ant` from the top-level directory.
+3. Copy the resulting /appbundler/bin/appbundler-1.0ea.jar file to this directory.
diff --git a/third_party/appbundler/appbundler-1.0.jar b/third_party/appbundler/appbundler-1.0.jar
index 777e3ced..76631982 100644
Binary files a/third_party/appbundler/appbundler-1.0.jar and b/third_party/appbundler/appbundler-1.0.jar differ
diff --git a/third_party/cef/README.jcef b/third_party/cef/README.jcef
index 77e64861..7cac8018 100644
--- a/third_party/cef/README.jcef
+++ b/third_party/cef/README.jcef
@@ -1,6 +1,6 @@
 Name: Chromium Embedded Framework
 Short Name: cef
-URL: https://bitbucket.org/chromiumembedded/cef
+URL: https://github.com/chromiumembedded/cef
 License: BSD
 
 Description:
diff --git a/third_party/jogamp/README.jcef b/third_party/jogamp/README.jcef
index 2953576d..e9080eae 100644
--- a/third_party/jogamp/README.jcef
+++ b/third_party/jogamp/README.jcef
@@ -1,16 +1,20 @@
 Name: Java™ libraries for 3D Graphics, Multimedia and Processing
 Short Name: jogamp
 URL: http://jogamp.org/
-Version: jogl-2.4-b1506-20200306, gluegen-2.4-b937-20200306
+Version: jogl-2.4.0, gluegen-2.4.0
 License: Mixed (see LICENSE.txt files)
 
 Description:
 This library is used to provide OpenGL bindings. Download the platform 7z
-files from https://jogamp.org/deployment/autobuilds/master/ and extract the
+files from https://jogamp.org/deployment/v2.4.0/jar/ and extract the
 required jar files from the jar/ directory.
 
 See http://jogamp.org/wiki/index.php/Downloading_and_installing_JOGL for
 related documentation.
 
 Local Modifications:
-None.
+Patch OSXUtil.DestroyNSWindow in jogl-all.jar to dispatch via
+RunOnMainThread when called from a background thread, matching how
+CreateNSWindow is already handled. The issue includes a script for
+applying this patch to the original 2.4.0 jar version.
+https://github.com/chromiumembedded/java-cef/issues/514#issuecomment-3825848565
diff --git a/third_party/jogamp/jar/gluegen-rt-natives-linux-amd64.jar b/third_party/jogamp/jar/gluegen-rt-natives-linux-amd64.jar
index 826d6d6f..00e9d72c 100644
Binary files a/third_party/jogamp/jar/gluegen-rt-natives-linux-amd64.jar and b/third_party/jogamp/jar/gluegen-rt-natives-linux-amd64.jar differ
diff --git a/third_party/jogamp/jar/gluegen-rt-natives-linux-i586.jar b/third_party/jogamp/jar/gluegen-rt-natives-linux-i586.jar
deleted file mode 100644
index ac9182c4..00000000
Binary files a/third_party/jogamp/jar/gluegen-rt-natives-linux-i586.jar and /dev/null differ
diff --git a/third_party/jogamp/jar/gluegen-rt-natives-macosx-universal.jar b/third_party/jogamp/jar/gluegen-rt-natives-macosx-universal.jar
index b3b3523a..7ad092b3 100644
Binary files a/third_party/jogamp/jar/gluegen-rt-natives-macosx-universal.jar and b/third_party/jogamp/jar/gluegen-rt-natives-macosx-universal.jar differ
diff --git a/third_party/jogamp/jar/gluegen-rt-natives-windows-amd64.jar b/third_party/jogamp/jar/gluegen-rt-natives-windows-amd64.jar
index 2d1fe141..992a5663 100644
Binary files a/third_party/jogamp/jar/gluegen-rt-natives-windows-amd64.jar and b/third_party/jogamp/jar/gluegen-rt-natives-windows-amd64.jar differ
diff --git a/third_party/jogamp/jar/gluegen-rt-natives-windows-i586.jar b/third_party/jogamp/jar/gluegen-rt-natives-windows-i586.jar
deleted file mode 100644
index a0c69317..00000000
Binary files a/third_party/jogamp/jar/gluegen-rt-natives-windows-i586.jar and /dev/null differ
diff --git a/third_party/jogamp/jar/gluegen-rt.jar b/third_party/jogamp/jar/gluegen-rt.jar
index 4c884abe..2025bf87 100644
Binary files a/third_party/jogamp/jar/gluegen-rt.jar and b/third_party/jogamp/jar/gluegen-rt.jar differ
diff --git a/third_party/jogamp/jar/jogl-all-natives-linux-amd64.jar b/third_party/jogamp/jar/jogl-all-natives-linux-amd64.jar
index 55953e23..edc57034 100644
Binary files a/third_party/jogamp/jar/jogl-all-natives-linux-amd64.jar and b/third_party/jogamp/jar/jogl-all-natives-linux-amd64.jar differ
diff --git a/third_party/jogamp/jar/jogl-all-natives-linux-i586.jar b/third_party/jogamp/jar/jogl-all-natives-linux-i586.jar
deleted file mode 100644
index 979fa364..00000000
Binary files a/third_party/jogamp/jar/jogl-all-natives-linux-i586.jar and /dev/null differ
diff --git a/third_party/jogamp/jar/jogl-all-natives-macosx-universal.jar b/third_party/jogamp/jar/jogl-all-natives-macosx-universal.jar
index f295cb02..7dda364c 100644
Binary files a/third_party/jogamp/jar/jogl-all-natives-macosx-universal.jar and b/third_party/jogamp/jar/jogl-all-natives-macosx-universal.jar differ
diff --git a/third_party/jogamp/jar/jogl-all-natives-windows-amd64.jar b/third_party/jogamp/jar/jogl-all-natives-windows-amd64.jar
index 43842503..d8f66a16 100644
Binary files a/third_party/jogamp/jar/jogl-all-natives-windows-amd64.jar and b/third_party/jogamp/jar/jogl-all-natives-windows-amd64.jar differ
diff --git a/third_party/jogamp/jar/jogl-all-natives-windows-i586.jar b/third_party/jogamp/jar/jogl-all-natives-windows-i586.jar
deleted file mode 100644
index 63b5ade5..00000000
Binary files a/third_party/jogamp/jar/jogl-all-natives-windows-i586.jar and /dev/null differ
diff --git a/third_party/jogamp/jar/jogl-all.jar b/third_party/jogamp/jar/jogl-all.jar
index d7bc638e..64503dd4 100644
Binary files a/third_party/jogamp/jar/jogl-all.jar and b/third_party/jogamp/jar/jogl-all.jar differ
diff --git a/tools/distrib/linux32/README.standard.txt b/tools/distrib/linux32/README.standard.txt
index 57010d6d..d5ef07d7 100644
--- a/tools/distrib/linux32/README.standard.txt
+++ b/tools/distrib/linux32/README.standard.txt
@@ -17,4 +17,4 @@ USAGE
 
 Please visit the JCEF Website for additional usage information.
 
-https://bitbucket.org/chromiumembedded/java-cef
+https://github.com/chromiumembedded/java-cef
diff --git a/tools/distrib/linux64/README.standard.txt b/tools/distrib/linux64/README.standard.txt
index c25c9801..f1da2476 100644
--- a/tools/distrib/linux64/README.standard.txt
+++ b/tools/distrib/linux64/README.standard.txt
@@ -17,4 +17,4 @@ USAGE
 
 Please visit the JCEF Website for additional usage information.
 
-https://bitbucket.org/chromiumembedded/java-cef
+https://github.com/chromiumembedded/java-cef
diff --git a/tools/distrib/macosx64/README.standard.txt b/tools/distrib/macosx64/README.standard.txt
index 746a2296..38a3b510 100644
--- a/tools/distrib/macosx64/README.standard.txt
+++ b/tools/distrib/macosx64/README.standard.txt
@@ -18,4 +18,4 @@ USAGE
 
 Please visit the JCEF Website for additional usage information.
 
-https://bitbucket.org/chromiumembedded/java-cef
+https://github.com/chromiumembedded/java-cef
diff --git a/tools/distrib/win32/README.standard.txt b/tools/distrib/win32/README.standard.txt
index 88073a86..b24a0d38 100644
--- a/tools/distrib/win32/README.standard.txt
+++ b/tools/distrib/win32/README.standard.txt
@@ -18,4 +18,4 @@ USAGE
 
 Please visit the JCEF Website for additional usage information.
 
-https://bitbucket.org/chromiumembedded/java-cef
+https://github.com/chromiumembedded/java-cef
diff --git a/tools/distrib/win64/README.standard.txt b/tools/distrib/win64/README.standard.txt
index ef145a94..a17a2576 100644
--- a/tools/distrib/win64/README.standard.txt
+++ b/tools/distrib/win64/README.standard.txt
@@ -18,4 +18,4 @@ USAGE
 
 Please visit the JCEF Website for additional usage information.
 
-https://bitbucket.org/chromiumembedded/java-cef
+https://github.com/chromiumembedded/java-cef
diff --git a/tools/make_docs.bat b/tools/make_docs.bat
index 3365e0f8..7a32b7de 100644
--- a/tools/make_docs.bat
+++ b/tools/make_docs.bat
@@ -11,7 +11,7 @@ cd ..\java
 set OUT_PATH="..\out\docs"
 
 if not exist %OUT_PATH% mkdir %OUT_PATH%
-javadoc -Xdoclint:none -windowtitle "CEF3 Java API Docs" -footer "<center><a href="https://bitbucket.org/chromiumembedded/java-cef" target="_top">Chromium Embedded Framework (CEF)</a> Copyright &copy 2013 Marshall A. Greenblatt</center>" -nodeprecated -d %OUT_PATH% -link http://docs.oracle.com/javase/7/docs/api/ -subpackages org.cef
+javadoc -Xdoclint:none -windowtitle "CEF3 Java API Docs" -footer "<center><a href="https://github.com/chromiumembedded/java-cef" target="_top">Chromium Embedded Framework (CEF)</a> Copyright &copy 2013 Marshall A. Greenblatt</center>" -nodeprecated -d %OUT_PATH% -link http://docs.oracle.com/javase/7/docs/api/ -subpackages org.cef
 
 :end
 endlocal & set RETURNCODE=%ERRORLEVEL%
diff --git a/tools/make_docs.sh b/tools/make_docs.sh
index fb026f12..782ecfe3 100755
--- a/tools/make_docs.sh
+++ b/tools/make_docs.sh
@@ -6,5 +6,5 @@
 DIR="$( cd "$( dirname "$0" )" && cd .. && pwd )"
 OUT_PATH="${DIR}/out/docs"
 
-javadoc --ignore-source-errors -Xdoclint:none -windowtitle "CEF3 Java API Docs" -footer "<center><a href="https://bitbucket.org/chromiumembedded/java-cef" target="_top">Chromium Embedded Framework (CEF)</a> Copyright &copy 2013 Marshall A. Greenblatt</center>" -nodeprecated -d "$OUT_PATH" -sourcepath "${DIR}/java" -link http://docs.oracle.com/javase/7/docs/api/ -subpackages org.cef
+javadoc --ignore-source-errors -Xdoclint:none -windowtitle "CEF3 Java API Docs" -footer "<center><a href="https://github.com/chromiumembedded/java-cef" target="_top">Chromium Embedded Framework (CEF)</a> Copyright &copy 2013 Marshall A. Greenblatt</center>" -nodeprecated -d "$OUT_PATH" -sourcepath "${DIR}/java" -link http://docs.oracle.com/javase/7/docs/api/ -subpackages org.cef