Glint

The file explorer for Windows that doesn't make you wait.

Folders open in milliseconds, every folder shows its size, and any file on any drive turns up as you type.

A native Windows app written in Rust. Free, open source, and no account.

Download the installer · Website · What's new · Features · Benchmarks · Shortcuts

Why Glint

• Folders open in milliseconds. System32's 5,097 items are on screen 12 ms after you press Enter, and a folder of 100,000 files in 47 ms (11 ms if the pointer rested on it first). Glint itself is up, with your folder in it, about a quarter of a second after you start it.
• Every folder shows its size. File Explorer keeps folder sizes in Properties. Glint puts them in the list as the folder opens (all of C:\Windows in 0.4 ms from the index), and draws any folder as a map of what fills it, like WizTree.
• Any file on any drive, as you type. Turn on instant search and a small service reads each NTFS drive's Master File Table once, the way Everything does, then follows every change: every kernel32.dll on three drives, among 3 million names, in 7.7 ms. Without it, fd streams results as it finds them.
• One search for names and contents. ripgrep reads inside the files from the same box, and a file found by what it holds is a row like any other, with the lines that matched under it. PDFs, Office documents and the text in pictures too.
• A preview for nearly every file. Space shows it full size: code, Markdown, PDFs, Word documents without Office, spreadsheets and databases you can query with SQL, books, videos, 3D models, and every file's bytes.
• More to do with files. Trim and shrink videos, merge and split PDFs, query CSV and Parquet files of any size, convert documents, take personal info out of photos, encrypt with age, rename hundreds of files at once, and take it all back with Ctrl+Z.
• Tabs, two panes, a terminal and Git. Each pane has its own tabs, two folders compare and sync down through every subfolder, a terminal under the files follows the folder you're in, and every file shows its Git status.
• Still Windows. Copy, move and delete run on Windows' own file engine, with its progress, Replace or Skip, Recycle Bin and UAC. The clipboard, drag and drop and Windows' own context menu work with File Explorer and every other app.
• AI agents use it too. Through its MCP server, Claude, Copilot, Cursor and other agents find files on every drive in milliseconds, measure folders and search inside files.

Install

# winget: the installer's copy, which updates itself
winget install shadijhade.Glint
# winget: the Microsoft Store's copy
winget install 9NQLRJ3HF1C9 --source msstore
# Scoop
scoop bucket add shadijhade https://github.com/shadijhade/scoop-bucket
scoop install shadijhade/glint

Glint needs Windows 10 or 11, 64-bit, and nothing else: it draws its own window, so it doesn't need WebView2. The installer's copy updates itself: when a new version is out it says so, and Install (in that notice or in Settings → About) downloads it, checks its signature and restarts into it in a few seconds. The Store's copy can't change File Explorer's settings (Windows doesn't let Store apps), so Open in Glint on File Explorer's menu, Open folders in Glint by default and Win+E opens Glint need the installer's copy. The two keep their settings apart, and Settings → About → Settings file moves them across.

[!NOTE]
The installer isn't code-signed yet, so Windows may say Windows protected your PC: choose More info, then Run anyway (why). If your browser holds the download back, choose Keep. With Smart App Control on, Windows doesn't run it at all: get Glint from the Microsoft Store there.

What's new

0.12.0 (November 14, 2026) adds nothing. It takes out what wasn't worth its weight, does less work for everything that stays, and brings back four things the move to a native window had stopped.

• Smaller. Glint.exe is 93 MB, down from 174 MB, and builds 240 fewer crates.
• Back again. Search inside files instantly catches up with what changed while Glint was closed, daily and weekly backups run on time, remotes shown in File Explorer answer it again, and Ctrl+Alt+G takes the file dialog in front to the folder shown.
• Quiet at rest. Glint no longer wakes at every refresh of the display when nothing on screen changes, nor while it waits in the tray.
• Less work for everything. Code previews color their first lines at once, an arrow key no longer rebuilds the sidebar, a search your next key replaces stops at once, and busy folders, big copies and searches with many hits all cost less.
• Removed: Mermaid diagrams, the built-in Typst (.typ previews and Export as PDF), paired devices, and photo, speech and meaning search. Their downloads are deleted from the PC at the first start.

Release notes · Every release · 0.11 gave Glint a window of its own, and 0.10 made it a native app.

Benchmarks

