From 3f825e4375c5b3d7e04c2f1ce9f7e1b76841a2bf Mon Sep 17 00:00:00 2001
From: rbalsleyMSFT <53497092+rbalsleyMSFT@users.noreply.github.com>
Date: Tue, 3 Feb 2026 19:06:07 -0800
Subject: [PATCH] Initial docs release
---
docs/M365appsoffice.md | 69 ++
docs/_config.yml | 23 +
docs/_includes/head_custom.html | 145 +++
docs/_includes/page_nav.html | 17 +
docs/applications.md | 21 +
docs/appsscriptvariables.md | 138 +++
docs/assets/js/image-zoom.js | 22 +
docs/assets/js/page-toc.js | 258 ++++++
docs/build.md | 822 ++++++++++++++++++
docs/byoapps.md | 98 +++
docs/drivers.md | 410 +++++++++
docs/hyperv_settings.md | 50 ++
docs/image/Prerequisites/1759527337644.png | Bin 0 -> 75125 bytes
docs/image/applicationscopy/1759882085098.png | Bin 0 -> 393440 bytes
.../appsscriptvariables/1760135511234.png | Bin 0 -> 189802 bytes
.../appsscriptvariablescopy/1760378889283.png | Bin 0 -> 134328 bytes
docs/image/build/1764362222174.png | Bin 0 -> 241433 bytes
docs/image/byoapps/1760117497413.png | Bin 0 -> 299248 bytes
docs/image/drivers/1760488183854.png | Bin 0 -> 289842 bytes
docs/image/drivers/1763794307504.png | Bin 0 -> 299843 bytes
docs/image/quickstart/1769211514092.png | Bin 0 -> 297630 bytes
docs/image/quickstart/1769212208722.png | Bin 0 -> 287916 bytes
docs/image/quickstart/1769218100003.png | Bin 0 -> 288952 bytes
docs/image/quickstart/1769218278316.png | Bin 0 -> 1357065 bytes
docs/image/quickstart/1769222221857.png | Bin 0 -> 145584 bytes
docs/image/quickstart/1769222271610.png | Bin 0 -> 45062 bytes
docs/image/quickstart/1769222319233.png | Bin 0 -> 24404 bytes
docs/image/quickstart/1769222537720.png | Bin 0 -> 61188 bytes
docs/image/ui_overview/1759533067934.png | Bin 0 -> 131901 bytes
docs/image/ui_overview/1759535556990.png | Bin 0 -> 365659 bytes
docs/image/updates/1759878085032.png | Bin 0 -> 126048 bytes
docs/image/updates/1759878277807.png | Bin 0 -> 128734 bytes
docs/image/updatescopy/1759881364454.png | Bin 0 -> 126694 bytes
docs/image/winget/1759883187930.png | Bin 0 -> 28040 bytes
docs/image/winget/1759884200465.png | Bin 0 -> 172786 bytes
docs/image/winget/1759884416556.png | Bin 0 -> 152840 bytes
docs/image/winget/1759884446099.png | Bin 0 -> 20010 bytes
docs/index.md | 27 +
docs/prerequisites.md | 66 ++
docs/quickstart.md | 276 ++++++
docs/ui_overview.md | 14 +
docs/updates.md | 52 ++
docs/windows_settings.md | 147 ++++
docs/winget.md | 118 +++
44 files changed, 2773 insertions(+)
create mode 100644 docs/M365appsoffice.md
create mode 100644 docs/_config.yml
create mode 100644 docs/_includes/head_custom.html
create mode 100644 docs/_includes/page_nav.html
create mode 100644 docs/applications.md
create mode 100644 docs/appsscriptvariables.md
create mode 100644 docs/assets/js/image-zoom.js
create mode 100644 docs/assets/js/page-toc.js
create mode 100644 docs/build.md
create mode 100644 docs/byoapps.md
create mode 100644 docs/drivers.md
create mode 100644 docs/hyperv_settings.md
create mode 100644 docs/image/Prerequisites/1759527337644.png
create mode 100644 docs/image/applicationscopy/1759882085098.png
create mode 100644 docs/image/appsscriptvariables/1760135511234.png
create mode 100644 docs/image/appsscriptvariablescopy/1760378889283.png
create mode 100644 docs/image/build/1764362222174.png
create mode 100644 docs/image/byoapps/1760117497413.png
create mode 100644 docs/image/drivers/1760488183854.png
create mode 100644 docs/image/drivers/1763794307504.png
create mode 100644 docs/image/quickstart/1769211514092.png
create mode 100644 docs/image/quickstart/1769212208722.png
create mode 100644 docs/image/quickstart/1769218100003.png
create mode 100644 docs/image/quickstart/1769218278316.png
create mode 100644 docs/image/quickstart/1769222221857.png
create mode 100644 docs/image/quickstart/1769222271610.png
create mode 100644 docs/image/quickstart/1769222319233.png
create mode 100644 docs/image/quickstart/1769222537720.png
create mode 100644 docs/image/ui_overview/1759533067934.png
create mode 100644 docs/image/ui_overview/1759535556990.png
create mode 100644 docs/image/updates/1759878085032.png
create mode 100644 docs/image/updates/1759878277807.png
create mode 100644 docs/image/updatescopy/1759881364454.png
create mode 100644 docs/image/winget/1759883187930.png
create mode 100644 docs/image/winget/1759884200465.png
create mode 100644 docs/image/winget/1759884416556.png
create mode 100644 docs/image/winget/1759884446099.png
create mode 100644 docs/index.md
create mode 100644 docs/prerequisites.md
create mode 100644 docs/quickstart.md
create mode 100644 docs/ui_overview.md
create mode 100644 docs/updates.md
create mode 100644 docs/windows_settings.md
create mode 100644 docs/winget.md
diff --git a/docs/M365appsoffice.md b/docs/M365appsoffice.md
new file mode 100644
index 0000000..a73027e
--- /dev/null
+++ b/docs/M365appsoffice.md
@@ -0,0 +1,69 @@
+---
+title: M365 Apps/Office
+nav_order: 8
+prev_url: /appsscriptvariables.html
+prev_label: Apps Script Variables
+next_url: /drivers.html
+next_label: Drivers
+parent: UI Overview
+---
+# M365 Apps/Office
+
+
+
+FFU Builder uses the Office Deployment Toolkit (ODT) to install Office. In the `.\FFUDevelopment\Apps\Office` folder you'll find two files:
+
+* `DownloadFFU.xml`
+* `DeployFFU.xml`
+
+## DownloadFFU.xml
+
+`DownloadFFU.xml` is responsible for the download of Office. It's invoked by `setup.exe /download .\DownloadFFU.xml` during the build process. It defaults to downloading the current channel 64-bit version of Office matching the current OS language to `C:\FFUDevelopment\Apps\Office`.
+
+`DownloadFFU.xml` contents:
+
+```
+
+
+
+
+
+
+
+```
+
+If you want to modify the language, you'll need to change the language ID to the language you wish to download and install.
+
+For more information about deploying languages see: [Overview of deploying languages for Microsoft 365 Apps - Microsoft 365 Apps Microsoft Learn](https://learn.microsoft.com/en-us/microsoft-365-apps/deploy/overview-deploying-languages-microsoft-365-apps)
+
+## DeployFFU.xml
+
+`DeployFFU.xml` is responsible for customizing the installation of Office. If you don't provide a custom XML, it will default to using what's in `DeployFFU.xml`. The default configuration will install the 64-bit current channel version of Office with Word, Excel, Powerpoint. Below is what's currently in `DeployFFU.xml`:
+
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+## Copy Office Configuration XML
+
+If you want to include your own custom XML file for office, check **Copy Office Configuration XML** and browse to the location of your custom XML file. The path to your custom Office configuration XML file is stored in the `OfficeConfigXMLFile` parameter. This file gets added to the `.\FFUDevelopment\Apps\Office` folder and is referenced in the `.\FFUDevelopment\Apps\Orchestration\Install-Office.ps1` file.
+
+{% include page_nav.html %}
diff --git a/docs/_config.yml b/docs/_config.yml
new file mode 100644
index 0000000..000d274
--- /dev/null
+++ b/docs/_config.yml
@@ -0,0 +1,23 @@
+title: FFU Builder
+description: Build and deploy Windows FFU images
+remote_theme: just-the-docs/just-the-docs@v0.10.1
+plugins:
+ - jekyll-remote-theme
+ - jekyll-seo-tag
+ - jekyll-sitemap
+
+search_enabled: true
+
+# Because you’ll publish as a project site at /FFU
+baseurl: "/FFU"
+
+callouts:
+ note:
+ title: Note
+ color: purple
+ tip:
+ title: Tip
+ color: green
+ warning:
+ title: Warning
+ color: yellow
diff --git a/docs/_includes/head_custom.html b/docs/_includes/head_custom.html
new file mode 100644
index 0000000..007040b
--- /dev/null
+++ b/docs/_includes/head_custom.html
@@ -0,0 +1,145 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_includes/page_nav.html b/docs/_includes/page_nav.html
new file mode 100644
index 0000000..1c62cde
--- /dev/null
+++ b/docs/_includes/page_nav.html
@@ -0,0 +1,17 @@
+
+
+ {% assign prev_url = include.prev_url | default: page.prev_url %}
+ {% assign prev_label = include.prev_label| default: page.prev_label | default: 'Home' %}
+ {% assign next_url = include.next_url | default: page.next_url %}
+ {% assign next_label = include.next_label| default: page.next_label | default: 'Next' %}
+
+ {% if prev_url %}
+
← {{ prev_label }}
+ {% else %}
+
+ {% endif %}
+
+ {% if next_url %}
+
{{ next_label }} →
+ {% endif %}
+
diff --git a/docs/applications.md b/docs/applications.md
new file mode 100644
index 0000000..c1957ab
--- /dev/null
+++ b/docs/applications.md
@@ -0,0 +1,21 @@
+---
+title: Applications
+nav_order: 4
+prev_url: /updates.html
+prev_label: Updates
+next_url: /winget.html
+next_label: Install Winget Applications
+parent: UI Overview
+has_toc: false
+---
+# Applications
+
+
+
+Applications can be installed in three different ways:
+
+* Winget (using an AppList.json file)
+* Bring Your Own Applications (using files you provide - can also be used to run command lines with or without content)
+* Apps Script Variables (key/value pairs used in conjunction with a PowerShell script to install custom applications)
+
+{% include page_nav.html %}
diff --git a/docs/appsscriptvariables.md b/docs/appsscriptvariables.md
new file mode 100644
index 0000000..cc72681
--- /dev/null
+++ b/docs/appsscriptvariables.md
@@ -0,0 +1,138 @@
+---
+title: Apps Script Variables
+nav_order: 7
+prev_url: /byoapps.html
+prev_label: BYO Applications
+next_url: /M365appsoffice.html
+next_label: M365 Apps Office
+parent: Applications
+grand_parent: UI Overview
+---
+# Apps Script Variables
+
+
+
+Apps Script Variables are key value pairs that are used to create a hashtable that is passed to the `BuildFFUVM.ps1` script (stored in the `$AppScriptVariables` parameter as a hashtable). At build time, `BuildFFUVM.ps1` will export the `$AppsScriptVariables` hashtable to an `AppsScriptVariables.json` file in the `$OrchestrationPath` folder (`$AppsPath\Orchestration`). You can also manually create your own `AppsScriptVariables.json `file and place it in the `$AppsPath\Orchestration` folder.
+
+In the VM, the `Orchestrator.ps1` file will call `Invoke-AppsScript.ps1` if `AppsScriptVariables.json` exists. `Invoke-AppsScript.ps1` must be modified to handle your variables.
+
+`Invoke-AppsScript.ps1` has the following commented example of how to modify the file:
+
+```
+# Example of how to use the AppsScriptVariables hashtable to control script execution
+
+# Note: The UI saves the values as strings, so if you type true for a value, it'll save to the config file as a string, not boolean
+
+# Example: Check if a variable named 'foo' is set to string 'bar' and run a script accordingly
+# if ($AppsScriptVariables['foo'] -eq 'bar') {
+# Write-Host "Foo would have installed"
+# }
+# else {
+# Write-Host "Foo would not have installed"
+# }
+
+# Example: Check if a variable named 'Teams' is set to string 'true' and run a script accordingly
+# if ($AppsScriptVariables['Teams'] -eq 'true') {
+# Write-Host "Teams would have been installed"
+# }
+# else {
+# Write-Host "Teams would not have been installed"
+# }
+```
+
+## Why use Apps Script Variables?
+
+This allows for you to create a dynamic task sequence via a PowerShell script with simple if statements to run apps, commands, etc. This is all driven by your `FFUConfig.json` file. For example, the following `FFUConfig.json` file contains an AppsScriptVariables hashtable of foo and vmwaretools like the screenshot above. If you build servers that require vmware tools, you may set the value to true. However there may be situations where you don't need vmwaretools installed. If that's the case, you set vmwaretools to false. This allows for your `Invoke-AppsScript.ps1` file to stay the same and all you have to do is adjust the variables.
+
+```
+{
+ "AdditionalFFUFiles": [],
+ "AllowExternalHardDiskMedia": false,
+ "AllowVHDXCaching": false,
+ "AppListPath": "C:\\FFUDevelopment\\Apps\\AppList.json",
+ "AppsPath": "C:\\FFUDevelopment\\Apps",
+ "AppsScriptVariables": {
+ "foo": "bar",
+ "vmwaretools": "true"
+ },
+ "BuildUSBDrive": false,
+ "CleanupAppsISO": true,
+ "CleanupCaptureISO": true,
+ "CleanupDeployISO": true,
+ "CleanupDrivers": false,
+ "CompactOS": true,
+ "CompressDownloadedDriversToWim": false,
+ "CopyAdditionalFFUFiles": false,
+ "CopyAutopilot": false,
+ "CopyDrivers": false,
+ "CopyOfficeConfigXML": false,
+ "CopyPEDrivers": false,
+ "CopyPPKG": false,
+ "CopyUnattend": false,
+ "CreateCaptureMedia": true,
+ "CreateDeploymentMedia": true,
+ "CustomFFUNameTemplate": "{WindowsRelease}_{WindowsVersion}_{SKU}_{yyyy}-{MM}-{dd}_{HH}{mm}",
+ "Disksize": 53687091200,
+ "DownloadDrivers": false,
+ "DriversFolder": "C:\\FFUDevelopment\\Drivers",
+ "DriversJsonPath": "C:\\FFUDevelopment\\Drivers\\Drivers.json",
+ "FFUCaptureLocation": "C:\\FFUDevelopment\\FFU",
+ "FFUDevelopmentPath": "C:\\FFUDevelopment",
+ "FFUPrefix": "_FFU",
+ "InjectUnattend": false,
+ "InstallApps": true,
+ "InstallDrivers": false,
+ "InstallOffice": false,
+ "InstallWingetApps": false,
+ "ISOPath": "",
+ "LogicalSectorSizeBytes": 512,
+ "MaxUSBDrives": 5,
+ "MediaType": "Consumer",
+ "Memory": 4294967296,
+ "OfficeConfigXMLFile": "",
+ "OfficePath": "C:\\FFUDevelopment\\Apps\\Office",
+ "Optimize": true,
+ "OptionalFeatures": "",
+ "OrchestrationPath": "C:\\FFUDevelopment\\Apps\\Orchestration",
+ "PEDriversFolder": "C:\\FFUDevelopment\\PEDrivers",
+ "Processors": 4,
+ "ProductKey": "",
+ "PromptExternalHardDiskMedia": true,
+ "RemoveApps": false,
+ "RemoveFFU": false,
+ "RemoveUpdates": false,
+ "ShareName": "FFUCaptureShare",
+ "Threads": 5,
+ "UpdateADK": true,
+ "UpdateEdge": true,
+ "UpdateLatestCU": true,
+ "UpdateLatestDefender": true,
+ "UpdateLatestMicrocode": false,
+ "UpdateLatestMSRT": true,
+ "UpdateLatestNet": true,
+ "UpdateOneDrive": true,
+ "UpdatePreviewCU": false,
+ "USBDriveList": {},
+ "UseDriversAsPEDrivers": false,
+ "UserAppListPath": "C:\\FFUDevelopment\\Apps\\UserAppList.json",
+ "Username": "ffu_user",
+ "Verbose": false,
+ "VMHostIPAddress": "192.168.1.169",
+ "VMLocation": "C:\\FFUDevelopment\\VM",
+ "VMSwitchName": "External",
+ "WindowsArch": "x64",
+ "WindowsLang": "en-us",
+ "WindowsRelease": 11,
+ "WindowsSKU": "Pro",
+ "WindowsVersion": "25H2"
+}
+
+```
+
+Example command line to run with vmwaretools set to false and foo set to foo. This will create the `AppsScriptVariables.json` file in the Orchestration folder with the updated values of `foo=foo` and `vmwaretools=false` without the need to modify the config file.
+
+`.\BuildFFUVM.ps1 -configFile 'C:\FFUDevelopment\config\FFUConfig.json' -appsScriptVariables @{foo='foo'; vmwaretools='false'}`
+
+
+
+{% include page_nav.html %}
diff --git a/docs/assets/js/image-zoom.js b/docs/assets/js/image-zoom.js
new file mode 100644
index 0000000..44e54c8
--- /dev/null
+++ b/docs/assets/js/image-zoom.js
@@ -0,0 +1,22 @@
+(function () {
+ 'use strict';
+
+ function InitImageZoom() {
+ if (window.mediumZoom === undefined) {
+ return;
+ }
+
+ window.mediumZoom('.main-content img:not(.no-zoom):not([src$=".svg"])', {
+ margin: 24,
+ background: 'rgba(0,0,0,0.80)',
+ scrollOffset: 0
+ });
+ }
+
+ if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', InitImageZoom);
+ return;
+ }
+
+ InitImageZoom();
+})();
\ No newline at end of file
diff --git a/docs/assets/js/page-toc.js b/docs/assets/js/page-toc.js
new file mode 100644
index 0000000..8eeba41
--- /dev/null
+++ b/docs/assets/js/page-toc.js
@@ -0,0 +1,258 @@
+(function () {
+ 'use strict';
+
+ function IsRightTocEnabled() {
+ var meta = document.querySelector('meta[name="ffu-right-toc"]');
+ if (meta && meta.content && meta.content.toLowerCase() === 'false') {
+ return false;
+ }
+
+ return true;
+ }
+
+ function GetHeadings(container) {
+ var headings = container.querySelectorAll('h2, h3');
+ var results = [];
+
+ for (var i = 0; i < headings.length; i++) {
+ var heading = headings[i];
+
+ if (heading.classList.contains('no_toc')) {
+ continue;
+ }
+
+ var id = heading.getAttribute('id');
+ if (!id) {
+ continue;
+ }
+
+ var text = (heading.textContent || '').trim();
+ if (!text) {
+ continue;
+ }
+
+ results.push({
+ level: heading.tagName.toLowerCase(),
+ id: id,
+ text: text
+ });
+ }
+
+ return results;
+ }
+
+ function BuildToc(headings) {
+ var nav = document.createElement('nav');
+ nav.className = 'page-toc';
+ nav.setAttribute('aria-label', 'On this page');
+
+ var title = document.createElement('div');
+ title.className = 'page-toc__title';
+ title.textContent = 'In this article';
+ nav.appendChild(title);
+
+ var list = document.createElement('ul');
+ list.className = 'page-toc__list';
+
+ for (var i = 0; i < headings.length; i++) {
+ var item = headings[i];
+
+ var li = document.createElement('li');
+ li.className = 'page-toc__item page-toc__item--' + item.level;
+
+ var a = document.createElement('a');
+ a.className = 'page-toc__link';
+ a.href = '#' + item.id;
+ a.textContent = item.text;
+
+ li.appendChild(a);
+ list.appendChild(li);
+ }
+
+ nav.appendChild(list);
+ return nav;
+ }
+
+ function SetActiveTocLink(toc, activeId) {
+ if (!toc) {
+ return;
+ }
+
+ var links = toc.querySelectorAll('.page-toc__link');
+ for (var i = 0; i < links.length; i++) {
+ var link = links[i];
+ var href = link.getAttribute('href') || '';
+ var isActive = ('#' + activeId) === href;
+
+ if (isActive) {
+ link.classList.add('is-active');
+
+ /* Keep the active item visible inside the TOC panel */
+ try {
+ link.scrollIntoView({ block: 'nearest' });
+ } catch (e) {
+ link.scrollIntoView();
+ }
+ } else {
+ link.classList.remove('is-active');
+ }
+ }
+ }
+
+ function SetupScrollSpy(main, toc, headings) {
+ if (!main || !toc || !headings || headings.length < 1) {
+ return;
+ }
+
+ var headingElements = [];
+ for (var i = 0; i < headings.length; i++) {
+ var el = document.getElementById(headings[i].id);
+ if (el) {
+ headingElements.push(el);
+ }
+ }
+
+ if (headingElements.length < 1) {
+ return;
+ }
+
+ var activeId = null;
+ var ticking = false;
+ var lockActiveUntilMs = 0;
+
+ function IsNearBottomOfPage() {
+ var thresholdPx = 24;
+ var scrollY = window.scrollY || window.pageYOffset || 0;
+ var viewportBottom = scrollY + window.innerHeight;
+ var pageHeight = Math.max(document.documentElement.scrollHeight, document.body.scrollHeight);
+
+ return viewportBottom >= (pageHeight - thresholdPx);
+ }
+
+ function GetCurrentHeadingId() {
+ /* If we're at the bottom, force the last heading active (Learn-like behavior) */
+ if (IsNearBottomOfPage()) {
+ return headingElements[headingElements.length - 1].getAttribute('id');
+ }
+
+ /* Choose the heading closest to the top "activation line" */
+ var activationLine = 16;
+ var current = null;
+
+ for (var i = 0; i < headingElements.length; i++) {
+ var rectTop = headingElements[i].getBoundingClientRect().top;
+
+ if (rectTop <= activationLine) {
+ current = headingElements[i];
+ continue;
+ }
+
+ if (null === current) {
+ current = headingElements[i];
+ }
+
+ break;
+ }
+
+ if (null === current) {
+ current = headingElements[0];
+ }
+
+ return current.getAttribute('id');
+ }
+
+ function Update() {
+ ticking = false;
+
+ if (Date.now() < lockActiveUntilMs) {
+ return;
+ }
+
+ var currentId = GetCurrentHeadingId();
+ if (!currentId || currentId === activeId) {
+ return;
+ }
+
+ activeId = currentId;
+ SetActiveTocLink(toc, activeId);
+ }
+
+ function OnScrollOrResize() {
+ if (ticking) {
+ return;
+ }
+
+ ticking = true;
+ window.requestAnimationFrame(Update);
+ }
+
+ window.addEventListener('scroll', OnScrollOrResize, { passive: true });
+ window.addEventListener('resize', OnScrollOrResize);
+
+ /* Update immediately and also when clicking TOC links */
+ toc.addEventListener('click', function (evt) {
+ var target = evt.target;
+ if (!target || !target.classList || !target.classList.contains('page-toc__link')) {
+ return;
+ }
+
+ var href = target.getAttribute('href') || '';
+ if (href.charAt(0) !== '#') {
+ return;
+ }
+
+ var id = href.substring(1);
+ if (!id) {
+ return;
+ }
+
+ /* Prevent scrollspy from immediately overriding the clicked section */
+ lockActiveUntilMs = Date.now() + 800;
+
+ activeId = id;
+ SetActiveTocLink(toc, activeId);
+ });
+
+ Update();
+ }
+
+ function InitRightToc() {
+ if (!IsRightTocEnabled()) {
+ return;
+ }
+
+ var main = document.querySelector('.main-content main');
+ if (!main) {
+ return;
+ }
+
+ var headings = GetHeadings(main);
+ if (headings.length < 2) {
+ return;
+ }
+
+ var wrap = document.querySelector('.main-content-wrap');
+ var content = document.querySelector('.main-content');
+ if (!wrap || !content) {
+ return;
+ }
+
+ if (wrap.querySelector('.page-toc')) {
+ return;
+ }
+
+ wrap.classList.add('has-page-toc');
+
+ var toc = BuildToc(headings);
+ wrap.appendChild(toc);
+
+ SetupScrollSpy(main, toc, headings);
+ }
+
+ if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', InitRightToc);
+ return;
+ }
+
+ InitRightToc();
+})();
\ No newline at end of file
diff --git a/docs/build.md b/docs/build.md
new file mode 100644
index 0000000..5a39174
--- /dev/null
+++ b/docs/build.md
@@ -0,0 +1,822 @@
+---
+title: Build
+nav_order: 9
+prev_url: /drivers.html
+prev_label: Drivers
+next_url: /monitor.html
+next_label: Monitor
+parent: UI Overview
+---
+# Build
+
+
+
+The Build tab is where the magic happens
+
+## FFU Development Path
+
+The FFU Development path (`$FFUDevelopmentPath`) is the root path of where most other paths are derived. The default is `$PSScriptRoot`, which is the location the script is currently running from and can be changed to another location from within the UI.
+
+If you want to download and test new releases, or want to create a new FFUDevelopment folder without modifying your existing one, you can always download the source files and put them in another location.
+
+The recommendation is to run from `C:\FFUDevelopment` and in most cases the path shouldn't need to be changed.
+
+## Custom FFU Name Template
+
+Controls the `-CustomFFUNameTemplate` parameter. This allows you to define a custom naming convention for the captured FFU file using placeholders that are replaced at build time.
+
+If left blank, the default FFU naming convention is used.
+
+### Available Placeholders
+
+| Placeholder | Description | Example |
+| -------------------- | ---------------------- | ------------------------------------------------------------------------------ |
+| `{WindowsRelease}` | Windows release number | `10`, `11`, `2016`, `2019`, `2022`, `2025` |
+| `{WindowsVersion}` | Windows version | `1607`, `1809`, `21h2`, `22h2`, `23h2`, `24h2` |
+| `{SKU}` | Windows edition | `Home`, `Pro`, `Enterprise`, `Education`, `Standard`, `Datacenter` |
+| `{BuildDate}` | Month and year | `Nov2025` |
+| `{yyyy}` | 4-digit year | `2025` |
+| `{MM}` | 2-digit month | `11` (for November) |
+| `{dd}` | 2-digit day | `28` |
+| `{HH}` | Hour in 24-hour format | `14` (for 2 PM) |
+| `{hh}` | Hour in 12-hour format | `02` (for 2 PM) |
+| `{mm}` | 2-digit minute | `09` |
+| `{tt}` | AM/PM designator | `AM` or `PM` |
+
+### Examples
+
+**Basic template with date and time:**
+
+```
+{WindowsRelease}_{WindowsVersion}_{SKU}_{yyyy}-{MM}-{dd}_{HH}{mm}
+```
+
+Result: `Win11_24h2_Pro_2025-11-28_1425.ffu`
+
+**Template with static text (e.g., indicating Office is installed):**
+
+```
+{WindowsRelease}_{WindowsVersion}_{SKU}_Office_{yyyy}-{MM}-{dd}_{HH}{mm}
+```
+
+Result: `Win11_24h2_Pro_Office_2025-11-28_1425.ffu`
+
+**Simple template with build date:**
+
+```
+{WindowsRelease}_{WindowsVersion}_{SKU}_{BuildDate}
+```
+
+Result: `Win11_24h2_Pro_Nov2025.ffu`
+
+{: .note-title}
+
+> Note
+>
+> The `.ffu` extension is automatically appended if not included in the template.
+
+## FFU Capture Location
+
+The FFU Capture Location sets the `-FFUCaptureLocation` parameter that determines where completed `.ffu` images are written. By default it points to `$FFUDevelopmentPath\FFU`, and the build script creates the folder automatically if it does not already exist.
+
+When apps are installed in a VM, the host converts this folder into a temporary SMB share using the **Share Name** and **Username** fields. The capture WinPE environment maps that share as drive `W:` and streams the captured image directly into this folder. When the build finishes, the share and local account are removed, but the FFU files remain unless a cleanup option deletes them.
+
+Choose a path on fast storage with plenty of free space—the directory must be local to the host running `BuildFFUVM.ps1`, and large captures can easily exceed 25–30 GB. This location also feeds other options such as **Copy Additional FFU Files**, **Build USB Drive**, and **Remove FFU**, so keeping all finished images here keeps those workflows simple.
+
+## Share Name
+
+The Share Name sets the `-ShareName` parameter that defines the name of the temporary SMB share created during the FFU capture process. The default is `FFUCaptureShare`.
+
+During the build, the host creates an SMB share that points to the **FFU Capture Location** and grants access to the temporary local user account defined in **Username**. The capture WinPE environment maps this share as drive `W:` using `net use` and streams the captured FFU image directly to it.
+
+When the build completes, the share is automatically removed along with the temporary user account, leaving only the captured FFU files behind in the FFU Capture Location.
+
+## Username
+
+The Username field sets the `-Username` parameter that `BuildFFUVM.ps1` uses when creating the temporary SMB share user. The value becomes a local standard user account that is granted Full Control on the **FFU Capture Location** share (default C:\FFUDevelopment\FFU) so the capture WinPE session can copy the FFU over `net use `. The default `ffu_user` account name works for most scenarios, but you can supply any other local account name that meets your organization's policies.
+
+When the build starts, the script ensures the account exists, rotates its password to a randomly generated GUID, and grants it access to the share. The Capture WinPE environment maps drive `W:` with those credentials, then writes the captured image directly into the FFU Capture Location.
+
+After the build finishes, the share is removed and the temporary account is deleted, leaving only the FFU files stored in the capture folder.
+
+## Threads
+
+Controls the `-Threads` parameter, which sets the number of parallel threads used for concurrent operations throughout FFU Builder. The default value is **5**.
+
+### Operations Affected by Threads
+
+The Threads value applies to the following parallel operations:
+
+| Operation | Description |
+| -------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| **Winget Application Downloads** | When downloading multiple Winget applications, each application download runs as a parallel task |
+| **BYO Application Copy** | When copying multiple Bring Your Own (BYO) applications to the Apps folder, each copy operation runs in parallel |
+| **Driver Downloads** | When downloading drivers for multiple device models, each driver download and extraction runs as a parallel task |
+
+### Recommended Values
+
+| Threads | Use Case |
+| -------------- | ------------------------------------------------------------------------- |
+| **1** | Minimal system impact; useful for troubleshooting or low-resource systems |
+| **5** | Default; balanced performance for most systems |
+| **8-10** | Higher concurrency for systems with fast storage and network connections |
+
+{: .note-title}
+
+> Note
+>
+> Setting a higher thread count may improve download times but will increase resource utilization. If you experience stability issues or resource constraints, try reducing the thread count.
+
+### Validation
+
+The UI validates that the Threads value is a valid integer greater than or equal to 1. If an invalid value is entered, it automatically resets to **1**.
+
+## BITS Priority
+
+Controls the `-BitsPriority` parameter, which determines the priority level for Background Intelligent Transfer Service (BITS) downloads. The default value is **Normal**.
+
+If you want faster downloads, change the priority to Foreground. Normal priority will significantly slow down downloads since BITS treats non-Foreground downloads as synchronous and queues each download. This means multiple driver or winget application downloads will go much slower than using Foreground. Normal is default as per Microsoft best practice guidance for using BITS.
+
+## Build USB Drive
+
+The following sub-options control how the USB drive is created
+
+### Allow External Hard Disk Media
+
+Controls the `-AllowExternalHardDiskMedia` parameter. When checked, allows the use of drives identified as "External hard disk media" via the WMI class `Win32_DiskDrive`. The default is **unchecked**.
+
+Most USB thumb drives are identified by Windows as "Removable Media" and work with the default settings. However, faster USB drives—such as portable SSDs or high-speed USB 3.x drives—may be identified as "External hard disk media" instead. If you want to use these faster drives for imaging, enable this option.
+
+{: .warning-title}
+
+> Warning
+>
+> Enabling this option may expose external hard drives attached to your machine to the USB imaging process. To prevent accidental data loss, use the **Prompt for External Hard Disk Media** option (enabled by default when this option is checked) to confirm which drive to use before formatting.
+
+### Prompt for External Hard Disk Media
+
+Controls the `-PromptExternalHardDiskMedia` parameter. When checked, prompts for user confirmation before using any drive identified as "External hard disk media". The default is **checked** when **Allow External Hard Disk Media** is enabled.
+
+This option is only available when **Allow External Hard Disk Media** is checked.
+
+When enabled, the build process will:
+
+1. Display a table listing all detected external hard disk media drives, including drive name, serial number, partition style, and status.
+2. Prompt you to select which drive to use for imaging.
+3. Only create a USB drive on the selected drive.
+
+When disabled, the script will not prompt and can use multiple external hard disk drives simultaneously, similar to how removable USB drives function. This is useful for automated or batch imaging scenarios but increases the risk of accidental data loss.
+
+{: .note-title}
+
+> Note
+>
+> If you do not want to be prompted each time, you can disable this option after verifying that only your intended imaging drives are connected.
+
+### Select Specific USB Drives
+
+When checked, enables manual selection of specific USB drives for imaging. The default is **unchecked**.
+
+This option is only available when **Build USB Drive** is checked.
+
+When enabled, a **Check USB drives** button and a list view appear. Click **Check USB drives** to scan for connected USB drives. The list displays all detected drives with the following information:
+
+| Column | Description |
+| ------------------- | ----------------------------------------------------- |
+| **Select** | Checkbox to include or exclude the drive from imaging |
+| **Model** | The model name of the USB drive |
+| **Unique ID** | A unique identifier for the drive |
+| **Size (GB)** | The total capacity of the drive in gigabytes |
+
+Select one or more drives by checking the checkbox in the **Select** column. Only selected drives will be formatted and used for imaging when the build completes.
+
+Use the **Select All** checkbox in the column header to quickly select or deselect all drives.
+
+{: .note-title}
+
+> Note
+>
+> If **Select Specific USB Drives** is unchecked, the build process will automatically use all discovered USB drives.
+
+### Copy Autopilot Profile
+
+Controls the `-CopyAutopilot` parameter. When checked, copies the contents of the `.\FFUDevelopment\Autopilot` folder to the `Autopilot` folder on the Deployment partition of the USB drive. The default is **unchecked**.
+
+This option is only available when **Build USB Drive** is checked.
+
+This leverages the Autopilot for existing devices json file. It's not recommended to use this method any longer as devices enrolled via this method are enrolled as personal instead of corporate.
+
+### Copy Unattend.xml
+
+Controls the `-CopyUnattend` parameter. When checked, copies the architecture-appropriate unattend XML file from `.\FFUDevelopment\Unattend` to an `Unattend` folder on the Deployment partition of the USB drive. The default is **unchecked**.
+
+This option is only available when **Build USB Drive** is checked.
+
+When enabled, the build process copies:
+
+- **unattend_x64.xml** (for x64 builds) or **unattend_arm64.xml** (for arm64 builds) → renamed to **Unattend.xml** on the USB drive
+- **prefixes.txt** (if present) → copied alongside the unattend file
+
+During deployment, `ApplyFFU.ps1` detects the `Unattend` folder and uses these files to customize the device name and apply other Windows settings during OOBE.
+
+#### Device Naming
+
+Device naming can be done from PE. The way this works is by leveraging an unattend.xml file to either take input from the user at imaging time or read a list of prefix values and append the serial number of the device. There are some major benefits to doing this:
+
+1. Total deployment time is reduced if naming is set at FFU deployment time since there is no additional reboot done during OOBE.
+2. Reduces the need for multiple provisioning packages or autopilot profiles. This means you can use a single PPKG or autopilot profile.
+
+#### Prompt for Device Name
+
+If you want to be prompted for the device name, simply check **Copy Unattend.xml.** This tells the build script to copy the appropriate architecture unattend_arch.xml file from the `C:\FFUDevelopment\Unattend` folder to the `.\unattend` folder on the deploy partition of the USB drive.
+
+#### Device Naming with prefixes.txt
+
+If a `prefixes.txt` file exists in the `Unattend` folder and there are multiple prefixes in the file, the deployment script prompts the technician to select a prefix from the file. The prefix is combined with the device's serial number to create the computer name. If there is a single prefix, the technician is not prompted and the script will automatically select that prefix.
+
+For example, with a prefix of `CORP-` and a serial number of `ABC123`, the resulting computer name would be `CORP-ABC123` (truncated to 15 characters if necessary).
+
+Sample `prefixes.txt` content:
+
+```plaintext
+CORP-
+STORE-
+KIOSK-
+```
+
+{: .warning-title}
+
+> Warning
+>
+> If using a provisioning package or autopilot json file, DO NOT specify a name in either of these. They will overwrite the name you have specified in the unattend.xml.
+
+#### Creating Your Unattend Files
+
+The `.\FFUDevelopment\Unattend` folder includes sample files you can customize:
+
+| File | Description |
+| -------------------------------- | ------------------------------------------ |
+| **SampleUnattend_x64.xml** | Example unattend file for x64 systems |
+| **unattend_x64.xml** | Active unattend file used for x64 builds |
+| **unattend_arm64.xml** | Active unattend file used for arm64 builds |
+| **SamplePrefixes.txt** | Example prefixes file for device naming |
+
+Copy and customize the sample files to create your own `unattend_x64.xml`, `unattend_arm64.xml`, and `prefixes.txt` files.
+
+{: .note-title}
+
+> Note
+>
+> The unattend file must contain a `` element in the `Microsoft-Windows-Shell-Setup` component for device naming to work. See the sample files for the correct structure.
+
+### Copy Provisioning Package
+
+Controls the `-CopyPPKG` parameter. When checked, copies the contents of the `.\FFUDevelopment\PPKG` folder to the `PPKG` folder on the Deployment partition of the USB drive. The default is **unchecked**.
+
+This option is only available when **Build USB Drive** is checked.
+
+#### How It Works
+
+1. **During Build**: The build process copies all `.ppkg` files from `.\FFUDevelopment\PPKG` to the USB drive.
+2. **During Deployment**: When `ApplyFFU.ps1` runs, it detects the `PPKG` folder and the provisioning packages within it.
+ - If **multiple** `.ppkg` files are found, the technician is prompted to select which package to apply.
+ - If **one** `.ppkg` file is found, it is automatically selected.
+3. **Application**: The selected provisioning package is copied to the root of the USB drive, where Windows picks it up during OOBE and applies the settings.
+
+### Copy Additional FFU Files
+
+Controls the `-CopyAdditionalFFUFiles` parameter. When checked, allows you to select existing FFU files from the FFU Capture Location to copy to the USB drive alongside the newly built FFU. The default is **unchecked**.
+
+This option is only available when **Build USB Drive** is checked.
+
+#### How It Works
+
+When enabled, an **Additional FFU Files** panel appears below the checkbox with the following controls:
+
+| Control | Description |
+| ----------------------- | ----------------------------------------------------------------------------------------------- |
+| **Refresh** | Scans the FFU Capture Location folder for existing `.ffu` files and populates the list |
+| **FFU Name** | The filename of the FFU file |
+| **Last Modified** | The date and time the FFU file was last modified, useful for identifying the most recent builds |
+
+The list displays all `.ffu` files found in the FFU Capture Location (default `.\FFUDevelopment\FFU`). Click on individual rows to select which FFU files you want to include on the USB drive. Selected files are highlighted in the list.
+
+#### Use Cases
+
+- **Multiple device configurations**: Copy different FFU files for different windows/application configurations (e.g., different versions of windows, different application stacks) to a single USB drive, allowing technicians to choose during deployment.
+- **Previous builds**: Include a known-good FFU from a previous build alongside the new build as a fallback option.
+- **Multi-architecture imaging**: Include both x64 and arm64 FFU files on the same USB drive for mixed-architecture environments.
+
+#### Command Line Usage
+
+When running `BuildFFUVM.ps1` from the command line with `-CopyAdditionalFFUFiles $true` and no `-AdditionalFFUFiles` parameter specified, the script displays an interactive prompt listing all available FFU files in the capture folder. You can:
+
+- Enter numbers separated by commas (e.g., `1,3,5`) to select specific files
+- Enter `A` to select all available files
+- Press **Enter** to skip and not include any additional files
+
+Example command line usage with pre-selected files:
+
+```powershell
+.\BuildFFUVM.ps1 -configFile .\config\FFUConfig.json -CopyAdditionalFFUFiles $true -AdditionalFFUFiles @("C:\FFUDevelopment\FFU\Win11_24h2_Pro_Nov2025.ffu", "C:\FFUDevelopment\FFU\Win11_24h2_Enterprise_Nov2025.ffu")
+```
+
+{: .note-title}
+
+> Note
+>
+> The newly captured FFU from the current build is always copied to the USB drive. Additional FFU files selected here are copied in addition to the new FFU.
+
+### Max USB Drives
+
+Controls the `-MaxUSBDrives` parameter, which sets the maximum number of USB drives to build in parallel. The default value is **5**.
+
+This option is only available when **Build USB Drive** is checked.
+
+When building USB drives, the script processes multiple drives concurrently to speed up imaging. This setting controls how many drives are formatted and copied to simultaneously.
+
+## Compact OS
+
+Controls the `-CompactOS` parameter. When checked, the Windows image is applied using compressed files. The default is **checked**.
+
+### How It Works
+
+When enabled, the build script uses the `-Compact` switch with `Expand-WindowsImage` when applying the Windows image to the OS partition. This compresses Windows system files using Compact OS compression, which reduces the disk footprint of the operating system. On an x64 image, space savings is ~3.5-4GB.
+
+### Benefits
+
+| Benefit | Description |
+| ------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| **Reduced Disk Space** | Windows files are stored in a compressed state, saving several gigabytes of storage |
+| **Smaller FFU Size** | The captured FFU file is smaller because the OS partition contains compressed files |
+| **Faster Deployment** | Smaller FFU files transfer more quickly to USB drives and deploy faster to target devices |
+| **No Performance Impact** | Modern CPUs decompress files faster than they can be read from storage, so performance is maintained |
+
+### When to Disable
+
+You may want to disable Compact OS in the following scenarios:
+
+- **Windows Server builds**: The script automatically disables Compact OS for Windows Server operating systems because the Windows Overlay Filter (wof.sys) is not included in Server SKUs
+- **Troubleshooting**: If you experience issues with specific applications that are incompatible with compressed files
+- **Maximum performance requirements**: In rare cases where every CPU cycle matters
+
+{: .note-title}
+
+> Note
+>
+> Compact OS is automatically disabled when building Windows Server images, regardless of this setting. The script detects Server operating systems and applies the Windows image without compression.
+
+## Update ADK
+
+Controls the `-UpdateADK` parameter. When checked, the script checks for and installs or updates to the latest Windows ADK and WinPE add-on before starting the build. The default is **checked**.
+
+### How It Works
+
+When enabled, the build process performs the following checks before starting:
+
+1. **Version Check**: Queries the [Microsoft ADK installation page](https://learn.microsoft.com/en-us/windows-hardware/get-started/adk-install) to determine the latest available ADK version
+2. **Compare Versions**: Compares the installed ADK and WinPE add-on versions (if present) against the latest available version
+3. **Update if Needed**: If an older version is detected:
+ - Uninstalls the existing Windows ADK
+ - Uninstalls the existing WinPE add-on
+ - Downloads and installs the latest Windows ADK with Deployment Tools feature
+ - Downloads and installs the latest WinPE add-on
+
+### Features Installed
+
+When installing or updating the ADK, the following features are included:
+
+| Component | Feature ID | Description |
+| ---------------------------------- | ---------------------------------------------- | --------------------------------------------------------------- |
+| **Windows Deployment Tools** | `OptionId.DeploymentTools` | Includes DISM, Oscdimg, and other deployment-related tools |
+| **WinPE Environment** | `OptionId.WindowsPreinstallationEnvironment` | Windows Preinstallation Environment used for capture and deploy |
+
+### Installation Location
+
+The ADK is installed to the default location: `C:\Program Files (x86)\Windows Kits\10`
+
+### When to Disable
+
+You may want to disable Update ADK in the following scenarios:
+
+- **Offline or air-gapped environments**: When internet access is not available to download the latest ADK
+- **Controlled ADK versions**: When you need to maintain a specific ADK version for compatibility or compliance reasons
+- **Faster builds**: When you have already verified you are running the latest ADK version and want to skip the version check
+
+{: .warning-title}
+
+> Warning
+>
+> If Update ADK is disabled and the Windows ADK or WinPE add-on is not installed, the build will fail. Ensure you have manually installed the required components before disabling this option.
+
+### Manual ADK Installation
+
+If you prefer to manually install the ADK, visit:
+
+[Download and install the Windows ADK](https://learn.microsoft.com/en-us/windows-hardware/get-started/adk-install)
+
+You must install both:
+
+- Windows Assessment and Deployment Kit (with Deployment Tools feature)
+- Windows PE add-on for the Windows ADK
+
+## Optimize
+
+Controls the `-Optimize` parameter. When enabled, FFU Builder runs the Windows ADK version of DISM to optimize the captured `.ffu` file:
+
+- `DISM /Optimize-FFU /ImageFile:`
+
+This post-processing step typically takes a few minutes and is intended to make FFU images faster to deploy and easier to deploy to differently-sized disks (by allowing the Windows partition to expand or shrink during apply).
+
+**Default:** Enabled (`-Optimize $true`)
+
+### When to Disable
+
+You may want to disable Optimize (`-Optimize $false`) if you are troubleshooting, or if you want to skip the extra post-processing time.
+
+{: .warning-title}
+
+> Warning
+>
+> If you plan to deploy the same FFU to devices with different storage sizes (especially smaller disks), keep `-Optimize` enabled. Non-optimized FFUs are more likely to require additional partition management during deployment.
+
+{: .note-title}
+
+> Note
+>
+> FFU Builder also performs a separate “optimize VHDX before capture” step. That VHDX optimization is independent of `-Optimize`, so you may still see “Optimizing VHDX before capture…” even when `-Optimize` is disabled.
+
+## Allow VHDX Caching
+
+Controls the `-AllowVHDXCaching` parameter. When enabled, FFU Builder caches the base VHDX it creates in `$FFUDevelopmentPath\VHDXCache` and writes a matching `*_config.json` file alongside it. On later builds, if a cached VHDX exists that matches your selected Windows settings and update set, the script reuses it to avoid re-applying the base image and integrating updates again.
+
+**Default:** Disabled (`-AllowVHDXCaching $false`)
+
+### Cache Matching
+
+A cached VHDX is reused only when the cache metadata matches your current build inputs, including:
+
+- Windows release, version, and SKU
+- Logical sector size (512 vs 4096)
+- Optional features selection
+- The exact set of update payload file names downloaded for that run (SSU/CU/.NET/etc.)
+
+### Disk Usage and Cleanup
+
+VHDX caching trades disk space for speed. The `VHDXCache` folder can grow over time as you build different combinations. Periodically check the folder and remove old cached vhdx and config json files as necessary.
+
+{: .note-title}
+
+> Note
+>
+> To force a full rebuild, delete the contents of `$FFUDevelopmentPath\VHDXCache` (or disable **Allow VHDX Caching**) and run the build again.
+
+## Create Capture Media
+
+Controls the `-CreateCaptureMedia` parameter.
+
+When enabled, FFU Builder creates WinPE capture media that is used during VM-based builds (when apps are installed in the VM). FFU Builder attaches this media to the VM and adjusts boot order so the VM can reboot into WinPE and automatically capture the FFU to your **FFU Capture Location**.
+
+The capture media uses the parameter values from `VMHostIPAddress`, `ShareName`, `UserName`, and `CustomFFUNameTemplate` and inserts them into `CaptureFFU.ps1` which is what is responsible for capturing the FFU from the guest VM to the Host.
+
+**Default:** Enabled (`-CreateCaptureMedia $true`)
+
+{: .note-title}
+
+> Note
+>
+> This option is only relevant when **Install Apps** is enabled. If **Install Apps** is enabled, the build forces `-CreateCaptureMedia` to `$true` because capture media is required to capture an FFU from the VM.
+
+{: .tip-title}
+
+> Tip
+>
+> If you just need to re-create media, you can use the `Create-PEMedia.ps1` script to regenerate the capture or deploy ISO using `Create-PEMedia.ps1 -Capture $true` or `CreatePEMedia.ps1 -Deploy $true`.
+
+## Create Deployment Media
+
+Controls the `-CreateDeploymentMedia` parameter.
+
+When enabled, FFU Builder creates WinPE deployment media that is used to deploy an FFU image to a physical device. This media contains the WinPE environment and deployment scripts needed to boot a target machine and apply the FFU image.
+
+The deployment media is saved as an ISO file at `$FFUDevelopmentPath\WinPE_FFU_Deploy_x64.iso` (or `WinPE_FFU_Deploy_arm64.iso` for ARM64 builds). This ISO can then be used with the **Build USB Drive** option to create bootable USB media for physical deployments.
+
+**Default:** Enabled (`-CreateDeploymentMedia $true`)
+
+{: .note-title}
+
+> Note
+>
+> If you only need to capture FFUs from VMs and do not plan to deploy to physical devices, you can disable this option to save time during the build process. However, most scenarios require deployment media for the final step of applying the FFU to target hardware.
+
+{: .tip-title}
+
+> Tip
+>
+> If you just need to re-create media, you can use the `Create-PEMedia.ps1` script to regenerate the capture or deploy ISO using `Create-PEMedia.ps1 -Capture $true` or `CreatePEMedia.ps1 -Deploy $true`.
+
+## Inject Unattend.xml
+
+Controls the `-InjectUnattend` parameter. When checked, copies the architecture-specific unattend XML file from `.\FFUDevelopment\unattend` into the Apps ISO so it's baked into the FFU during the VM build process. The default is **unchecked**.
+
+This option is only available when **Install Apps** is checked.
+
+### How It Works
+
+When enabled, the build process:
+
+1. Determines the correct unattend file based on the target architecture:
+ * **unattend_x64.xml** for x64 builds
+ * **unattend_arm64.xml** for arm64 builds
+2. Creates an `Unattend` folder inside `.\FFUDevelopment\Apps` if it doesn't exist
+3. Copies the architecture-specific unattend file to `.\FFUDevelopment\Apps\Unattend\Unattend.xml`
+4. Includes the unattend file in the Apps ISO, making it available to sysprep during the VM build
+
+The unattend file is then used by sysprep during the specialize phase and/or other OOBE phases when the FFU is deployed.
+
+### Creating Your Unattend Files
+
+Modify the architecture-specific unattend file in the `.\FFUDevelopment\unattend` folder:
+
+| File | Description |
+| ---------------------------- | ----------------------------------- |
+| **unattend_x64.xml** | Unattend file used for x64 builds |
+| **unattend_arm64.xml** | Unattend file used for arm64 builds |
+
+{: .warning-title}
+
+> Important
+>
+> Keep the file names with the architecture suffix (e.g., unattend_x64.xml). The script handles renaming the file to `Unattend.xml` when copying it to the Apps folder.
+
+### When to Use This Option
+
+This option is primarily intended for scenarios where:
+
+* You are **not using the USB drive** to deploy the FFU and use other deployment methods (e.g., network deployment, disk cloning, etc)
+* You want the unattend configuration **baked directly into the FFU** rather than applied at deployment time
+
+### Limitations
+
+| Limitation | Description |
+| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **No prefixes.txt support** | Unlike the**Copy Unattend** option for USB drives, this method does not support `prefixes.txt` for dynamic device naming based on serial numbers |
+| **Fixed configuration** | The unattend settings are baked into the FFU at build time and cannot be changed at deployment time |
+| **Requires VM to be built** | This option only works when**Install Apps** is `$true` because the unattend file is included in the Apps ISO |
+
+{: .note-title}
+
+> Note
+>
+> Most users should continue using the **Copy Unattend** option via the USB drive, which provides more flexibility including support for `prefixes.txt` device naming. Use **Inject Unattend.xml** only when you won't be using the USB drive for deployment.
+
+{: .tip-title}
+
+> Tip
+>
+> If you're using this option, you can disable **Build Deploy ISO** to save time during the build process since the deployment ISO is not needed when you're not using the USB drive method.
+
+## Verbose
+
+Controls the `-Verbose` common parameter. When checked, enables detailed verbose output during the build process. The default is **unchecked**.
+
+In prior builds it was necessary to enable `-verbose` output to track in real-time the build process if you didn't have `cmtrace.exe` or some other log-monitoring tool. With the UI, you can now watch the build in real-time using the monitor tab. Enabling verbose shouldn't be necessary but is available for those who wish to use it.
+
+# Post-Build Cleanup
+
+## Cleanup Apps ISO
+
+Controls the `-CleanupAppsISO` parameter. When checked, the Apps ISO file is automatically deleted after the FFU has been successfully captured. The default is **checked**.
+
+During the build process, when apps are being installed, the script creates an `Apps.iso` file in the FFU Development Path (e.g., `.\FFUDevelopment\Apps.iso`). This ISO contains the contents of the `.\FFUDevelopment\Apps` folder—including application installers, Office deployment files, and orchestration scripts—and is mounted to the VM during the build to install applications.
+
+### When to Disable
+
+You may want to disable Cleanup Apps ISO in the following scenarios:
+
+* **Debugging app installations**: When troubleshooting application installation issues and you want to manually inspect the ISO contents
+* **Multiple builds with same apps**: If you're running consecutive builds with identical app configurations and want to reuse the existing ISO to save time (the script will recreate it if missing)
+* **Archival purposes**: When you need to retain a copy of the exact Apps ISO used for a specific FFU build
+
+{: .note-title}
+
+> Note
+>
+> The Apps ISO is only created when applications are configured for installation. If no apps are being installed in the FFU, this option has no effect. Keeping this option enabled helps conserve disk space by removing temporary build artifacts.
+
+## Cleanup Capture ISO
+
+Controls the `-CleanupCaptureISO` parameter. When checked, the WinPE capture ISO file is automatically deleted after the FFU has been successfully captured. The default is **checked**.
+
+It's recommended to keep this checked as each new build re-creates the local username account (e.g. `ffu_user`) and its password. If you were to retain the capture ISO from a previous build, it'd be using an old password and the capture would fail.
+
+## Cleanup Deploy ISO
+
+Controls the `-CleanupDeployISO` parameter. When checked, the WinPE deployment ISO file is automatically deleted after the FFU has been successfully captured. The default is **checked**.
+
+During the build process, when **Build Deploy ISO** is enabled, the script creates a `WinPE_FFU_Deploy.iso` file (e.g., `.\FFUDevelopment\WinPE_FFU_Deploy.iso`). This ISO contains a customized Windows PE environment used to deploy captured FFU images to target devices. The deployment ISO is typically copied to a bootable USB drive along with the FFU files for field deployment.
+
+### When to Disable
+
+You may want to disable Cleanup Deploy ISO in the following scenarios:
+
+* **Creating deployment media separately**: When you want to create USB deployment drives at a later time (e.g. using `.\FFUDevelopment\USBImagingToolCreator.ps1`)
+* **Testing in Hyper-V**: When deploying FFU images to Hyper-V VMs for testing, you can attach the deploy ISO directly to a VM as a DVD drive
+
+## Cleanup Drivers
+
+Controls the `-CleanupDrivers` parameter. When checked, the contents of the Drivers folder are automatically deleted after the FFU has been successfully captured. The default is **unchecked**.
+
+During the build process, when drivers are configured for installation, the script downloads and extracts driver packages into manufacturer-specific subfolders within the Drivers folder (e.g., `.\FFUDevelopment\Drivers\HP`, `.\FFUDevelopment\Drivers\Dell`). These drivers are then injected into the FFU during the build.
+
+### When to Enable
+
+You may want to enable Cleanup Drivers in the following scenarios:
+
+* **Conserving disk space**: Driver packages can be large (several gigabytes per manufacturer), and removing them after a successful build frees up storage
+* **Ensuring fresh drivers**: When you want each build to download the latest available drivers rather than reusing previously downloaded versions
+* **Single-use builds**: When building an FFU for a one-time deployment and you don't need to retain the driver files
+
+### When to Disable
+
+You may want to keep Cleanup Drivers disabled in the following scenarios:
+
+* **Multiple builds with same drivers**: If you're running consecutive builds targeting the same hardware models, keeping drivers avoids re-downloading them each time
+* **Debugging driver issues**: When troubleshooting driver injection problems and you want to manually inspect the downloaded driver contents
+* **Offline builds**: When building in an environment with limited or no internet access, retaining drivers allows reuse across builds
+* **Bring Your Own Drivers:** When you download and bring your own set of drivers from another source and don't want FFU Builder to remove them
+
+{: .note-title}
+
+> Note
+>
+> Only the contents within the Drivers folder are removed—the folder itself is preserved. If no drivers were downloaded during the build, this option has no effect.
+
+## Remove FFU
+
+Controls the `-RemoveFFU` parameter. When checked, all FFU files in the FFU Capture Location are automatically deleted after the build completes successfully. The default is **unchecked**.
+
+During the build process, the captured FFU image is written to the FFU Capture Location (e.g., `.\FFUDevelopment\FFU`). This option removes all `.ffu` files from that folder after the build finishes, including any previously captured FFU files that may exist in the folder.
+
+### When to Enable
+
+You may want to enable Remove FFU in the following scenarios:
+
+* **USB-only workflow**: When you're using **Build USB Drive** to copy the FFU directly to a USB drive and don't need to retain the FFU file on the host machine
+* **Conserving disk space**: FFU files can be very large depending on what you're installing, and removing them after copying to USB frees up storage
+* **Automated build pipelines**: When running automated builds where the FFU is immediately transferred to another location (such as a network share or deployment server) and no longer needed locally
+
+### When to Disable
+
+You may want to keep Remove FFU disabled in the following scenarios:
+
+* **Archival purposes**: When you want to retain captured FFU images for future deployments or as a backup
+* **Multiple USB drives**: When you need to create additional USB deployment drives at a later time
+* **Testing and validation**: When you want to test the FFU in Hyper-V or other environments before deploying to physical hardware
+
+{: .warning-title}
+
+> Warning
+>
+> This option removes **all** FFU files in the FFU Capture Location folder, not just the FFU from the current build. If you have previously captured FFU files stored in this folder that you want to keep, do not enable this option or move those files to a different location before building.
+
+## Remove Apps Folder Content
+
+Controls the `-RemoveApps` parameter. When checked, application content in the Apps folder is automatically deleted after the FFU has been successfully captured. The default is **un****checked**.
+
+During the build process, application content accumulates in several subfolders within the Apps folder (e.g., `.\FFUDevelopment\Apps`):
+
+| Folder | Contents |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `Win32` | Winget source applications and Bring Your Own Apps content copied using the**Copy Apps** button or manually copied |
+| `MSStore` | Microsoft Store applications downloaded via Winget |
+| `Office` | Microsoft 365 Apps installer files downloaded by the Office Deployment Tool |
+
+Additionally, the `WinGetWin32Apps.json` orchestration file in `.\FFUDevelopment\Apps\Orchestration` is removed. This file is automatically regenerated at build time based on downloaded applications.
+
+When this option is enabled, the cleanup process removes:
+
+* The entire `Win32` folder and its contents
+* The entire `MSStore` folder and its contents
+* The Office download subfolder (`Office\Office`) and the `setup.exe` file within the `Office` folder
+
+### When to Enable
+
+You may want to keep Remove Apps Folder Content enabled in the following scenarios:
+
+* **Conserving disk space**: Downloaded application installers can consume significant storage, and removing them after a successful build frees up space
+* **Ensuring fresh downloads**: When you want each build to download the latest available application versions rather than reusing previously downloaded content
+* **Single-use builds**: When building an FFU for a one-time deployment and you don't need to retain the application files
+
+### When to Disable
+
+You may want to disable Remove Apps Folder Content in the following scenarios:
+
+* **Multiple builds with same apps**: If you're running consecutive builds with identical application configurations, keeping the downloaded content avoids re-downloading applications each time
+* **Debugging app installations**: When troubleshooting application installation issues and you want to manually inspect the downloaded content
+* **Offline builds**: When building in an environment with limited or no internet access, retaining downloaded applications allows reuse across builds
+* **Preserving Bring Your Own Apps**: When you've manually copied application content into the `Win32` folder and don't want FFU Builder to remove it
+
+{: .note-title}
+
+> Note
+>
+> Only the application content subfolders are removed—the `Apps` folder itself and configuration files such as `AppList.json` and `UserAppList.json` are preserved. If no applications were configured for the build, this option has no effect.
+
+## Remove Downloaded Update Files
+
+Controls the `-RemoveUpdates` parameter. When checked, downloaded Windows updates and application update payloads are automatically deleted after the FFU has been successfully captured. The default is **unchecked**.
+
+During the build process, update files are downloaded to specific locations within the `FFUDevelopment` folder:
+
+| Folder | Contents |
+| ----------------- | ---------------------------------------------------------- |
+| `KB` | Windows Cumulative Updates (CU) and .NET Framework updates |
+| `Apps\Defender` | Microsoft Defender definition updates |
+| `Apps\Edge` | Microsoft Edge browser installer |
+| `Apps\MSRT` | Malicious Software Removal Tool updates |
+| `Apps\OneDrive` | Microsoft OneDrive installer |
+
+When this option is enabled, the cleanup process removes the entire `KB` folder and the specific update subfolders within the `Apps` directory.
+
+### When to Enable
+
+You may want to keep Remove Downloaded Update Files enabled in the following scenarios:
+
+* **Conserving disk space**: Windows Cumulative Updates can be several gigabytes in size, and removing them after a successful build frees up significant storage
+* **Ensuring latest updates**: When you want each build to download the absolute latest available updates rather than potentially reusing older cached versions
+
+### When to Disable
+
+You may want to disable Remove Downloaded Update Files in the following scenarios:
+
+* **Multiple builds**: If you're running consecutive builds, keeping the downloaded updates avoids re-downloading large Cumulative Update files each time
+* **Offline builds**: When building in an environment with limited or no internet access, retaining downloaded updates allows reuse across builds
+* **Testing and validation**: When you want to manually inspect the update files that were included in the build
+
+{: .note-title}
+
+> Note
+>
+> Only the update-specific subfolders are removed-the `Apps` folder itself and other application content (unless **Remove Apps Folder Content** is also selected) are preserved.
+
+## Restore Defaults
+
+Use this to restore FFU Builder to its default state. When clicked:
+
+- A confirmation dialog lists what will be removed before anything is deleted.
+ - Generated JSON files are removed (`config\FFUConfig.json`, `Apps\AppList.json`, `Apps\UserAppList.json`, `Drivers\Drivers.json`).
+ - Capture, Deploy, and Apps ISO files are deleted.
+ - Downloaded artifacts are cleared: Apps payloads (Win32, MSStore, Office downloads), update folders under Apps (Defender, Edge, MSRT, OneDrive), driver downloads, and all `.ffu` files in the FFU capture folder.
+ - UI list views (drivers, apps, Winget search results, AppScript variables) are cleared and all controls are reset to their default values.
+
+{: .note-title}
+
+> Note
+>
+> VHDX cache and any custom config files in the `FFUDevelopment\config` folder, and `Drivers\DriverMapping.json` will remain. DriverMapping.json is retained because you may have made custom changes to it and we want to retain those.
+>
+> If you want to keep any content prior to restoring defaults, copy it out first.
+
+## Save Config File
+
+Saves all current UI selections to a JSON file so you can reload the same settings later or run `BuildFFUVM.ps1` from the command line with `-configFile` (e.g. `BuildFFUVM.ps1 -configFile C:\FFUDevelopment\config\FFUConfig.json`)
+
+### How it works
+
+- Collects the full UI state (paths, toggles, driver/app selections, build options) into a single JSON.
+- Defaults the save location to `FFUDevelopmentPath\config` and suggests `FFUConfig.json` as the file name. You can browse and pick a different file name or folder.
+- Creates the `config` folder if it does not exist and confirms the save when finished.
+
+## Load Config File
+
+Loads a previously saved configuration JSON and repopulates the UI.
+
+### How it works
+
+- Click **Load Config File** to browse for a JSON file (for example, `FFUDevelopment\config\FFUConfig.json`).
+- The UI updates with everything from the file: paths, checkboxes, build options, driver/app selections, and USB settings.
+- Supplemental files referenced in the config (Winget `AppList.json`, BYO `UserAppList.json`, `Drivers.json`) are also imported if they exist. Missing helper files are treated as optional and noted for you.
+- If the file is empty, unreadable, or invalid JSON, the load is stopped and an error message is shown.
+
+## Build FFU
+
+Use **Build FFU** to run `BuildFFUVM.ps1` with the current UI selections.
+
+### What happens when you click Build FFU
+
+- The UI gathers all current settings and saves them to `FFUDevelopment\config\FFUConfig.json`, and launches `BuildFFUVM.ps1 -configFile` pointing to that file in a background job. `FFUConfig.json` persists between builds and is read on each opening of `BuildFFUVM_UI.ps1` so you can continue where you left off on each new run.
+- The window switches to the **Monitor** tab so you can watch progress in real time.
+- The progress bar shows overall completion
+- When the job finishes, the button returns to **Build FFU** and the UI is ready for the next run.
+
+### Cancelling a Build
+
+The Build FFU button will change to Cancel while a build is running. Cancelling will do the following:
+
+- The UI stops the background build job and kills any child processes so DISM, downloads, and other tools exit.
+- The in-progress download is always removed to avoid partial or corrupt content.
+- You’re prompted to decide whether to remove other items downloaded during this run. Selecting **Yes** removes only this run’s downloads. Any previously downloaded content stays in place.
+- When cleanup is finished, the Cancel button reverts to Build FFU and a new build can begin
+
+{% include page_nav.html %}
diff --git a/docs/byoapps.md b/docs/byoapps.md
new file mode 100644
index 0000000..007c049
--- /dev/null
+++ b/docs/byoapps.md
@@ -0,0 +1,98 @@
+---
+title: Bring Your Own Applications
+nav_order: 6
+prev_url: /winget.html
+prev_label: Install Winget Applications
+next_url: /appsscriptvariables.html
+next_label: Apps Script Variables
+parent: Applications
+grand_parent: UI Overview
+---
+# Bring Your Own Applications
+
+
+
+Bring Your Own Applications allows you to run any command line you want in the virtual machine to include in your FFU to install an application, run a script, etc. As the name implies, you'll provide the content, command line, arguments, and additional exit codes.
+
+All applications are stored in the `$AppsPath` parent folder which defaults to `C:\FFUDevelopment\Apps`. Winget source applications and BYO Apps that you select Copy Apps are stored in `$AppsPath\Win32`. MSStore source apps from Winget are stored in `$AppsPath\MSStore`.
+
+At build time, an `Apps.iso` file is created of the `$AppsPath` folder. This ISO gets mounted to the VM. It shows up in the VM as the `D:\` drive. When creating your command line or arguments, you must make sure to reference `D:\`.
+
+## Name
+
+The name of the application. The name is also used when selecting **Copy Apps** to copy apps from a source location to the `$AppsPath\Win32\` folder (e.g. `C:\FFUDevelopment\Apps\Win32\Google Chrome`)
+
+## Command Line
+
+This is the full path to the command line to install the application, script, or to run a command. If the content was included in the `$AppsPath` this should start with `D:\` (e.g. `D:\Win32\Mozilla Firefox\Mozilla Firefox_136.0.3_Machine_X64_exe_en-US.exe`)
+
+For MSI applications, this should only include msiexec. The rest of the command line will be specified in arguments.
+
+## Arguments
+
+These are the command line arguments for the application. Using the Mozilla Firefox example above, the arguments would be `/S /PreventRebootRequired=true`.
+
+For MSI applications, this will include `/i` and the full-path to the MSI file plus any additional command line parameters (e.g. `/i "D:\Win32\Google Chrome\Google Chrome_134.0.6998.178_Machine_X64_wix_en-US.msi" /quiet /norestart`)
+
+## Source
+
+This is an optional parameter. This is the local source to the content. It is used by the Copy Apps button to copy from the source location to the `$AppsPath\Win32\` folder. If you don't use the **Copy Apps** button, then you must put the conent in the `$AppsPath` folder manually.
+
+## Additional Exit Codes
+
+This is an optional parameter. Enter a comma-separated list of additional success exit codes if necessary.
+
+## Ignore all non-zero exit codes
+
+If checked, any non-zero exit code will be considered a success.
+
+## Save UserAppList.json
+
+When you're done adding your apps, you must save the `UserAppList.json` file to your `$AppsPath` folder. If you click **Copy Apps**, the `UserAppList.json` file is also saved. The `UserAppList.json` is used by the FFU Builder Orchestrator in the VM to know what to install and when based on the priority of the application.
+
+Below is the `UserAppList.json` of Chrome and Firefox using the example above.
+
+```json
+[
+ {
+ "Priority": 1,
+ "Name": "Google Chrome",
+ "CommandLine": "msiexec",
+ "Arguments": "/i \"D:\\Win32\\Google Chrome\\Google Chrome_134.0.6998.178_Machine_X64_wix_en-US.msi\" /quiet /norestart",
+ "Source": "C:\\temp\\source\\Google Chrome",
+ "AdditionalExitCodes": "",
+ "IgnoreNonZeroExitCodes": false
+ },
+ {
+ "Priority": 2,
+ "Name": "Mozilla Firefox",
+ "CommandLine": "D:\\Win32\\Mozilla Firefox\\Mozilla Firefox_136.0.3_Machine_X64_exe_en-US.exe",
+ "Arguments": "/S /PreventRebootRequired=true",
+ "Source": "C:\\temp\\source\\Mozilla Firefox",
+ "AdditionalExitCodes": "",
+ "IgnoreNonZeroExitCodes": false
+ }
+]
+```
+
+## Import UserAppList.json
+
+You can import a saved `UserAppList.json`
+
+## Edit Application
+
+When you select a single application you can select the **Edit Application** button. This allows you to edit the application information and update the application.
+
+## Copy Apps
+
+If the application source is provided, click **Copy Apps** to copy the application content to the `$AppsPath\Win32` folder (e.g. `C:\FFUDevelopment\Apps\Win32\`). Network shares are supported. When clicking **Copy Apps** the `UserAppList.json` file is automatically created.
+
+## Remove Selected
+
+Removes the selected applications from the list view. Click **Save UserAppList.json** to save the application list.
+
+## Clear List
+
+The **Clear List** button will clear the list view of what’s currently in it. It will not clear the `UserAppList.json` file if it exists.
+
+{% include page_nav.html %}
diff --git a/docs/drivers.md b/docs/drivers.md
new file mode 100644
index 0000000..34b6db2
--- /dev/null
+++ b/docs/drivers.md
@@ -0,0 +1,410 @@
+---
+title: Drivers
+nav_order: 9
+prev_url: /M365appsoffice.html
+prev_label: M365 Apps Office
+next_url: /build.html
+next_label: Build
+parent: UI Overview
+---
+# Drivers
+
+
+
+FFU Builder supports adding drivers directly to the FFU file at build time, or adding them as folders on your USB drive which can be serviced offline after the FFU has been applied to your device.
+
+The UI allows you to download the drivers prior to build and/or create a `Drivers.json` file which can be used to automatically download the drivers at build time. This allows for flexibility in downloading drivers whenever you need them. It supports downloading multiple driver models at once in parallel.
+
+## Drivers Folder
+
+This is the location where drivers are downloaded to, or where you'll manually copy drivers to. The default is `.\FFUDevelopment\Drivers`
+
+## PE Drivers Folder
+
+Path to the folder containing drivers to be injected into the WinPE deployment media. Default is `.\FFUDevelopment\PEDrivers`.
+
+## Drivers.json Path
+
+Path to a JSON file that specifies which drivers to download. Default is `.\FFUDevelopment\Drivers\Drivers.json`
+
+## Download Drivers
+
+FFU Builder can download drivers from the following OEMs:
+
+* Dell
+* HP
+* Lenovo
+* Microsoft
+
+Clicking the **Download Drivers** exposes a **Make:** drop down which lists the above four OEMs and a **Get Models** button
+
+Clicking **Get Models** downloads the list of models from the selected OEM.
+
+The **Model Filter** box allows you to type in a string to filter on the model. The filter should match on any portion of text in the model name.
+
+The model column lists the model name and the System ID (for Dell and HP) or the Machine Type (for Lenovo) in parenthesis. The SystemID/Machine Type values are required to know exactly which set of drivers to download for your model. There typically is a lot of overlap, and sometimes the drivers for the various SystemID/MachineTypes for the same model might be exactly the same, it's still best to grab the SystemID/MachineType before downloading drivers.
+
+To get the System ID:
+
+**HP**
+
+* BIOS/UEFI: Either under Main or System Information (it's going to be different depending on the model) you're looking for the **System Board ID** and it should be a four-character code.
+* PowerShell:`(Get-CimInstance -Namespace 'root\WMI' -Class MS_SystemInformation).BaseboardProduct`
+
+**Dell**
+
+* BIOS/UEFI: I'm not sure if it's possible to get the System ID from the BIOS/UEFI. I seem to recall in some BIOS screenshots that System SKU is listed in some BIOS/UEFI implementations, but it may not be consistent.
+* PowerShell: `(Get-CIMInstance -ClassName "MS_SystemInformation" -NameSpace "root\WMI").SystemSku`
+
+ or
+
+ ```
+ [string]$OEMString = Get-WmiObject -Class "Win32_ComputerSystem" | Select-Object -ExpandProperty OEMStringArray
+ $ComputerDetails.FallbackSKU = [regex]::Matches($OEMString, '\[\S*]')[0].Value.TrimStart("[").TrimEnd("]")
+ ```
+
+**Lenovo**
+
+To find the Machine Type for Lenovo devices, check the bottom/back of the device for the MTM field and capture the first four characters.
+
+* BIOS/UEFI: Look for MTM and grab the first four characters
+* PowerShell: `(Get-CIMInstance -ClassName "MS_SystemInformation" -NameSpace "root\WMI").SystemProductName`
+
+You can multi-select different models within the same make, or mix and match different makes. The screenshot below shows different Dell, HP, Lenovo, and Microsoft models selected
+
+
+
+## Save Drivers.json
+
+After selecting the drivers you want to download, clicking **Save Drivers.json** will prompt you for a location to save the `Drivers.json` file to. The `Drivers.json` file is responsible for telling `BuildFFUVM.ps1` what drivers to download during the build process.
+
+Below is an example of `Drivers.json`:
+
+```
+{
+ "HP": {
+ "Models": [
+ {
+ "Name": "HP EliteBook 865 16 inch G11 Notebook PC",
+ "SystemId": "8d03"
+ }
+ ]
+ },
+ "Dell": {
+ "Models": [
+ {
+ "Name": "Dell Pro Max Desktops Dell Pro Max Micro FCM2250,Dell Pro Max Micro XE FCM2250",
+ "CabUrl": "https://downloads.dell.com/FOLDER13898125M/1/Dell_Pro_Max_Desktops_0D14.cab",
+ "SystemId": "0D14"
+ }
+ ]
+ },
+ "Lenovo": {
+ "Models": [
+ {
+ "Name": "Lenovo 300w Yoga Gen 4",
+ "MachineType": "82VN"
+ }
+ ]
+ },
+ "Microsoft": {
+ "Models": [
+ {
+ "Name": "Surface Pro for Business (11th Edition)",
+ "Link": "https://www.microsoft.com/download/details.aspx?id=108013"
+ }
+ ]
+ }
+}
+```
+
+## Import Drivers.json
+
+Import Drivers.json allows you to import a previously saved Drivers.json file. The models in the Drivers.json file will show up in the list view pre-selected. This will allow you to select additional models and save an updated version of Drivers.json, or to download the selected models by clicking Download Selected.
+
+## Download Selected
+
+Download Selected will download the selected models to the Drivers Folder path (default .\FFUDevelopment\Drivers). Drivers will download the the .\FFUDevelopment\Drivers\Make\Model folder. Download select also interacts with the Compress Driver Model Folder to WIM checkbox which will download and compress the drivers to WIM.
+
+If you've previously downloaded a driver model and want to compress it to a WIM, you can check he Compress Driver Model Folder to WIM checkbox and click Download Selected again. This will skip the download and compress the driver folder to a WIM file.
+
+Download Selected leverages BITS and the BITS Priority can be controlled by the BITS Priority drop down on the Build tab. If driver downloads via the UI feel slow, change BITS Priority to Foreground to speed them up.
+
+## Clear List
+
+Clears the list view of the previous model list
+
+## Install Drivers to FFU
+
+Install Drivers to FFU will recursively add the drivers in the FFUDevelopment\Drivers folder to the FFU file.
+
+It's recommended to only include a single model's drivers in the FFU. This is because dism will add the drivers to the drivers store in the FFU and any additional models that aren't necessary will bloat the drivers store, using up disk space.
+
+If you're dealing with multiple models, it's recommended to select Copy Drivers to USB drive instead.
+
+## Copy Drivers to USB drive
+
+Copy Drivers to USB drive will copy the drivers to the .\Drivers folder on the deploy partition of the USB drive (e.g. D:\Drivers\Make\Model)
+
+If you're manually copying drivers to the .\FFUDevelopment\Drivers folder, you must copy them to the FFUDevelopment\Drivers\Make\Model folder (e.g. FFUDevelopment\Drivers\Lenovo\Lenovo 300w). Prior releases referenced using just .\FFUDevelopment\Drivers\Model, however for better organization and consistency, the code has been updated to require the make folder.
+
+## Compress Driver Model Folder to WIM
+
+Enabling this checkbox compresses the driver model folder to a WIM file after each model finishes downloading (or when an existing model is detected). Every `Drivers\\` directory is captured into a single `\\.wim` using DISM with `Compress:Max`, which dramatically reduces the space required on your USB drive.
+
+1. Select the models you need, check **Compress Driver Model Folder to WIM**, then click **Download Selected**. Fresh downloads are extracted as usual and immediately compressed into their companion `.wim`.
+2. If the model already exists, the download phase is skipped and only the compression runs, so you can rebuild the `.wim` whenever you refresh the folder contents.
+
+By default the extracted folder is deleted after a successful capture so that the `.wim` becomes the canonical artifact. When **Use Drivers Folder as PE Drivers Source** is also checked, the UI keeps the folder in place, writes a `__PreservedForPEDrivers.txt` marker, and lets WinPE driver harvesting reuse the loose INF set.
+
+Additional guidance:
+
+- `DriverMapping.json` is updated to reference the `.wim`, so `Copy Drivers to USB drive`, `BuildFFUVM.ps1 -CopyDrivers`, and the WinPE `ApplyFFU.ps1` flow mount the compressed archive automatically.
+- Watch the Drivers tab status column or `FFUDevelopment_UI.log` for DISM progress and troubleshooting details per model.
+- Ensure the volume hosting `FFUDevelopment\Drivers` has enough free space for both the source folder and the resulting `.wim`.
+- Only applies to drivers from Dell, HP, Lenovo, or Microsoft that are specified in the Drivers.json file. It will not compress models you manually copy to the Drivers folder.
+
+## Copy PE Drivers
+
+When **Copy PE Drivers** is enabled, drivers will be injected into the WinPE deployment media. This ensures that WinPE has the necessary drivers to recognize hardware components like storage controllers, network adapters, and input devices during FFU deployment.
+
+By default, drivers are sourced from the **PE Drivers Folder** (default `.\FFUDevelopment\PEDrivers`). You can manually place drivers in this folder, and they will be injected into the WinPE media during the build process.
+
+### Use Drivers Folder as PE Drivers Source
+
+When **Copy PE Drivers** is checked, an additional sub-option becomes visible: **Use Drivers Folder as PE Drivers Source** .
+
+When this option is enabled, the script bypasses the PE Drivers Folder and instead dynamically builds the WinPE driver set from the main **Drivers Folder**. The script scans all available drivers in the Drivers folder, parses their INF files, and copies only the essential driver types needed for WinPE, including:
+
+* System devices
+* SCSI, RAID, and NVMe controllers
+* Keyboards
+* Mice and other pointing devices
+* Human Interface Devices (HID) for touch support
+
+This eliminates the need to maintain a separate, manually curated `PEDrivers` folder and ensures that WinPE has the necessary drivers based on what you've already downloaded for your target devices.
+
+{: .note-title}
+
+> Note
+>
+> If the PE Drivers folder already contains content when using this option, it will be cleared before the new driver set is copied in.
+>
+> Some drivers may fail to be added during injection, which is expected behavior and can be safely ignored.
+>
+> Network adapters are not included when using the drivers folder as PE drivers source, so if you're using WDS or another network-based solution to copy your FFU and you've modified ApplyFFU.ps1, it's best to not use the **Use Drivers Folder as PE Driver Source** option and just copy in your required PE Drivers to the PE Drivers folder.
+
+## DriverMapping.json
+
+`DriverMapping.json` is an automatically generated file that maps hardware identifiers (like System IDs or Machine Types) to specific driver packages. This file enables the WinPE deployment script (`ApplyFFU.ps1`) to automatically detect your device hardware and apply the correct drivers without manual intervention.
+
+### How it gets created
+
+`DriverMapping.json` is created and updated automatically when you download drivers using the **Download Selected** button on the Drivers tab of the UI, or when drivers are downloaded during the FFU build. Each time you successfully download drivers for a model, the file is updated with the mapping information for that model.
+
+### Automatic Driver Selection During Deployment
+
+When you deploy an FFU using the WinPE media, `ApplyFFU.ps1` looks for `DriverMapping.json` on the USB drive at `D:\Drivers\DriverMapping.json` (where D: is your USB deploy partition). If found, the script:
+
+1. Detects the hardware identifiers of the current device (System ID, Machine Type, etc.)
+2. Searches `DriverMapping.json` for a matching entry
+3. Automatically selects and applies the correct driver package
+4. Falls back to manual driver selection if no match is found
+
+### Required Fields by Manufacturer
+
+Each entry in `DriverMapping.json` contains different required fields depending on the manufacturer:
+
+**All Manufacturers:**
+
+* **Manufacturer** – The OEM name (e.g., "Dell", "HP", "Lenovo", "Microsoft")
+* **Model** – The full model name as it appears in the driver download catalog
+* **DriverPath** – The relative path to the driver folder or WIM file on the USB drive under the Drivers folder (e.g., "Dell\\\Dell Latitude 7490" or "HP\\\HP EliteBook 865 16 inch G11 Notebook PC.wim").
+
+ Relative paths are used since we don't know the drive letter of the USB drive when the `DriverMapping.json` file is created. And since this uses json, the double backslash is intentional since the first slash is an escape character.
+
+**Dell:**
+
+* **SystemId** – The System SKU identifier (e.g., "0819", "0D14"). This is the primary matching field used during deployment. To find your Dell System SKU via PowerShell, run: `(Get-CIMInstance -ClassName "MS_SystemInformation" -NameSpace "root\WMI").SystemSku`
+
+**HP:**
+
+* **SystemId** – The System Board ID, a four-character code (e.g., "8d03", "83D2"). This is the primary matching field used during deployment. To find your HP System Board ID via PowerShell, run: `(Get-CimInstance -Namespace 'root\WMI' -Class MS_SystemInformation).BaseboardProduct`
+
+**Lenovo:**
+
+* **MachineType** – The first four characters of the MTM (Machine Type Model) field (e.g., "82VN", "21JD"). This is the primary matching field used during deployment. To find your Lenovo Machine Type via PowerShell, run: `(Get-CIMInstance -ClassName "MS_SystemInformation" -NameSpace "root\WMI").SystemProductName`
+
+**Microsoft:**
+
+* No additional fields required beyond Manufacturer, Model, and DriverPath. Matching is performed based on the normalized model name.
+
+### Example DriverMapping.json
+
+Below is an example of `DriverMapping.json` with entries for multiple manufacturers:
+
+```
+[
+ {
+ "Manufacturer": "Dell",
+ "Model": "Dell Latitude 7490",
+ "DriverPath": "Dell\\Dell Latitude 7490",
+ "SystemId": "0819"
+ },
+ {
+ "Manufacturer": "Dell",
+ "Model": "Dell Pro Max Desktops Dell Pro Max Micro FCM2250,Dell Pro Max Micro XE FCM2250",
+ "DriverPath": "Dell\\Dell Pro Max Desktops Dell Pro Max Micro FCM2250,Dell Pro Max Micro XE FCM2250.wim",
+ "SystemId": "0D14"
+ },
+ {
+ "Manufacturer": "HP",
+ "Model": "HP EliteBook 865 16 inch G11 Notebook PC",
+ "DriverPath": "HP\\HP EliteBook 865 16 inch G11 Notebook PC.wim",
+ "SystemId": "8D03"
+ },
+ {
+ "Manufacturer": "Lenovo",
+ "Model": "Lenovo 300w Yoga Gen 4",
+ "DriverPath": "Lenovo\\Lenovo 300w Yoga Gen 4",
+ "MachineType": "82VN"
+ },
+ {
+ "Manufacturer": "Microsoft",
+ "Model": "Surface Pro for Business (11th Edition)",
+ "DriverPath": "Microsoft\\Surface Pro for Business (11th Edition)"
+ }
+]
+```
+
+## Bring Your Own Drivers
+
+If you manage models that aren't from Dell, HP, Lenovo or Microsoft, or you want to use different drivers from what FFU Builder downloads, you can copy your own drivers to the `.\FFUDevelopment\Drivers` folder using the `.\FFUDevelopment\Drivers\Make\Model` format, or simply change the Drivers Folder path to the location of your drivers content.
+
+You can also manually create your own DriverMapping.json file for the following makes/manufacturers
+
+| Manufacturer | Match Field | WMI Class | Property |
+| ------------------------------- | ----------- | ------------------------------------------- | ----------------------------------------------- |
+| **Dell** | SystemId | `MS_SystemInformation` (via `root\WMI`) | `SystemSku` |
+| **Dell** (fallback) | SystemId | `Win32_ComputerSystem` | `OEMStringArray` (parsed for bracketed value) |
+| **HP** | SystemId | `MS_SystemInformation` (via `root\WMI`) | `BaseBoardProduct` |
+| **Lenovo** | MachineType | `Win32_ComputerSystem` | `Model` |
+| **Microsoft** | Model | `Win32_ComputerSystem` | `Model` |
+| **Panasonic Corporation** | SystemId | `MS_SystemInformation` (via `root\WMI`) | `BaseBoardProduct` |
+| **Viglen** | SystemId | `Win32_BaseBoard` | `SKU` |
+| **AZW** | SystemId | `MS_SystemInformation` (via `root\WMI`) | `BaseBoardProduct` |
+| **Fujitsu** | SystemId | `Win32_BaseBoard` | `SKU` |
+| **Getac** | SystemId | `MS_SystemInformation` (via `root\WMI`) | `BaseBoardProduct` |
+| **Intel** | Model | `Win32_ComputerSystem` | `Model` |
+| **ByteSpeed** | Model | `Win32_ComputerSystem` | `Model` |
+| **Other** (default) | Model | `Win32_ComputerSystem` | `Model` |
+
+**Notes:**
+
+* Match Field is the name of the field in the `DriverMapping.json` file (e.g. SystemID, MachineType, Model)
+* SystemId is a catch-all term for a unique identifier, however each manufacturer calls this something different and stores them in different places within WMI
+* The Dell (fallback) is used for models where the systemSKU isn't available and the OEMStringArray is parsed via Win32_ComputerSystem
+* The `MS_SystemInformation` class is queried from the `root\WMI` namespace
+* Unless noted, the other WMI classes use the `root\cimv2` namespace
+* All identifiers are normalized to uppercase for matching
+* ByteSpeed systems with "NUC" in the model name are re-mapped to Intel and use `BaseBoardProduct` instead
+* For manufacturers that aren't listed, the default behavior is to use the `Win32_ComputerSystem` `model` string
+
+Below is an example `DriverMapping.json` that includes the additional manufacturers. Note that the model and systemID information is made up and is used only as an example to show how to format the file. You'll need to collect the model or system ID from the locations in the table above and include it in your custom `DriverMapping.json` file. Each entry includes both a WIM and drivers folder for each manufacturer. If you want to include driver WIM files for manufacturers other than Dell, HP, Lenovo, or Microsoft, you'll need to manually compress the drivers folder to a WIM file.
+
+```
+[
+ {
+ "Manufacturer": "Panasonic",
+ "Model": "Toughbook CF-33",
+ "SystemId": "CF-33LEHAGT1",
+ "DriverPath": "Panasonic\\CF-33.wim"
+ },
+ {
+ "Manufacturer": "Panasonic",
+ "Model": "Toughbook FZ-55",
+ "SystemId": "FZ-55DZ0KVM",
+ "DriverPath": "Panasonic\\FZ-55"
+ },
+ {
+ "Manufacturer": "Viglen",
+ "Model": "Genie Desktop Pro",
+ "SystemId": "VGN-GDP-2024",
+ "DriverPath": "Viglen\\GeniePro"
+ },
+ {
+ "Manufacturer": "Viglen",
+ "Model": "Omnino Mini",
+ "SystemId": "VGN-OMN-M1",
+ "DriverPath": "Viglen\\OmninoMini.wim"
+ },
+ {
+ "Manufacturer": "AZW",
+ "Model": "SER5 Pro",
+ "SystemId": "SER5-5800H",
+ "DriverPath": "AZW\\SER5Pro.wim"
+ },
+ {
+ "Manufacturer": "AZW",
+ "Model": "U59 Mini PC",
+ "SystemId": "U59-N5095",
+ "DriverPath": "AZW\\U59"
+ },
+ {
+ "Manufacturer": "Fujitsu",
+ "Model": "LIFEBOOK U9312",
+ "SystemId": "FPCM52921",
+ "DriverPath": "Fujitsu\\LIFEBOOK-U9312"
+ },
+ {
+ "Manufacturer": "Fujitsu",
+ "Model": "ESPRIMO D7010",
+ "SystemId": "D3644-A1",
+ "DriverPath": "Fujitsu\\D7010.wim"
+ },
+ {
+ "Manufacturer": "Getac",
+ "Model": "F110 G6",
+ "SystemId": "F110G6",
+ "DriverPath": "Getac\\F110G6.wim"
+ },
+ {
+ "Manufacturer": "Getac",
+ "Model": "B360 Pro",
+ "SystemId": "B360PRO",
+ "DriverPath": "Getac\\B360Pro"
+ },
+ {
+ "Manufacturer": "Intel",
+ "Model": "NUC13ANHi7",
+ "DriverPath": "Intel\\NUC13"
+ },
+ {
+ "Manufacturer": "Intel",
+ "Model": "NUC12WSHi5",
+ "DriverPath": "Intel\\NUC12.wim"
+ },
+ {
+ "Manufacturer": "ByteSpeed",
+ "Model": "Tera 2450",
+ "DriverPath": "ByteSpeed\\Tera2450.wim"
+ },
+ {
+ "Manufacturer": "ByteSpeed",
+ "Model": "Celeritas X1",
+ "DriverPath": "ByteSpeed\\CeleritasX1"
+ },
+ {
+ "Manufacturer": "Acer",
+ "Model": "TravelMate P214-53",
+ "DriverPath": "Acer\\TMP214"
+ },
+ {
+ "Manufacturer": "ASUS",
+ "Model": "ExpertBook B5402CVA",
+ "DriverPath": "ASUS\\B5402.wim"
+ }
+]
+```
+
+{% include page_nav.html %}
diff --git a/docs/hyperv_settings.md b/docs/hyperv_settings.md
new file mode 100644
index 0000000..0887f1d
--- /dev/null
+++ b/docs/hyperv_settings.md
@@ -0,0 +1,50 @@
+---
+title: Hyper-V Settings
+nav_order: 1
+prev_url: /ui_overview.html
+prev_label: UI Overview
+next_url: /windows_settings.html
+next_label: Windows Settings
+parent: UI Overview
+---
+# Hyper-V Settings
+
+
+
+## VM Switch Name
+
+Drop down of detected VM Switches. There's also an **Other** option which allows you to specify a VM Switch Name. The other option is useful in scenarios where the machine you're running the UI from isn't going to be the machine where you plan to build the FFU from.
+
+## VM Host IP Address
+
+IP address of the selected Hyper-V switch that will be used for FFU capture. The UI will auto-detected this based on the VM Switch that was selected.
+
+If `$InstallApps` is set to `$true`, this parameter must be configured.
+
+## Disk Size (GB)
+
+Size of the virtual hard disk for the virtual machine. Default is a 50GB dynamic disk. You may want to increase the size if you're installing many apps.
+
+## Memory (GB)
+
+Amount of memory to allocate for the virtual machine. Recommended to use 8GB if possible, especially for Windows 11. Default is 4GB.
+
+## Processors
+
+Number of virtual processors for the virtual machine. Recommended to use at least 4. Default is 4.
+
+## VM Location
+
+Default is `$FFUDevelopmentPath\VM`. This is the location of the VHDX that gets created where Windows will be installed to.
+
+## VM Name Prefix
+
+Prefix for the generated VM. Default is _FFU.
+
+## Logical Sector Size
+
+Uint32 value of 512 or 4096. Useful for 4Kn drives or devices shipping with UFS drives. Default is 512.
+
+There is some error-handling in the script that will call out mismatch issues with logical sector size. Unfortunately you will need to create a new FFU with the correct logical sector size as you can't convert a previously created FFU. Most should be fine with 512, but lower-end devices that used to ship with eMMC drives have now shifted to using UFS.
+
+{% include page_nav.html %}
diff --git a/docs/image/Prerequisites/1759527337644.png b/docs/image/Prerequisites/1759527337644.png
new file mode 100644
index 0000000000000000000000000000000000000000..7e21ccf9ed4570a40bc948305482bdd61e932d5e
GIT binary patch
literal 75125
zcmeFZ2UJsO*C>qR>wr3x8AV2_j0i{_L3+suA_f#h=|~U-ks7H1LJ~(&1Qawh=}Hl#
z_a1^2krt%a08)j7gcd?b`%f5WzW1*6-F4Uf*LVMN*L~Jfo^z7(JiG7x?7dGSZo~L
zIK%k}aDDXQRXcw!F1|L-zeAnSd>1Y*b}snxCCgw45f6JKIP$UOt7=b0z-n25fW^;7
zmn|-rA5tfdtEK#!9T}-M5LWZx?%iKb+yiHUy)NuNc2qbi|8_h-D=Q$!q_k%ynH<|#
z)CfDR&9m3sj|jViORjgV*X_lC`Y)F@?T7M6g3;Xx$2~?1tg`R-39EUIQ$57>Nbx-pG^~+H(LOS+!hclO)74@C-4UIr=-3p{HJ=+TRC?R)
zq>%;BJKu#**HbQb;UXa+6pDSdXRXIj&6Pg;dhWm0j7QoRWN~pl^8TC%K0QhpzSE;C
zb*69dTy&n9FxF+DRluMxMa`ksCp|M$;-xU%sPa^?-wKD8WjO08t0MAB9v4>&>~3`K
zPXy%SvJUZIUftgx?i$K7i^|G>`}VC>q4mIYhrA!~EiSHCKD?O`)(oxy-Z%h(;!7Q<
zPf&eA;N!A$62IOU80?6Ce@z%0u$lGv@el4CR@Q
z0zw$p|3UuF)L-DpzANMaqa|~s#RDwQS@t#yfLr$KFjxN7gXO|XBjtdvh?<>vBzi!$
zTC3mhg|MQob00sDf|b-XdJ{6&0$TMUZD%ODr=*>*X0e2oS9M)Y{SJ^XT@nUKF
zLv)`(R@&`}XuBm#pu%=0x7=4iE(U*t~A9ckHNTD^6Ltps&4m&TcgcVg15ET0OfO
z`A2;Wpkt4U+hKeBdwnq9SJg=OhGbF_`AbEvsWNNg$aUf25}V3y?U|H|`H0PaCEJ=c
z`u_UOBpiHKzhb5J>2W{qLB-p3b8pVV*Qe@lky`Fo?pEEkOQTM>WxAp;Ju!Vw@Nec+
zHl-kCq%h%we1(xw5G_g*r*zlircHZpuF)?-oxbk_r_wzw?Fh36aHU?`jr)=|Wq*#a
zaY=@YYeTPGN#&PR&G-Ua{@#$WKUhrEmfCVwq2Rin`Ai
z*M3Jfypy-uW5jO6s;EKwb8W3vw5>}8ThXrKx5(%zayj(6yHN<4SL}A_{RACoqZ;h(
zV`6Wdxu!IXLrB|m^sa?atCNDX4L~8s?~aE3Q1Nj^&Fg6faxGGzHQQWY)p@cvut{%!
zQ8ib`r&JtXL59G|%r0YzVpGT0>vHW0B)RyTYv!sWeBlA6{>)ntxO(CQs}dPaY8h3cp)GdAnpV#U=|U~3Jl?8!okhcykj
zv%=@4Hp-~546_>3;|0{}k>Z{8OdSBjsWTymrv4;`3eqJW{;@t8IJz0sZeg56s>4h=
zM@*XQGl>nug078GGMUJr2r-Wp+&Bk`lN|$jnMiT8)KM_Hz3mw)bUl+DCpKAq{cCj+
zOY>+5_!l?mEaaHft&;Mq^VibOo6XN#dr!)M^Q{6MLGzkLZl!4sc^K`a^c#6*_$dFB
z+6NXvIO&1+eKEP6nIP0mB_dP%0b2>+OPUTp0Ok1OL4AA2u~_jz@7^dOKuvo~anzk{Z?!N@AODd_
z+0`-RIU)U`UyQT7dhB4@Z!6ioBR>BE=x{9!(Xt$8Z4$jv7_qZkf08H=nJX|}JYTnUs*YlekM^bw(SGx7tHMsbq+t1Z%;vkf>kqfClOxUat
z-OVi{;PTjzxnA*3#Tnl;@cg_~r3WqQz^2W7K)g(;hK(y(7yqi~;ld*cw|jLHkV7q6
z_`PnQ^LPlLYJ;=Q8UYV6DOMa2_KUM#NzTh8`rfD|lJxl2M%mRi{%%Esz#nt{uWyLG
z80rJ3&AEwzgBdo4BN1FRKe}hyOG{cd5%Y}{4g@+bGr&@}@lSGb+CLa5$LQ0Em4h8}
zXw5h&-?Vlxx@!hWPio9V>Z$6`5Up1C=7}AbOpvc5Rg*`(VTJZuAFAH#
zO#j%MPVZAS2Zc;qMAW)hE~sJaC1Jrsv=P^&GK3vJ6Z~-PV|7_|U#6d*_7t
zBJTKCn;NL`e1E5ewF>PcRe|Sk7
zzcA(E)%!DWYY=CxJ{}a3fo5j5X%G|P3eD!-qk;~GHsy&`ca5a?1A5&!dPNKBijsybv!S&R%zpj0`fK(Kte;6`!Ao&)l%`+rP(LOB&GS`X2b)4?sbSj{R-IpmgOp~wW#$j04?>s1Ad%Rx_u*5?A4(B
z6NTG#XJ9j@;!~^@kd0A2SGzXisV?VL-xm5_FjviRwfKIYy{pXdhg-GtX%#2b6a4#i
z*sCj$?wL>K=>w(gw*sv+5aW{BS~>WIxSAh}5fVWmjx=0PO?#ISAz`sw3s_8D6syS)
zzSH~RT!jvDYtz_O>itrBm;$
zUlPL`Geg-;B6OtMG6t%T@JX_!P-koXYni+HZwdO`0eI>oCRML&3aOZ)aoxJuexLyl
zh@1CI30Hs_8nB@Tt;I5N$?zk`mjPGm>#A&Bv3x|=uQmQ?>Ylo=BB#nilMfc!xyBW$B1PXf7`+zCOFB5feS`y)vi%&^`KEQ7X8oD_r;
z{Wtg=bc@GpJ;wxExBGYd!~k21e@Sc*sy{69b%7t$JD~z2X=pi&4m|&wx#)Aud7#y(
zKGi_8%D6Pj6z0|YgZPAWHrumwnJ@gteoGMEyLOrra@%ryI;P)s^jhTjx6~)M1jm1M
zcQhJ>L2Qcji)|ZJObp&!bPoH)4XwHT*%9>syB#y}Ze>;!zGW5rQgpLx`a=IHMMgu&
z(5FUnjVXy$NSs}0{{$BmLA&%TMOZ4254v~Y8j1FR>jx}|tb@g3-Fj(lxIm0nO^%SA
z6O>Q*SAz%mhDFydrAHS4VU9c@ZJAaB37T;Q&=fh$ZP}~BLQp~7EOni2!2A?x`rmUY
zHQL(C=3n6p|2=g0Gax=zz~X?2z0%+UX_DY_y9fy)`HFcsM)D4C=;~x
zw|Py$j|vu=%SWjUv~QkBRDi@gR{sY7`IV8W_3iznq>{!$_6uLbQ`dseR{GhAx=EX7
z=z8>yPcv<3Ve`a-z?Ahm&pd(FM5pR3z>uym7at3>`WlO|X1;vPom#;$m#J809}v!X
z4BhWsFw^}otxtFlP@J_^VQRo5lNn^c`Uz0hpClOzF;gbBfKsdIcw>eOZP-oQ%4t9(
zbY4c(p(c5cjG!(SMOltZzKHMtTV??0!
z%f}~iE{>?y(p`9cK!Veg
zFa>;9OQiK~c{*GB?GZkDm8
zM}AEKiQ2C#xhCKd#c}d-cm$q$ebh|_pm>ArcJe@jyq?2^CHG=uAaL*sUVO*xUt98|
z68VrcOJ`1A7xtD9zn#UPmQ8$Rl
z9xjs|w!P8@vE3MHNic1WT$l$;wl5I%N%<}locUjnQQJ19ET8EfERE6O`AHu(@}}A5
z1#)e0z}!(Av8O6V)yfGP(WL6vJP)O;ftb^#R2KDJTj*{IAbf8RF}ZoaVQp40(5BU8
ze&ZNBPa6x5*6_^-NPJT
z{bc5J=nPG$25{{%5~z!SoP=yIyJiNO*>FshmWgs(`KX|@+`gH<{Owt8AfZrZZFbSN
z*ue+GERslTgqYs2{9sQ3rtqHPTEJ!--|tJo=k_!c#;xK@9LvpS6N^7^>aVpw9ClJU%=<0#;+SBPM<
zjw47bPgf-5;+-eO`UkleSI(;dPtFuPd{@Idnkk+7|bk8Y5b_va4Q
zzv;ad=FBT`+-HjpEHNJHwLvrM&=nisI!M^Gta)#6quj%UfoLf#)4La(xP5-l=OF3w
zi1Lcb&Q+f?#PE&-$)P(sl@|h!Y>54pwmB!XAWJ_z>j5G=7>buq((D9py->RbnCbCm
z?~S7tyX_vlE3PfeXE`7|A~&XG{gzj5TUm`O!!P|t4^IgkPmY$Vch~cK$sZtErdRl@cD%hO=~WGM6{6Lc*9WA7&h(}9
z_dF^NuL3B;Rbx0Ya(48Kb`hnmQH|I*sc^4v8vycZ<>-lvb2>5y#59Tj@ibuyTtp7z
z;N|`N;6WZw+}Y6$)D0`*@1wt;20pmsAa(FLQ7vN{;!S9Vs1WMD(uWgeWwC1?Cm
zK!H@>Z94`y^@H(<-2LeyKPQ>_*SPwZ9CI%I&-DM09$EfRO{3OL(Cx=NvGf+@*y%zmOhHJ9
z#Yw@755|~85piLaYFTi1|7~4jZKJWp@LaFk`*WL3uVa~8&vz*W%S%h-F9lQlY!<2a
z8X8D%W|huj$$8vW1vYA>F5hBm{rD3EmD7L!hLcF_?UjGB#iWDBMBaY1t*U@>q>{&ex6{9CWY8k#zrS3s&-A`q8z;HH4-
zY|wN)BGyzwR3!v*yVN~OzmoL)*k;)Dq_&U}Bw)OaRj(j7&6==}7EOq728D)IQIwC&b#
zqn=X=ww6s{qY*HP+26aaq4wqrOX!r4Bz|vSisuO-Mf&|^4b!ClV0x*Zh;;I5EX1Eo
z?`hUExWA?r%>%}GduNbA(dE0Rr74cyO~KjPFB;F>3A3Zf0!VUh0kPj$Xqn@8SH
ztL}R4^xZ?GtSlLw-xAJXU3+TlOnbwPq;&pl6!O#!q`vo5p5NUn`(_Y)hEFF5yEgz6
z*Dbzet4%c5z-V4@!m=llLH65_~0tc_;bZ
zC%keq;nS0BS#c^>NMFfa9vw`Ys&%Ao5M3g&Ng`WorTjh+0fXmRO=6Q27Gf4|UUZ^A
zm=TNUY_F&OEuK?6?j5^lz^7tEmuDp9(PA;I9;ms8-TA2Qm@5{S2n!|6eq@1D&8&VK
zeR-Xe20V&5HtoVvP^56cYRDZP$;I`sE?1d&k%H+W&(avl@N;o)eLX(l`&2BU1Z
z3SVr@ykb#Yf@rAeI^A8+u<)^ym?$OREUNBvg(j%HMjWemt*#I;cvjZ*9}A
z?V=sNS-fQCZOCKfFQnM-V|#HK<7^~ZMfa`^*I7Wk2;!r+Pr
ztvf~&PNivjA%F{Vg3O)+QIAQ7gjDY~`d;I4rcHO4`p5q5c&C0m2q8GK{D+)-N021;
z{<@d}PxL30p3K2sXa#Zh#EN8i0g(Lc7n_z%@E9!?F-p*81YX`3ytb?xdb4t*82R^d
z4j^EScP867?iv$xNGXVc3zzB=tK#QJ*$a>(6m4^o3_j@1a_*%;7gwx)Flm4*~MI4Lvb8!!!caw=?
zXhw+3r8o56>-B`(hJ>d6tDiY#b!dbq+1Kh>@(uD|eTfwi@qb1s><8~k+-
z#zNkw`e(k0vk6|FEg{;0V4W|mJ}iO9oG@;e2Am~dpYLyt!JR!)LRYJMGme@8gY5Ou>^9!oE?@n+qlrF7ho14
zrXFbXTF~f7u{n(_bdQ^{;ATu5sJnu;yXZaNn-!|4EgC!uWl>4SRMA3-^8{x(unW+Y)DGw=S8@f9mIZ!B_8zLRlgmo;j4$5aTWxI`sz5VS~|9e57
zNP@Lg%cvx^4@g9CMvHWX#XsJmW%v3&sQ)iJp?PEvM*T}2s~NL`L3x&1_XUys`}1>s
zNxy^9QsDoV{ZYjxD$Lx>YGnll-M!LGg+4L)d&6Rm$AN)jFs9d+roKrfvqwkLj~zem
zAVF;r+Dyr?L@S6gQZZw$_iIw^v?d
z@Ja6U>1tP!?P+iYkX>{WM=hkP&fBlk8N079Nxaw#n17Lct65ZaEt_S|TG+4D8JlSV
zse^Co!WT_pj)5NJLVADEhGv}Wi622bc@h!`hTgp%ULy-gIukj9+8SHfXSu|#dCD1Z
z2mp*baZ@ei&l3&AvK8Mv(#iQH2{!Z(n!;BHunIda3G(Jt#3Z*k*1U3h!0$fRcg$Nt
zsMCsCzq=~L_PrE~x4&3ogSiPAnS6Q7f$00C3&bX{eYBf=tDGa-w!lo*ULzZ$=MI*J
zNrjhvTR=I5(0e5Moszds{xCzcV%Buh+5b;X71#~sEuj*GtU8?3M$FRz(C$+L=)W&7Lmb0z_|q`sMfiH<&vJbNS}e4?9RtpFUOW5A`zf
zCE4HhrVfQSL3XBTfyU%w}D-5~}3
zT)=<_Jg_54y&X2)T(}&hwTy<(rdL$m=CUBo84X1+7Sa$?7Znw}LcW^%_n4VlOj
zc5f`zKLM){FhUT!lM(kj#VT#^(*vSb1P%9J4c=(vljph$i!TD^*=4o8mW}WwV{G&~
zN;;kVX5p&VC6jt~jIWt|vR;EZ_;MJK_6^$}=BENzWx&{&Yy2c#xu0>%)^^;b-{~hF
z$#7o{u|zSsX(rmnO&ZMOycvPge(ORiID9|0&I30X31!pgvtdxjt;)RtMW%i#Hbqy8
zu1UrKI%RWxJ#;J3{KXrwBrV%|+9t!?i3wjF@|dZ)MO{E4sjvKizMg|I-i(+XiVDS>
z=@hy?kDdux#jkbw|NgQ26A_H5ba*E=V2CHB3eye-_Uw*-@$xI)0vhLJm`N
zwc_EpB8Fd=@+|L)TTs4}K&R36C(Ksuc8vCl(^;XFc6p-{nHbJ)5GuCz6V5Kfrufnm
zxoGKTI5`)?kIkAL>j2|64OLL%-o`=N#0XUITDH5XoW_G2@}VMA%+KhthWr
zcnLL=-Hq~VU}V*)TLRAQs2?J_+!eC=)S`r!p3G(NxKUu-t>lx=gO|4
z=RYXlMlw43anA`7VNCzbYZ+U#&j84X3ws|kiRfCdJuxA??n7%H$%2ukHAx_cE<8()
z3X%-Jk_WmNI$AUVL@Fs1Tt6&YIFqqK1TJ4T)1S*mWjR8_JV!a#{TX`8WMg%R1JBKi
z`%WPCrs2yHFQ+HdC(>B
zc+}2fsmu#;O2=YkHl%TVkC9ip*MX8w((wYE)K+aKUd1nDBqm93^XndX!T6;(l`?h$
zB(_CV#E2x(+rG1|W!D?LoHUV-n$j%H#V<%m31;*|%<#!y!7^!>aTVguiVUcsV1&>bueb&N6e^Szn^X?oJ
zq&6Q;C)Y2&8db}tggup41MMw7*i){4qN<6D+o;8XzfV}eYzyeic5HR8|jJQ-gE!qxF(37E9YDQS*!
z)u4G9?y+N=IA^kcwi;s6-FBxXMRgLjH+1ciFS~r)N{!CztAG6Vm@i6jq
zD1MhETQE&*S>XE|8!gjxgOqYcl^d&Brdcvc>+B3HXvRhK6%Opr^+<@Q>}`s~Kpg~x
zl#}6|3c8J*V$v8?dzXs?AZ>NHCN_jql@M~ZIN3rThtR#GQG
zgp6(L&!v#cE26F4A;%LFv1XhO70#Gdo^r7N*{Bghn+&&G{Sh+tzE!E1kM`A<*MRX=
zm5IG=QE>sB7!%6;5b4`wo(b_TTqOS7AddJW?wHWi=UI&O#vQqzBw1VA;2r}W=ZQu0
zXMNEN>1J9UvD2Doqt-^D)_P!-1^pfz)4J1e*T?efT-Th4y~c-pDrTXX7f5!{6ya%;
zsvsrtv08TCgr~C+@Wtf8at
zt$3VqpEqa2y?#)E4mY+f)QuuBRF6a*t?*Y)s3cr*542!#e{Mm0CBo=%>DqR7OpN*4j{X#1NOC2=Jpe`!)+Fqv{Pa!|vLr%`OnLgNklC=SJ99do0?F
z|7wsQ@1&(1{yURE6xuw#9EQ2b=ge5|Tpzxu5%pkjaRYRnPg23QOv>%_%TF%}Hcg#3
z>dgov4{o28X?-p%5wNydJs&*pe^|e-#Nl8Jn<@1+KBL|#YwBlciyoF
z^7I<8t3pE8k$Z!lnaL;Jg#2Vvwka>Jp~EPhZK)c4h?wgzeNxP(WV`&bGK5m#^P@$s
z$p_T)g+YpR;t>+}PCl+WA)jYKJY4hQa7jmmk9Q|huko(9j~>PJXAvesLl&BxBQX@LXTPWFx856N?ILwk#?oAf89JW^!AV0g`0V?nCLr={0|_@i7|E43IoG9;y^qz>2!GE_8hUTfBRT9o5>hKH
z`9ea^8H}6mlZ{$~ts*Ro1qUCH3nw2^XKdKyNH#&BvuB1r
zE3)7Rba5YyG7Q=}{&|)oAAR#>6^y6_+{_0An
zS)ZNgxJbk36L7Mf{M3c28Fsu+wZTA7t=`5!tD>#=Fky0Ku@!)N7VCr+is*c|F|JQn
z?@o{R*_DS)Q)XTy2#P;MpS&)-w-H@wkl!%Wye|AyAS>T*+t5s36O^&tDrWwZ6TX7q
z;pLBbGyP`k=We>bQw!ON@hA`QfKC5Q5W6a{uG_f!6r6PH*ZKLZ1j0e}6~N@t`je`8
z2St9437!9NnC;(xB2#FIy7$#r$L6}-D$q$bFeVD$O^2GWecGm;w^z8^~PA9ju9O|6oJP;!w2t?rq-?6H0ndu{sIkv8cY
z@X~uR&{OlP{dn5kH_emcfi9g5^|waP*zIp#mm$^mUr54J=IQtHdLdORU~7dmHCGp`
z15R(VB5CClO|hTmN)|JfUa8exwn?h$ceub<*6(zp>~Y^pO1#VsWW>LYopoY%TGjrP
zX0;5wJwvX#wIrKDUydeU@AAH7P;D(1bWHLZ@&ns=TZ1B~k@bu_9p+4D1W%NKG6Gq6
zva5s}r)0(7uwJx))G74OYxUcXJC`lN+(!L~Q1@IdFh&=>(PK=|A!&kJQ@b;zR`p%q
z<-w~nN6>Yc9JIFDH{b6R610c5m&q6^49T57S|}RaCuUQ_TI_cVn5ws%(xXmRyKdLe
zGkoct(et5r6njGguF=O<|D0bx)=$O|cBDg$7BU%2n~pG_(W>9?Zx)vD*tS^rQ`WsH`gxicbx3c_C^v;)k39mxxyc^r}%@q(5t;ydfg;$e>;4VOk`SPL)5$k_cHOv-R~bo6qcoi%){O}UYpV8ad$c8&*(
zd0%U2A*AqeB1Q?bn2+l-%@|-bUGb*sZ5F`yd6C4{7`0}-Z`Rq1tAFP*KNyMZ=6cOG
zBMf=)jj(>P@lT3KGQXbrKE3@u2<7u7(9v_LPMt*;B?600{c6wahz8&IHRQi$4Ld_^R47-RKfRKd)SQG
zMFDN*w?#8Gf8z>nW~T|G_AzB5iJ9YR2~D3RROj9%Pm6
z?YH`a`X4GQFR}OyV%Do!(jsKNa4F_HG8=j_#X!I>)z!=18E|6mkh*-45%S2u+uJ7f
zs^g!|bwU=_JlEG(wtlYAl%jD&FoYO@tu$ISiL5zOC;bm#e*SW5HEF3$kRe
zJg&Xito66?xeT1#{vs}?lk4A_mHtbo91F+g5HYRscifTs87MUTz3-I9KPh*hAp1|3
z(7#O!WWnfZZ^B#XY;%3;BeH#_KEhAqI||>KUHm^v)gKgarnEmpp5y?zjQYbZFz1#>
zheX2c&in<(qjgBlf!O>HSNhLuPzQ3z&WBD9Adt`uKb2HsGu3Uc>oit`UevF06HhQn_kLijuvR$a)!Q0i33c2+1)*zQo*M;0%r}W4>)}_9*yip
z+EG>MX5SH{8p6uyQpFx#1fCw&`MD!uZ5{Q|yPxm0TIh7VU8OWa-(!)^%xqdnIT0lP
z8Gq05T*oc_u$|rGvE~W^Z^1R&u{;YZ0Y7#6z##M@=dv^gjTLwDwTKGd|C03Viq&L|x7gEjhi63VrQCGE)-m)&
zd_DMPnP$t|_0f-!loihFs6{Y^wr
zKf8hOY*$vklSQsb%@osal!cuMf0fMoMZh2K7;&uMcR!voVs{pZvB+soI
zLGUy5b!+5z8^HB8&0DSb`C6bB$TyJ&jdU~N4%+MwO`RLOXH1jHLvk9{B?4InW=RQrqL$*%1ir<-Mt(sy9-QAgc7Lv
zUh0*X!fJ9}jnvgKJ-xeTzE3@0hrg1NzyBg^f4MR=z-uTU5dNp$RPC)!STiNim(-+!
z&Z1@VH?3?fG~S1~TaH&4*4|R4jrC;q(Sk~I9<Dm{w|>wMeQgT-XKmO2fVIk#N_>Szi;eU6phsm@V)Kv5ky2%>G8
zS1(~tiyPRgf15`D??`hD!j*NOQ01eNQe72e%3TOGYx)A`cCy5nN5*}iS&6!}E|jSI
zr8QBkA$_wG>C|g(A`WRxosp;JdA33R;D{+OYMiG$?0?=$A)f2cRO7KP8!cU3s3hHsC(dZt^jR-bsFN0tcZvJE!J-Aa#C;MG;40b{#;iD
zN7WrkJ*?iHcgnnA^ozouMhLW4l#{VS1|tZ5eD)=E<6r&BN8tfF3n>v1*HV(k
z^1)9Y2h)m5^+Q*i-wpMwC(1`1)6RH!DM`-aKIsWalOfdq!XZN^`?28AzT-%7Pq~e*
zuFHJdy#3RsYV%KTfkMAh^8)o2*A96WT~m)F#uCQm#gQm*v9wzD0pcj91H@BAo=Npw
znT5BCkQj0pLbg|fY!XS5e$FuL>wFA@(wHj!t^
z0t3k@T}pWmuIb$EopJa=-V2cncNx7$CG`CUN{+nS>p`*h%%Mt3=^~w`oeYAp+YB?r
z0!g^#19x4_DV2FCe&POByz&fk&bT<@b_gr8)4J|S?~5@O`STE&)l|2S%bVTp&Idc0
zi|To`+o-+|+r-^Vf)ys)=@QNJSd8*gYiXcdu!QH+tbm+UJiW2}8A?_K&qJSKSV2oa
z@~%BwYMc30t#HR(x@*gPCZt%_ay|6!*eRf$!RRchVQ%uB=@v|v{E^yeo~#+#o)_nK
zjkfi~h8<#7$WZBYC^pf_gs~ATRYkuPr)?~nHQSu~0{m$hs4?wz;H#gsY
z1>aowb~vc?B=8#{ZHJ6UqO;C1e~iV&69xPCg1C@77ac4CH;~KOr>PixCp_
z`(^5CTiF5zmf5cTo@_*4hGbW7$l8)~v<;##J$bJe3T2f6a#`vi(YVlyds%p8;+(`9
zagxrj-2Bj+o+YSddRxl$*>vDi+fW<>$TjTb>fk0DeMcUQC^hcvVLKrV?8f*f=8W$Bh*eQONu2cWx3-9v
zlE(^ft<_0=2%U2U=~M)EorpXZ^k9UxNI;gsP9os#BavB6S1>*yo?nif6E;bV+(lSmGw;PfD?AdpUh0g?l+Rwmzi_;9d^cLY$^vs^;
zthqJwcl9SO9YPW~5bdimi+n&Cpo%H12zR8DJ++N27=5>t`5h=fJS_|O>}aE}a<*Wa
zlvM$m&c70USSf6S0yodMuq2g~
z4K7|`+$VcX(sDIm?&l+t8MDywg2HDCB05COE6km%wCvo%pmr-EqEqAadq$9+`Gib(
znco%>YVg@wY$!sPx*V1Bb~{ibZB!aCqU#pbc+_6uP~l?OA*{>BEo%RBIW^4{en9==
z==d
W}dEX
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