Each time runs from pressing Enter until everything is on screen, as the app's status bar reports it: the median of 5 runs, with the files already in Windows' cache (as when you browse back and forth). Intel Core Ultra 7 265K, NVMe SSD, Windows 11, release build. The status bar shows the time for every folder and search, so you can check these numbers on your own PC; built from source, npm run bench measures folders, search, copies and start-up for you.

_{¹ From the moment Windows makes the process to the folder painted in its window, the median of 7 starts. Most of it is Windows loading the display driver (155 ms), which Glint does on a thread of its own while the rest of it starts.}

_{² A folder is read ahead while the pointer or the keyboard rests on it, and its row says what is in it meanwhile. Opening it then only has to draw it.}

_{³ With instant search on. Without it, fd and pdu do the work: fd on its own lists the same 5,015 DLLs in 0.1–0.3 s, and takes 8 s for a name search across a 219 GB home folder.}

_{⁴ From the first thumbnail asked for to the last one in, each run a fresh start of the app, so none came from its own memory. Asked for all at once, 1,200 photos come 1,100 a second from Windows' cache, and are made at 220 a second when Windows hasn't seen them.}

_{⁵ Its list of entries read (47 ms of that), nothing extracted, each run a fresh start of the app. After that, every folder in it is read from memory in 0.2 ms. See docs/archives.md.}

Features

A tour of what Glint does. Every feature, in detail: docs/features.md.

Folders and their sizes

The size of every folder, in the list	Disk usage: what fills a drive

• Instant folders. One Win32 pass reads every name, size, date and attribute, Rust sorts them in natural order (img9 before img10), and only the rows on screen are drawn.
• A size for every folder, in the list as it opens with instant search on, or one click away with pdu, with a bar showing how each compares with the biggest.
• Disk usage map. A treemap like WizTree's, six levels deep, colored by kind of file, by age, or by what grew in the last day, week or month.
• A head on every folder. What's in it (6 folders · 15 files · 13 MB), a chip for each kind of file to show only those, and soft light behind the window in the color of the place you're in.
• It answers before you ask. Rest the pointer on a folder and its row says what's in it: Glint has read it by then, so opening it takes a frame.
• List, grid, columns and gallery. Windows' own thumbnails in five tile sizes, a Columns view (Ctrl+Shift+9), Group by kind, date, size, type or Git status, and a Gallery of your photos and videos by month.

More about browsing →

Search

One search: names, and what the files hold	Instant search over every NTFS drive

• One box for names and contents. Typing filters the folder; Enter searches below it, names by the index or fd and contents by ripgrep, in one list.
• Instant search, when you turn it on: an index of every NTFS drive, kept current from the change journal, so names, folder sizes and maps answer from memory in milliseconds (how it works, and its security model).
• Filters, or plain words. ext:pdf size:>10mb dm:7d, taken:2024 camera:canon, artist:, tag:work, git:changed… or type pdfs from last week over 5 mb and Glint shows the filters it read. Typos are forgiven: reprot finds Q3 Report.pdf.
• Inside documents and pictures. The text in PDFs, Word, Excel, PowerPoint, OpenDocument and EPUB files without Office, and in screenshots and scans through Windows' OCR. Search inside files instantly keeps an index of the folders you choose, to answer as you type.
• Quick search from anywhere. Ctrl+Alt+F in any app opens a search box over every drive, answered by the index as you type.

More about search →

Tabs, two panes and the grid

Ctrl+Shift+D: two panes, each with its tabs	Ctrl+Shift+2: the grid, with Windows' thumbnails

• Tabs in each pane, listed whole in the side rail and back when you start Glint again.
• Two panes. Drag between them, compare them down through every subfolder and by contents, and Sync.
• Compare two files (Ctrl+M): text side by side with the words that changed marked, code by its structure with Difftastic, pictures with a swipe, an onion skin or a pixel diff, anything else byte by byte.
• Thumbnails that never hold up the folder, from Windows' own cache (30 in 71 ms), and made on several threads when Windows hasn't seen a photo yet.
• Ctrl+K for everything else. Every command, the folders you use most (ranked by frecency, like zoxide), paths, and = to work out a sum, units and all.

More about tabs and panes →

Previews and Quick Look

Space: Quick Look	Ctrl+K: the folders you use, and every command

• Code and text with syntax colors, Markdown as GitHub shows it (math and Graphviz diagrams included), and JSON, YAML and TOML as trees you can filter with jq.
• Tables you can query. CSV, Excel, OpenDocument and Parquet files and SQLite databases, with SQL that only reads.
• Documents without their apps. Word documents laid out as pages, books and comics (EPUB, Kindle, FB2, CBZ) with Read aloud, Jupyter notebooks, 3D models, emails with their attachments, contacts and calendar invites.
• Photos, songs and videos with where and when they were taken, covers and waveforms, and Trim for a video or a recording.
• Every file's bytes in a Hex view, and Windows' own previewers for the rest, as in File Explorer.

More about previews →

More to do with files

• Media, with FFmpeg: convert and shrink videos (to fit under 10, 25 or 50 MB, on the PC's own video encoder when it has one), take the sound out, make GIFs, even out loudness, and write subtitles from what's said, with whisper.cpp on your PC.
• Make smaller. Videos that still look the same (scored by VMAF), photos as JPEG XL without losing a bit, PNGs, PDFs and the pictures inside Office files. Nothing that comes out bigger is kept.
• PDF tools (pdfcpu), data files of any size (DuckDB), Convert document (pandoc) and Convert pictures (rimage).
• Archives and disk images open like folders. Zip, 7z, RAR, tar and the rest, ISO, VHDX and WIM images and installers, read-only, with nothing extracted until a file's bytes are needed. Compress to zip, 7z or tar.zst, a zip or a 7z with a password.
• Remove personal info from photos, videos, PDFs and Office files, Encrypt with age, Compress in place with Windows' own compression, and Batch rename with a live preview.

More about media, documents and data → · Archives →

Tools

File X-Ray: check a download against its published SHA-256	F2 on several items: rename them all, with a preview

• Find duplicates by their content, then recycle, hard-link or (on ReFS and Dev Drives) clone the extra copies.
• Clean up the build output and package caches of projects you've left alone, empty folders, programs' leftovers, big files, and with Czkawka, look-alike pictures and videos.
• What's locking this? The programs holding a file open, and End to close one.
• Where did a file go? 30 days of renames, moves and deletes, read from each drive's change journal.
• File X-Ray. Checksums against a pasted one, who signed a program, hidden streams and a file's real type; scan with Microsoft Defender, look for leaked keys with Kingfisher, or check YARA rules.
• Drive health. Each drive's temperature, wear and errors, read without administrator rights.

More about the tools →

Files in other places

• Clouds and servers. Google Drive, OneDrive, Dropbox and 60 more open as folders through rclone, signed in to from Glint; S3 buckets, WebDAV and SFTP servers too, and any of them can show in File Explorer, on demand.
• Send and share. Send a file or a folder to another PC with a ticket (sendme: encrypted end to end, no account), to phones nearby with LocalSend, or share a folder with a phone on your network through a QR code.
• Backups. A folder backed up with restic, encrypted, every day or week; your backups and Windows' restore points show in Previous versions.
• Folder rules sort out what lands in Downloads, or keep a folder in sync with a cloud, with Undo.
• A copy queue with pause and resume, where each copy is read back and compared with its original.

More about remotes, sending and backups →

For developers

• Git at a glance. Every file's and folder's status, the branch in the address bar and what changed in a file, read by gitoxide (Git needn't be installed).
• A terminal under the files (Ctrl+`) that follows the folder you're in: PowerShell, Command Prompt, Nushell, Git Bash or WSL.
• Run a project's scripts (npm, pnpm, Yarn, Bun, just, Cargo, uv), and your own scripts on what's selected.
• A repository's card (onefetch and tokei), and Open in VS Code, Cursor, Zed or your terminal.

More for developers →

At home on Windows

• Windows' own file engine for every copy, move, delete and rename, and Ctrl+Z takes them back.
• Windows' own menu on Shift+right-click, Properties and Open with, and OneDrive's sync marks.
• Mica and your accent color, the Recycle Bin as a place, and the taskbar button's jump list.
• Open in Glint from File Explorer, Win+E and folders that open in Glint by default (installer copy), and Ctrl+Alt+G to take any file dialog to Glint's folder.
• English and Arabic, right to left.

More about Windows integration →

Compared with File Explorer

AI agents

AI agents that speak the Model Context Protocol (Claude Code and Claude Desktop, VS Code's Copilot, Cursor and others) can use Glint's engines. Glint.exe mcp is the server: the agent starts it, and it answers on its standard input and output with 13 tools. Nine only read; four change files, and only after you allow each in a Windows dialog naming exactly what will happen.

Agents that show apps (MCP Apps) draw folder_sizes and largest_files as a map of the folder, and Glint adds itself to Windows' own agent registry where Windows has one.

Settings → AI agents has each agent's setup to copy: claude mcp add glint -- "C:\…\Glint.exe" mcp for Claude Code, code --add-mcp for VS Code, and the mcpServers entry for Claude Desktop, Cursor and the like. Once told, the agent starts Glint for itself and sees the names and text it asks for; Glint tells it that what files are named and contain is data, not instructions. Measured here, through the server as an agent asks: kernel32.dll on every drive in 8 ms, C:\Windows's folder sizes in 1 ms, the biggest files on C:\ in 41 ms.

Keyboard shortcuts

F1 (or Ctrl+/) shows every shortcut on one sheet, and Ctrl+, opens Settings. The ones to know:

Files

Disk usage map

The search box

From any app

How it works

Glint is Rust from end to end. GPUI, the UI framework of the Zed editor, draws the window, and the windows crate talks to Windows itself. There is no web view, no HTML and no JavaScript engine in the app: until 0.10 its interface was a web page in WebView2 (Tauri and React). Glint builds with a patched copy of GPUI, in vendor/ (docs/gpui/VENDOR.md).

• Folders: one FindFirstFileExW pass (basic info, large fetch) gets every name, size, date and attribute at once. Rust sorts them in the window's own process, and the list draws only the rows on screen.
• Name search: the instant-search service when it covers the folder, otherwise fd, with results streamed into the list as they arrive.
• Folder sizes: the index's per-folder totals, otherwise pdu. It took over from dust, giving the same totals 14–30% faster: the subfolders of C:\Windows are sized in 4.9 s instead of 6.9 s, and its map is measured in 4.7 s instead of 6.7 s (warm cache, the median of 5).
• Thumbnails: Windows' thumbnail cache through IShellItemImageFactory (thumbnails only, from the cache only: about a millisecond each), on worker threads that are each a COM apartment of their own. What the cache doesn't have is made by the file type's thumbnail handler: Windows' photo provider runs on Glint's own threads with IThumbnailCache and WTS_EXTRACTINPROC (220 a second with 8 threads, where the isolated process Windows uses for other handlers makes about 50 however many ask), and Windows caches each one as if Explorer had made it. Requests wait in their tab's queue, shared between panes showing the same file, and are dropped when the tiles asking for them scroll away. Each tile asks at its size in screen pixels; when the cache answers with a smaller size it has (it keeps 16 to 2,560 px versions), the thumbnail is made at the size asked, and the smaller one is the answer only for online-only files or when making fails. Each answer reaches the window as pixels, and both sides keep the latest ones in memory.
• Disk usage map: one request to the index returns the biggest files and folders six levels down (folders are walked biggest first, so nothing too small to draw is looked at), or pdu's JSON tree when the index doesn't have the folder. Either way it goes straight to the window and is drawn as a squarified treemap. For all of C: here (464 GB, 2.9 million MFT records) the service answers in 19 ms for the 20,000 biggest items six levels down, and the map is on screen 53 ms after the click; on a synthetic index of 2.86 million records it takes 9–17 ms, whether the map goes 4 or 32 levels down.
• Archives: zip reads a zip's central directory, served from memory in one read of the file's end (13 ms for 50,000 entries, where reading it from the file takes 150 ms), and sevenz-rust2 reads a 7z's header, once Glint has checked how big it unpacks to. Tars and cabinets are read by Glint's own readers, and gzip, xz, bzip2, Zstandard, LZ4 and LZX by pure Rust decoders. RAR is read with RARLAB's UnRAR (C++), which only ever tests files and hands their bytes over; everything else is pure Rust. The entries become a tree of folders kept in memory, with safe Windows names and folder totals, and each listing reaches the list the same way as a folder's. A file is extracted only when it's previewed, opened or copied, cut off at its declared size, and copies out go through IFileOperation from a staging folder. See docs/archives.md.
• Inside files: ripgrep's JSON output, streamed in batches, each file it names read once for its size and date so it is a row like any other. Documents are read by worker processes of Glint's own (pdf-extract for PDFs, their XML for the rest), each held to 1 GB and 30 seconds.
• Git: gitoxide reads the repository inside Glint: status for the folder on screen and below it, stopped at 4 s, cached per folder and refreshed by one watcher per repository. Nothing is written to it, and a repository whose settings would run programs for status waits until you trust it.
• Previews of its own: Markdown through comrak, with the HTML in it cut down to what GitHub allows and never added to the page as HTML; JSON, YAML and TOML read with jaq's readers by a worker process of Glint's own, and jq filters run in jaq, both held to 1 GB and 10 seconds; workbooks through calamine and Parquet through the parquet crate; Query in SQLite, the file's table loaded into memory or the database opened read-only.
• Remote folders: Glint's own S3 (signed requests) and WebDAV clients, over HTTPS whose certificates Windows checks; SFTP through Windows' own OpenSSH sftp.exe, a password handed over by Glint itself when it asks (never on a command line), and host keys checked against ~/.ssh/known_hosts and a list of Glint's. Clouds through rclone: one rclone rcd (its remote control) on 127.0.0.1, on a port and with a password of its own at each start, in a Windows job that ends it with Glint; sign-ins are rclone's own (rclone authorize, its page opened by Glint), kept in rclone's configuration. Listings reach the list the same way as a folder's. See docs/remote.md.
• Sending and sharing: sendme and dufs run as programs of their own in a Windows job that ends them with Glint; dufs listens only at this PC's address on the network, on a free port, behind a random key in the link.
• Folder rules: notify watches each rule's folder; every 500 ms Glint looks again at the files that came in, and acts on one once its size has held for two seconds and it opens for reading. Rules that wait on age look again every hour, and every step goes to a log kept with Glint's data, which Undo works from. A sync rule runs rclone copy, sync or bisync with its filters, reading rclone's JSON log for what it did.
• Previews from Windows: the file type's preview handler (IPreviewHandler), the one File Explorer uses, created out of process (Office's run in Word, Excel and PowerPoint; others in prevhost.exe) and drawing in a window over the preview pane. A thread of Glint's with its own COM apartment owns that window and talks to the handler, so the UI never waits on one, and a watchdog cancels a call that hangs. GPUI's window is a DirectComposition window that a handler's child window can't draw over, so the handler is hosted in an owned pop-up kept over the pane's rectangle, and Glint hides it while a menu, dialog or toast covers the pane.
• Comparing folders: Rust walks both trees side by side and answers with each top-level item's status and what Sync copies each way; files compare by date and size, or byte for byte when asked, reading both until they differ.
• Quick search: RegisterHotKey on a thread of its own, and a second, borderless window of the app that searches as Files does.
• File operations: Windows' IFileOperation (the engine Explorer uses), the clipboard formats Explorer reads, and OLE drag and drop.
• Live folders: notify watches the folders on screen (one per pane).
• Terminal: portable-pty runs each shell in a Windows pseudo console (ConPTY), and a thread of its own reads the output into the emulator of alacritty_terminal, whose grid the window draws. Each shell is started so its prompt says where it is, as Windows Terminal reads it (OSC 9;9): PowerShell's own prompt is wrapped, and Command Prompt's PROMPT and Git Bash's PROMPT_COMMAND are set; Nushell says it by itself. Rust picks those (and OSC 7) out of the output, and the pane goes there. The other way, Glint types a cd for the shell, only while it sits at its prompt with nothing typed.
• Tabs and panes: every tab keeps its own state, and its name searches and pdu runs go in a lane of their own in Rust, so tabs and panes never stop each other's work.
• Opening folders from Windows: per-user shell verbs under HKEY_CURRENT_USER\Software\Classes (no administrator rights) run Glint.exe "%V", and a later launch hands its folders to the window that's open (a named mutex decides which copy is first; the later one sends its folders to the first's hidden message window as WM_COPYDATA and ends). What Glint can't open goes back to File Explorer before any window shows. See docs/explorer-integration.md.
• Instant search: a Windows service in Rust (crates/shadui-index, built as shadui-index.exe) that reads each NTFS volume's Master File Table in one sequential pass and follows its USN journal. See docs/instant-search.md.

The tools that ship inside Glint:

The others, from FFmpeg to rclone, install with one click when a feature needs them: docs/tools.md.

Build from source

You need Windows 10 or 11 and Rust (stable, MSVC toolchain, with the Visual Studio C++ build tools). Node.js 22 or newer is only for the release scripts (they use nothing from npm), and NSIS 3 only to pack an installer.

git clone https://github.com/shadijhade/glint.git
cd glint
cargo run -p glint

The first build compiles GPUI and all the other dependencies, which takes several minutes; later ones take seconds. Everything builds into target\ui (set in .cargo/config.toml). cargo build --release -p glint -p shadui-index makes Glint.exe and the instant search service in target\ui\release, and npm run installer packs them into Glint-setup.exe. The Windows x64 builds of ripgrep, fd and pdu ship in crates/glint/binaries/, and crates/glint/build.rs puts them next to the built Glint.exe. npm run release, or the release workflow when a version tag is pushed, builds a release on top of that: the update package the app installs, code signing, and the winget and Scoop manifests (docs/releasing.md).

The checks to run before you commit:

cargo test --workspace
cargo clippy --workspace --all-targets -- -D warnings
npm run test:signing

powershell -STA -File tests\e2e\run.ps1 drives a debug Glint.exe the way a person does, with real clicks and keys (tests/e2e/README.md). A release build hands its folders to an installed Glint that's running, so try one under a name and identifier of its own (how). The index's tests (MFT record parsing, queries, disk-usage maps, folder totals under random changes, snapshots, the wire format, and a real named-pipe round trip with its ACL) run without administrator rights.

Roadmap

• Code-signed installers (the SignPath Foundation invited a new application once Glint is better known)
• 0.12: smaller and quieter, with what the move to a native window had stopped running again
• 0.11: a window of its own (one bar, tabs in a rail, a dock) and one search for names and contents
• 0.10: a native app in Rust and GPUI, with no web view

• Tabs and a dual-pane view
• A disk-usage map (treemap) from the index
• Thumbnails and a grid view
• Auto-update, with signed update packages
• Scoop and winget packages
• The Microsoft Store, signed by Microsoft
• Zip, 7z, RAR, cabinet and tar archives (compressed too) opened like folders, with their passwords
• Undo (Ctrl+Z) for copies, moves, renames, deletes and new items
• Quick search from anywhere (Ctrl+Alt+F), the tray, and starting with Windows
• Word, Excel, PowerPoint and font previews through Windows' previewers
• Comparing folders down through subfolders and by contents, with Sync
• A terminal under the files that follows the folder shown
• The Recycle Bin as a place: restore with Undo, delete for good, empty
• Git status, the branch and what changed, in every folder of a repository
• Previews of Markdown, JSON and YAML trees with jq, workbooks and Parquet with SQL, and every file's bytes
• Searching inside PDFs and Office documents
• Clean up, and duplicates cloned on ReFS and Dev Drives
• Sending files to another PC, sharing a folder with a phone, and S3, WebDAV and SFTP folders
• Folder rules
• Windows 11's Mica and your accent color, Windows' own context menu, marquee selection
• Plain words read as filters, and name searches ranked across every drive
• An MCP server, so AI agents can use Glint's instant search
• Previous versions, from Windows' shadow copies
• Remotes in File Explorer, on demand
• Search inside files from an index, tags, and Glint in Arabic

Missing something? Open an issue. If Glint saves you time, a star helps other people find it.

Contributing

Bug reports, ideas and pull requests are welcome. CONTRIBUTING.md covers the setup, where things are in the code, and the checks. To report a security issue, see SECURITY.md.

Acknowledgments

• fd, pdu and ripgrep, which do the heavy lifting and ship inside the app.
• GPUI and gpui-component, which draw Glint's window.
• The tools Glint installs when a feature needs them, from FFmpeg and rclone to Czkawka, Difftastic and YARA-X (docs/tools.md), and the crates it's built from (THIRD_PARTY_CRATES.md).
• Everything and WizTree, which showed that reading the MFT directly is the fast way, and goz and everyfind, whose ideas the index service borrows.
• zoxide for frecency, and macOS for Quick Look.

License

MIT, see LICENSE. The bundled ripgrep, fd and pdu, and the crates that read archives, keep their own licenses; see THIRD_PARTY_LICENSES.md, and THIRD_PARTY_CRATES.md for every crate in the app.