Web UI & desktop app
Scan from a browser without the CLI. The UI server is built into the scanner image, so no extra install is needed.

macOS / Linux:
cd ~/sbom-output # output folder (anywhere is fine)/path/to/bomlens/scripts/scan-sbom.sh --ui# → opens http://localhost:8080 automaticallyWindows — double-click (no command line): in the unzipped folder, double-click scripts\sbom-ui.bat and a browser opens http://localhost:8080 shortly after. Docker just needs to be running, and sbom-ui.bat works on Rancher Desktop or Docker Desktop (on WSL2, run scan-sbom.sh --ui inside WSL).
The run location is the output base, and it scans that folder’s source only when you choose “Current folder” as the scan target. If you use a GitHub URL, an upload, or a Docker image, the run location does not matter. Each scan is saved to its own
{Project}_{Version}/subfolder; the base defaults and how to change them are in Where outputs go.
The shell
Section titled “The shell”The interface has a top bar across the width, a left rail for the current scan’s sections, and a content area:
- Top bar — the product mark (links home), the current project, a Re-scan button (shown on a scan that still carries its settings, so you can re-run the same target with the toggles prefilled), global search across components and CVEs, the Scan management menu (the clock icon opens a list of past scans with a delete control and a link to the full list), the New scan button, and the language (한국어 / EN) and light/dark toggles.
- Left rail — two named links out of the scan (Scan management, New scan) above the current scan’s sections, which are grouped under Inventory, Security, Compliance, AI and Outputs. The rail adapts to the scan: AI sections appear only for AI/ML SBOMs, and a section appears only when its data exists. It collapses to icons on narrow windows. With no scan open — the home screen — there is no rail.
- Content — the home (Scan management) screen, the New scan form, the running view, or the active result section.
The first Tab stop on every screen is a “Skip to main content” link that moves focus past the top bar and rail. The global actions (New scan, Scan management) live in the top bar, and the rail repeats them as labelled links above its sections so a result screen always shows a named way back. Every navigation element — the logo, New scan, the rail sections, the past-scan links — is a real link backed by a URL hash (#/scan/<id>/<section>), so Cmd/Ctrl or middle click opens it in a new tab.
The Help menu (the question-mark icon in the top bar) links to Getting started, the documentation, the live demo, the release notes of the running version and Report a problem, and lists the keyboard shortcuts. Press ? outside a text field to open the same list. On a first run with no scans yet, the Scan management screen offers a link to an example result next to the New scan button.
New scan
Section titled “New scan”The New scan screen reads from top to bottom. First come the source tiles, in rows with the group name on the left: Code (current folder, a directory path, a GitHub URL, a ZIP upload), Artifact (a Docker image, a package or build artifact, a firmware image), SBOM (analyze an existing SBOM) and AI model (generate an ML-BOM from a HuggingFace model, from a model file you upload, or from model information you enter). The arrow keys move between the tiles. Under the tiles is the input for the chosen source, and under that the scan settings in three boxes. Result quality and Output format fold away and show how many of their options differ from the default. External transfer is one row with a switch that opens the server form when it is on. The project name, the version, the two output switches (notice and security report) and the Run scan button are one line pinned to the bottom of the window, so they stay in view however long the page gets. Each output switch has an info button that explains it on the line above, and a switch that BomLens turned on for you says why on that line too.
| Scan target | Input method | Backend mode |
|---|---|---|
| Current folder | scans the source in the UI’s run folder | SOURCE |
| Directory path | a subfolder under the run folder (e.g. an OS rootfs), a folder mounted with --ui --mount <dir>, or — in the desktop app — a folder added with the Add folder button |
ROOTFS, or ANALYZE when the folder is a Yocto build directory |
| GitHub URL | enter the repository URL, and optionally a branch, tag or commit (the default branch when empty) | SOURCE (clone) |
| ZIP upload | upload a .zip/tar file |
SOURCE (extract) |
| Package upload | upload a build artifact — .jar, .war, .ear, .deb, .rpm, .whl |
BINARY (a wheel is unpacked and scanned as ROOTFS) |
| SBOM upload | upload an existing SBOM (JSON, or the .spdx.tar.zst a Yocto SPDX 2.2 build deploys) |
ANALYZE |
| Firmware upload | upload a .bin, etc. |
FIRMWARE |
| Docker image | enter the image name | IMAGE |
| AI model | enter a HuggingFace model id (org/model) |
AIBOM |
| Model file | upload a .gguf, .safetensors, .pt, … (up to 8 GB) |
MODELFILE |
| Published dataset | enter a Figshare item (its page URL, its DOI, or the item number) or a HuggingFace dataset (datasets/<owner>/<name>, its https://huggingface.co/datasets/... address, or hf:<owner>/<name>) in the same field as the model id |
DATASET |
| Enter model information | for a model that has no repository or file yet: the project name becomes the model’s name. Start the questions first asks whether the model was trained from scratch or started from a base model (then added by HuggingFace id, revision optional), then the model information (the document author unless the form’s SBOM author is set, release date, download address, supplier), the training data (HuggingFace datasets by id and data the hub does not hold) and the decisions, then shows a review. An id typed but not added is added when you move on; one that is not an id keeps you on the step. Choosing adapter weights with no base model shows a warning. “Start the scan” has the server check the answers first; a refusal is shown with its reasons in the review, with the answers kept, and only an accepted declaration is uploaded and scanned. Upload to a server is not offered for this input. A re-scan reopens the questions at the review step with the saved answers. The tile is locked when the image lacks the scripts for it | AIDECLARE |
For every source scan (current folder, GitHub URL, ZIP upload, and a mounted folder scanned as source), the form also has a “Paths to leave out” box: one path per line, relative to the scanned folder, such as vendor/legacy. The scan skips them in the build, the license scan and the file tree, as --exclude does on the command line. Globs, absolute paths and .. are refused, and a path that does not exist is reported in the log and ignored. The paths are kept with the scan, so a re-scan fills the box again.
Firmware analysis, an AI model, and Deep CVE matching each run in their own opt-in image rather than the base one. Picking one of these shows a panel that checks whether that image is already present: if so, it names the version already installed; if not, it offers a Download button with the download size and, once started, layer-by-layer progress. Downloading it here, before the scan starts, avoids a multi-minute wait in the middle of a scan that would otherwise be indistinguishable from the analysis itself.
Generation options are the open-source notice and the security (vulnerability) report. A scan always writes the SBOM in CycloneDX; an SPDX copy is exported afterwards from the results screen, so there is nothing to decide here. Separately, a Result quality group gathers the toggles that change how the source is analyzed rather than which files are produced. An Output format group holds the conformance profile, outbound license, SBOM author and CycloneDX version. Options that send data off the machine (the SCANOSS lookup and the upload) carry a “Sends data out” mark, and the scan button stays in the action bar pinned to the bottom of the window. License scan (ScanCode) scans the project’s own source files for per-file license text (1st-party; it does not download the declared dependencies) and applies to source-code scans (current folder, GitHub URL, ZIP upload). File-level identification (SCANOSS) finds third-party open source copied into the tree (mainly C/C++), also for source-code scans. SCANOSS uses the free OSSKB service, which is rate-limited and may return nothing under frequent use, so add a token from scanoss.com for regular runs. Go reachability analysis (govulncheck, the same as --reachability on the CLI) applies to a source-code scan or an uploaded package (an executable) and judges whether the code each Go advisory names is reached; it reads the Go vulnerability database online, turns the security report on, and is offered only when the image carries govulncheck. Firmware, Docker images and SBOM uploads have no other advanced options. Choosing SBOM upload (ANALYZE) forces the notice and security reports on for the risk analysis, and an AI-model scan produces the notice only (it has no package CVEs, so the security report is skipped).
For a source scan, the Result quality group also has Look up the AI models the code uses on Hugging Face (the CLI’s --resolve-models). It is off by default and carries the “Sends data out” mark, because it asks the hub about each model the code references. Set HF_TOKEN to read a private model. See AI usage in a source scan.
The top bar’s language toggle (한국어 / EN, see The shell) also decides the language of a scan’s own generated prose: the conformance, security and AI-profile reports, and the model/dataset risk assessment’s reason text, the same as --lang on the CLI. It reads whichever language is showing when you press Run scan. The SBOM itself and the third-party notice are not localized either way.
A Reproducible output toggle produces byte-identical SBOMs across runs (the UI equivalent of --byte-stable); it is available for source, image and firmware scans, not for SBOM analysis or AI models.
For SBOM analysis, a Match against the CPE index toggle (off by default; the UI equivalent of --analyze-cpe-index) also matches the components of an SBOM that BomLens generated, those carrying bomlens:purlSource=upstream-map, against the bundled CPE index. Other components are not matched.
A Read sbom-declared.cdx.json toggle, on by default under Result quality, adds the components listed in sbom-declared.cdx.json at the root of the scanned folder: the folder of a source scan, or a Yocto build directory picked with the Directory input. Any other directory is scanned the same either way, since whether a folder is a Yocto build directory is known only once the scan starts. Turn it off for a scan made before the build outputs the file names exist; for a source scan this is the UI equivalent of --no-components. The UI reads only that file name and cannot name another file, as --components does. See the declared components guide.
An Outbound license field takes the SPDX id your project ships under, such as Apache-2.0 (the UI equivalent of --license). Fill it in and the Licenses section reports which dependencies clash with it; leave it empty and that check stays off, which the section says outright. It appears wherever BomLens generates the SBOM, so not for an analyzed supplier SBOM (which carries the supplier’s own declaration) or an AI model.
An SBOM author field records the organisation or person running the scan on the SBOM’s own metadata, not the tool and not whoever wrote the software (the UI equivalent of --sbom-author). Leave it empty and BomLens is recorded as the author, marked as the tool, with no email. Available for AI-model scans too, since they get a document-metadata stamp the same as any other generated SBOM; hidden for an analyzed supplier SBOM, which the UI did not author.
A CycloneDX version choice sets the version the SBOM is written in: 1.6 (the default) or 1.7, the UI equivalent of --spec-version. AI model and dataset SBOMs are 1.7 whichever is chosen. Like the SBOM author, it is hidden for an analyzed supplier SBOM, which keeps the version its supplier wrote, and a re-scan keeps the version the earlier scan used.
Below the outputs, an optional External transfer step can send the finished SBOM to a server. Turn it on to pick the destination — Dependency-Track or TRUSCA — and enter the server URL and an access token; TRUSCA also asks for the target project id. The URL and token are used for that one run and are never saved. It is the UI equivalent of the CLI upload options; see Upload to Dependency-Track / TRUSCA.
Yocto build directory
Section titled “Yocto build directory”A folder picked with the Directory input can be a Yocto build directory, and BomLens recognizes it as one: it analyzes the image SBOM the build published under tmp/deploy/images/<machine>/ instead of walking the build tree, which holds sysroots and native build tools that never ship in the image. The scan log names the folder and the document it read, the result page labels the scan a Yocto build directory, and the vulnerabilities carry the verdicts the build itself made — patched by a recipe, judged not applicable, or still open.
The build gives the most when it was configured to emit an SBOM (INHERIT += "create-spdx-3.0" and INHERIT += "vex" in conf/local.conf, on 5.0 Scarthgap or later — 4.0 Kirkstone has no such class). SPDX 2.2 is read as well, together with the .spdx.tar.zst beside it, though it carries no CVE verdicts; a build with no SPDX at all is read from the manifests it wrote anyway. Only a build directory with none of those stops the scan, rather than falling back to a directory scan whose result would misrepresent the image. The supplier SBOM guide covers the behaviour and its limits; the CLI recognizes the same folder through --target.
To declare components by recipe (bomlens:yocto-recipe), put sbom-declared.cdx.json at the root of the build directory. The UI reads it there, while the CLI takes the same file with --components; the log names the file when it is read. A symbolic link or a hard link in its place is not read, and the scan stops and says so. If the scanner image that ran did not apply the file, for example an older deep CVE image, the scan fails rather than finishing without the declared components. Turning off Read sbom-declared.cdx.json scans the build without it. See A Yocto image in the declared components guide.
Scan running
Section titled “Scan running”During a run the screen shows the project and version, a Cancel button and a Steps box: generate, normalize, notices, security, report, plus Deep CVE matching when the run asked for it. Each step is marked done, in progress or waiting as its marker appears in the live log, and the percentage beside the bar counts only the steps this run has. The run log below stays open. It follows new lines while you are at its end; scroll up to read and it stops following until you scroll back down. Copy log puts the log as shown on the clipboard, with a reminder to read it first.
Cancel asks first, because it stops the scan and keeps nothing it found so far. Keep scanning leaves the scan running; Cancel scan stops it, returns to New scan and says so in a short notice.
When a run fails, the title becomes “Scan failed” and a banner leads with what went wrong and what to do, in your language: a repository that was not found or is private, a repository host that could not be reached, a scan tool that could not start (exit code 126, with the tool and runtime named), or an internal error. The Steps box stays and marks the step the run stopped on. Retry runs the same scan again; it is offered only when nothing in the scan is single-use, so a scan with an access token or an uploaded file shows a line saying why instead. New scan is always there. The scanner’s own message is kept as received in the run log, which stays folded when the banner already explains the cause and opens by itself when it does not. Report a problem opens below with the diagnostics summary, as described in Reporting a problem.
Result sections
Section titled “Result sections”When the scan finishes, the left rail fills with the sections for that scan.
Every result section starts with one line naming the project, version, scan type and scan time, then the section title. A status badge appears there only when the scan failed or finished with some steps failed, so a normal result carries no “complete” label.
Overview has a title with the project name and version, and under it one line with the scan type, the scan time and the component count. The next line names what was scanned (the folder path, the cloned URL, the container image reference, the uploaded file’s name or the AI model id), so a result read weeks later still says where its numbers came from. A scan that read a lock file instead of building says that too. A Download all (ZIP) button at the right of the title gets every generated file.
Banners about how far to trust the result come first (they are described below). The page then has two columns. The main column holds, from the top:
- For an AI scan, the AI model SBOM summary: the model name, the risk grade, the G7 and regulatory coverage tiles, the SPDX 3.0.1 line with a link to fill in empty fields, and links to Models & datasets and, for a submitted document, Conformance.
- One box named “Items to check first”. Its upper part lists up to three links with the count each rests on, where the count came from and when the scan was made: known exploited vulnerabilities (CISA KEV), Critical or High vulnerabilities that already have a fixed version, and required conformance items still to fill in. It is a reference order for reading the scan, not a ranking of importance or a verdict. Its lower part, “Needs attention”, lists known-malicious packages first, then critical or high vulnerabilities, components flagged for license review and model risk, and conformance elements that can still be filled in. A malicious package leads because it is already running in the build and has to be removed, not scheduled for a patch. Rows that repeat the upper part are left out. The same part lists the components past their upstream end of life, with how many of them are also vulnerable (see Component end-of-life), and the components that have fallen behind their latest version (see Version currency). Every row opens its section with the matching filter already applied. The box is left out when no row applies.
- For a Yocto build, a note on the vulnerabilities the build already closed.
- When the same project was scanned before, the comparison with the previous scan (described below).
- “Highest risk components”: the six components with the most risk, each linking to its vulnerabilities.
The side column holds the two risk axes. The security severity distribution is a bar with one cell per severity under it. The license classification is a bar with the six classes in a legend under it. Click a cell or a class and you land in Vulnerabilities or Licenses with that filter applied; a severity with no findings is not clickable. A “Scan summary” box appears under them only when the navigation counts leave something out: the number of components not checked or judged not reachable by the vulnerability scan, or a dependency view with no recorded relationships. The other counts (components, vulnerabilities, dependencies, models, conformance, artifacts) are in the left rail.
If a scan finished with reduced analysis (for example cdxgen ran out of Docker disk space and the SBOM fell back to direct dependencies only), a banner at the top of the Overview gives the reason and what to do. When two or more notices of the same kind apply, they share one folded banner that shows how many it holds; Details opens one line per notice and the full text of each. A different banner, “Some data may be incomplete”, appears when a best-effort post-process step (CPE/EOL/malicious enrichment, conformance validation, notice generation, and the like) failed during the scan; it names the step and suggests re-scanning to retry or checking the run log, so a valid but silently incomplete SBOM does not look no different from a complete one. A firmware scan that could not open part of the image adds a “Firmware analysis scope” note: how much of the image was not recognized as a known format, how many extraction steps did not complete and for which formats, how many regions are encrypted, and which extraction tools the scanner image lacks. Components inside those regions are not in the SBOM, so read the vulnerability counts as covering only what was opened; the note is not shown for an SBOM you uploaded for review. The run log of a scan you just ran appears at the end of the Overview, not under every section.
When a declaration file was refused, the scan fails and the Overview says so in place of the general failure message: it lists each reason the scan gave, naming the file, the component and the rule it breaks, and offers the SBOM written up to that point, {Project}_{Version}_bom.refused.json, to view or download. That file lacks the declared components and is not the SBOM to submit. Fix the declaration file and scan again, or turn off Read sbom-declared.cdx.json to scan without it. The run stays in Scan management with a “Declaration refused” badge and reopens on the same message until the next scan of that project and version. A scan that failed for another reason shows the scanner’s own error text in the same place. A failed scan’s banner also shows the diagnostics summary expanded, with its copy button and the issue form link, and has a Report a problem button that opens the same dialog as the Help menu (see Reporting a problem).
A source scan that found AI in the code adds an AI used by the code card to the Overview: models, AI services, MCP servers, MCP configuration files and agent instruction files, each with its provider or file, its scope (runtime or not) and what to review. The list is shown, not counted: the conformance check and the NOTICE leave it out, and the model risk assessment judges only models looked up on the hub (it rates the hub licence and the base models’ licences, and is not a G7 check). A looked-up model also shows its licence, weight file formats, gated state and base models, a warning for pickle weights, a link to the hub page and, when --model-sbom linked one, the model SBOM it points to. A model the hub could not answer for is marked unreadable. The card is absent when the scan found no AI or BOMLENS_NO_AI_USAGE was set.

When the same project was scanned before, a box compares this run with the previous one (labeled by its version, or how long ago it ran). Its head gives the component count change (or “no component change”) and whether the worst vulnerability severity got more severe, less severe, or stayed the same. Below it, two rows fill in a moment later with the specifics: components changed (added, removed and version-changed counts) and vulnerabilities changed (new and resolved counts). Open a row to see the names, up to eight per list and a “more” line for the rest. A component or a CVE id links into Components or Vulnerabilities filtered to just that one. A resolved CVE is no longer in this scan, so its link opens it in the previous scan.
Components lists everything detected. One toolbar holds a search box (name, group, version, type and license), a Type menu and a License menu (each value with its count; the Type menu appears when there is more than one type), a Filters menu (has vulnerabilities, direct only, needs review, end of life, outdated, license to decide; only the ones this scan has data for are offered), a View menu and an Export CSV button. Each active filter shows as a button under the toolbar that removes it, next to Clear filters and an “N of M components” count. The View menu sets the row height (Compact or Comfortable, one choice shared with the Vulnerabilities table and remembered in your browser) and shows or hides the Version, Type, Scope (direct vs transitive), Risk (the worst vulnerability severity and count) and License columns. A column this scan has no data for is not offered, and the Type column starts hidden when every component has the same type. Export CSV writes the rows as the table shows them, with the current filter and sort. Click a column header to sort: the first click sorts ascending, a second click reverses it, and Risk and Scope put the worst or the direct components first when descending. The name column is the widest and wraps a long name instead of cutting it. The table grows with the page, and its header stays under the top bar while you scroll. A component the bundled OSV snapshot knows to be a malicious package carries a “Malicious package” badge, ahead of the others, with the advisory id and snapshot date in its tooltip. A component past its upstream end-of-life has a line under its name, “End of life since” with the date where it is known. A component added from a declaration file carries a “first-party” or “third-party” badge, from its bomlens:origin, so it reads apart from what the scan found. A component that is not on its latest version has a line saying it is outdated and naming the latest version; with deps.dev enrichment on (STALENESS_ENRICH=true) its detail shows how many releases it is behind and its last-release date (see Version currency). A list of any size scrolls as one page: rows are drawn in blocks of 100 as they come near the window. Click a row, or Tab to its arrow button and press Enter or Space, to expand its detail in place: the PURL, source/download location, copyright, licenses and any vulnerabilities. Where the detail reports vulnerabilities, it also links into the Vulnerabilities section filtered to that component, and a vulnerability’s own detail links back to its package in Components, so an investigation moves between the two lists without retyping the name.

Vulnerabilities sorts by severity, then CVSS. Each row has a Severity, a CVSS and a Fixed column, and a Vulnerability column: the title with its labels (known exploited, reached, no fix yet, the vendor’s status, your judgement, a supplier VEX statement) and, under it, the package as group / name with its installed version, the CVE id and the other ids the same vulnerability is filed under. An id that does not fit on that line is left out whole; all of them stay in the tooltip and in the detail panel. Fixed versions are listed one per line. EPSS and the NVD severity are columns of their own when the report carries them. The View menu turns each on or off and remembers the choice (EPSS starts off in a window narrower than 1280 px; the NVD severity starts off unless every row has one). The table grows with the page and its header row stays under the top bar while you scroll. When the report holds more findings than the list does (a large firmware scan lists at most 2,000), a notice says how many are listed of how many. Click a row’s title, or the row, to open its detail in a side panel: the package URL, your judgement, links to the package in Components and Dependencies, any supplier VEX statement, the CVSS score with its vector, the published date, the fixed versions, the description and the references. One panel is open at a time, Escape closes it, and the URL carries it (open=), so a link opens the same panel. Above the table, preset views (All, Fix available, No fix yet, Known exploited, Critical and High, each with its count) narrow the list in one click; a preset with no rows is disabled. The View menu also switches the layout between a flat list and one block per package, and sets the row height (Compact or Comfortable), which is remembered in your browser and applies to the Components table as well. With five packages or fewer every block starts open; with more, only the first three (the worst) do. Each package block shows how many CVEs it carries and the version that resolves them (“Upgrade to X to resolve N”). In the list layout a collapsed box above the filters says how many packages one upgrade each would clear and how many CVEs that is; open it for one line per package, worst first. Click a severity button next to the search box to filter to that severity, or search by CVE, another id, package or title. Every detail panel also has a judgement field, where you can record your own read of that CVE against your product (affected, not affected, fixed, or under investigation, with an optional note), separate from the vendor/advisory status a report already carries; it is saved to the scan’s own result folder, not into the SBOM itself. Once at least one judgement is on file for the scan, an “Export VEX” button at the top of the page hands you the judgements as a CycloneDX VEX document (see the artifacts reference). “Import VEX” goes the other way: pick a CycloneDX VEX document a supplier sent and its statements appear on the matching rows with their own “Supplier VEX” label, next to your judgement and never replacing it. A statement is matched to a component through its affects reference, by purl or by name and version; a statement that names the product itself applies to every finding of that CVE that has no statement of its own. A document that describes a different product or version than the scanned SBOM is refused, statements about components the SBOM does not contain are left out (the screen says how many), and a statement with no affects is ignored. A refused or empty import changes nothing. When the scan ran Go reachability analysis, a finding govulncheck judged not reachable is left out of the severity figures and the Overview count, as in the security report, and listed above the table in its own collapsible list, marked “Not reachable” with the reason (the affected package is not in the build, or no affected function is reached) and govulncheck’s own detail. A reached finding stays in the table with a “Reached” label whose tooltip gives the call path or the symbol.

Dependencies shows the relationships recorded in the SBOM as a graph or a tree, with a Graph and Tree switch and a package search above it. The tree is a keyboard tree: Up and Down move between rows, Right and Left open and close a branch, Home and End jump to the ends, and Enter or Space toggles a branch. Direct dependencies start open and carry a Direct label, a package that would repeat one of its own ancestors carries a cycle label and no branch, packages with known vulnerabilities carry their severity, and each row shows its first two licenses and a count for the rest (the full list is in the tooltip). Searching expands the tree to the first matching package and marks it; the cursor stays in the search box and Enter moves to the row. The graph draws the scanned component, direct and transitive packages and a severity-shaped ring on vulnerable ones. Hover a package to trace its links, click it for its type and licenses, and use Zoom in, Zoom out, Fit to view and Save as PNG (named after the scan) above the canvas. The canvas cannot be read with a keyboard, so the note under it points to the tree. An SBOM that records no relationships shows a note instead of a graph and lists its components flat in the tree. A graph over 1,500 nodes is not drawn; use the tree. An SBOM with more than 60 packages opens as the tree, because a graph of that size cannot be read, with a note that says so; switch to Graph to see it anyway. The “View (package) in Dependencies” links on the Components and Vulnerabilities screens open the tree at that package with its ancestors expanded. If the SBOM or the graph cannot be loaded, the screen says so and offers Retry.

Licenses opens with a box named “License classification”: a proportional bar and a legend that group components by copyleft strength: network copyleft (AGPL), strong copyleft (GPL), weak copyleft (LGPL, MPL, EPL, …), permissive, review needed, and uncategorized. An unrecognised license is never assumed permissive; it falls to uncategorized so a person looks at it. Both the bar segments and the legend entries are toggle buttons: click a class to filter the rest of the screen to it, click it again to clear it. The class is kept in the address (?tier=), so a link or a reload opens the same view, and the Overview’s license bar links here with it. The bar always shows the whole scan, and the classes you did not pick are dimmed. A note under the legend, inside the same box, says how many components are shown, with a Clear filters link; when the scan has no license in the chosen class, it says so instead. An address with a class that is none of the six shows a warning with Clear filters and filters nothing.
When the scan declared an outbound license, the “Conflicts with your outbound license” box comes next: the dependencies whose terms clash with it, grouped by verdict (cannot be met, depends on how you ship, cannot judge), worst first. A group shows its first five rows, with a button for the rest; the column headings stay when it is folded. A reason shared by several components is said once above them, in the interface language, and the recorded English text stays as its tooltip. It is a documentation aid, not a legal determination. If no outbound license was declared, an information banner right under the title says the check did not run and how to turn it on, rather than leaving an empty list to read as an all-clear: a button re-scans with the Outbound license field in focus, and the command-line form is folded away. For a scan of a submitted SBOM or an AI model there is no such field, so the banner explains that instead and offers no button.
The “Licenses” box lists how many components declare each license, with a marker shape, the class name and a bar. A switch sorts it by count (busiest first) or by name. A row is a link that opens the Components table filtered to that license, where it combines with the type, scope and risk filters. Components with no declared license are one plain row at the end, because Components has no filter for them. Twenty rows show first, then a button shows all of them or folds them again. Picking a class narrows this list.
The “License review needed” box lists the components whose terms need a person to read them, AI behavioral-use (RAIL, Llama, Gemma) and non-commercial licenses. The “What each license asks of you” box shows the conditions each license attaches to redistribution, such as keeping the notice, stating changes, disclosing source or sharing alike. The list comes from public license summaries and covers 47 well-known licenses. An SPDX expression is shown term by term (choose one of an OR, meet all of an AND), and a license outside the list, or one with an exception clause, is marked “Needs checking” rather than filled in. Eight licenses show first, with a button for the rest. The class filter applies to the distribution, conflicts, review and obligations boxes. From a 1536 pixel wide window the obligations box moves into a narrow column beside the distribution.

Conformance check appears under Compliance for every scan, whether the SBOM was uploaded for review or generated by the scan itself — the intro line at the top says what the section measures either way: how well this SBOM’s own fields meet the CycloneDX format and SBOM-related regulatory requirements, not a judgment of the scanned software. The one exception is an AI SBOM the scan generated itself, with no upload. For an AIBOM or a model file scan, the G7 minimum-element checks are the more useful reading, so they appear on Models & datasets instead of duplicating them here. A dataset scan is routed the same way, but G7 applies only when the SBOM has a machine-learning-model component, and a dataset-only SBOM has none. Neither screen shows G7 checks for it, and the base format checks are in the _conformance report files. The regulatory crosswalk shown with the checklist is for reference and makes no compliance determination. The screen shows the format verdict (pass or fail) and the base CycloneDX checks (timestamp, tools, top-level component, name and version coverage, PURL coverage, transitive dependencies), with the missing items listed for each failed check, plus, for a scan that is not an AI SBOM, the share of components that declare a license. A pass on a result that identified no software, or where no component declares a license, is shown as “Pass, see the note below” with a warning, because a pass only says that no required item failed. A crosswalk roll-up shows how the checks map to the regulatory baselines (EU CRA via BSI TR-03183-2, the US SBOM minimum elements of 2026). When the SBOM carries a machine-learning-model component, the G7 AI minimum-element checks (all advisory) appear here as a sub-block, grouped by the seven G7 clusters and tagged by data source — auto (read directly), inferred, declaration needed (shown as publisher’s declaration once the publisher’s declaration meets it; BomLens does not verify it), or review-needed when no automated source exists. The AI model SBOM guide explains the headline numbers and badges. If a best-effort post-process step failed while this SBOM was generated, a “Some conformance checks may be based on incomplete data” note names it here too; for a document someone else supplied, it suggests asking them to regenerate it instead of re-scanning.
The screen is a summary box and the checks. The box names the format, gives the verdict and the number of mandatory checks that failed, and warns when no software was found or no component declares a license; from a 1536px window it stays in a column at the right while the checks scroll. The report files (HTML, Markdown) are download buttons in the page header. Tabs split the checks by what a reader can do about them: All, Can be fixed, Needs a person, Not applicable and Met, each with its count and disabled when it is zero. The screen opens on Can be fixed, or on All when there is none. The search takes every word you type, in any order, and looks at the requirement name in both languages, the measurement, the id and the regulation references. The tab and the search are kept in the address (kind and q), so a filtered view can be shared; the line under them says how many checks are shown, and a search that a tab narrows offers “Search all kinds”. The checks sit in boxes of folded groups: format conformance, the 2026 minimum elements and, for a model, the G7 elements. A group opens when it holds something that can be fixed, and all groups open while a tab or a search is active. Each check is one row with its status (also read to a screen reader as text), name, Required mark, source label, measurement, the regulation references and, when something can be done, the how-to-satisfy line. Opening the row shows the missing items (repeats counted as ×N, “and N more” when the list was capped), the components the supplier explained, what satisfied a met check, what a person has to establish, an example fragment and a link to learn more. The regulatory crosswalk is always shown, whichever tab is chosen. Its table scrolls inside its own box on a narrow window.

Artifacts lists the generated files (SBOM, notice, risk report, security report, conformance) as one row per kind, with a download button for each format and its size, a signed label when an SBOM signature exists, and a View button that opens the richest viewable format (HTML first) in a dialog. The line above the list counts the kinds, their total size and the files; files that no row offers, such as the raw EPSS feed, are named there and are only in the ZIP. Copy link puts the file’s address on the clipboard, and Download all (ZIP) is in the page header. The viewer dialog keeps focus inside, closes with Escape, the Close button or a click outside, and hands focus back to the View button. An HTML report is shown in a frame that runs no script, JSON is indented, other text is shown as it is, a text or JSON file over 2 MB is not previewed and offers the download instead, and a file that cannot be opened says so and offers Retry.
Source tree shows what the scan actually looked at, rather than only what it found. The tree on the left lists the files; picking one opens its text beside it. It appears for every scan that had files to read: a source scan, a directory or rootfs scan, a firmware image (after unpacking), a container image, and a build artifact that is an archive (jar, war, whl, zip, tar). A container image and an archive have no folder to walk, so BomLens unpacks a temporary copy, reads it, and deletes it before the scan ends. Symlinks are listed with the path they point at; in a container image nearly every command in /bin is a link into busybox, and leaving them out would show a tree in which those commands do not exist. When the scan ran with License scan (ScanCode) on, each file also carries the license detected in it. The tree is a keyboard tree: the arrow keys move and open or close folders, and a box above it filters the files by name and keeps the folders on the way to each match. Top-level folders start open when there are eight or fewer of them. The file pane shows the path, line count and size, numbers the lines and highlights the syntax of known languages, and long lines wrap, and a “Wrap lines” switch turns that off to scroll sideways. A file over 1,500 lines shows the first 1,500 with a button for the rest, and that choice does not carry over to another file. A file with no captured text says why: binary, past the capture limit, or not captured.
The captured text is bounded so a scan’s output folder stays a reasonable size: text files only, up to 256 KB each and 8 MB in total, and licence texts and package manifests are taken first so the evidence behind a finding is the part that survives a tight budget. A file with no text on screen says why — it is binary, or the capture reached its limit — and the line above the tree reports how many files were captured and how many were left out. Nothing is silently dropped.
Submitted SBOM appears when the scan read an SBOM someone else produced (SBOM upload / ANALYZE). Every other screen describes the CycloneDX document BomLens converted that input into, so this one describes the input itself: the format and spec version it was written in, its document name and identifier, when it was created, the tool that produced it, and the supplier or authors it names. Fields the supplier did not fill in are left out rather than shown blank, because on a compliance screen a confident-looking wrong value costs more than a missing one. The entries themselves are not repeated here; the section links to Components, which lists them with sorting, filters and risk, and, when the converted document holds a different number of components than the input had entries, the line with the link says so. The creation time is shown in UTC in the interface language, with the recorded text as its tooltip, and the document id and package URL each have a copy button. The file name wraps instead of being cut off, so a long name stays readable at any width. If the details cannot be loaded, a message with a Retry button replaces the box.

The SBOM row in that section carries an Export as SPDX 2.3 button. It converts the finished CycloneDX BOM into {Project}_{Version}_bom.spdx.json and starts the download at once, without rescanning. The converted file then joins the row as an ordinary download button and is included in the ZIP, and the button is no longer offered for a scan that already has an SPDX file. CycloneDX stays the primary format, and CycloneDX-only data (vulnerabilities, bomlens:* properties) is not carried over. Signing is available only in the CLI (--spdx --sign), so a file exported here is unsigned like every other artifact the UI produces.
Conversion needs syft. The scanner image ships it, so the usual deployment converts on the spot. Where it is missing, such as the desktop app’s base UI image, BomLens runs the scanner image as a separate container to do the conversion, which downloads that image once on first use. Where neither is possible, the button is not shown.
An AI scan adds two cards. SPDX 3.0.1 AI document holds the document, with a draft badge while required fields are open, and its check; its check chips are labelled “Check JSON” and “Check MD”. A “Rebuild with the saved declaration” button appears only when the document is behind the saved declaration or this BomLens (a declaration edited outside the screens, for instance); it rebuilds the document and downloads it. AI declaration holds the values you declared and the empty form; its “Upload declaration” button sends an edited file back, which the server checks and applies the same way as the questions on Models & datasets. When the document is rewritten, a signature the CLI made over the earlier one is removed, because it no longer matches.
AI surfaces
Section titled “AI surfaces”For an AI/ML SBOM (a CycloneDX SBOM with a machine-learning-model component), the rail adds:
Models & datasets — each model card’s identifier, architecture, task, license, supplier and integrity, a four-axis disclosure panel (weights / architecture / training data / training process, as documented in the BOM), and the datasets the model references. When the SBOM carries a model risk assessment, the card opens with the overall grade badge (ok / conditional / caution / review), the per-axis verdicts (license, file security, datasets — an unevaluated axis shows a dash), the reasons behind the grade, the quoted custom-license wording and lineage warning when present, and the usage scenario the verdict was judged for; each dataset row carries its own grade badge. A source the scan traced from a dataset’s card is a row of its own, indented under that dataset, and a source the card names only in words carries a “needs checking” badge. The section ends with the reminder that the assessment is guidance, not legal advice. For AI model scans, the New scan form adds a usage-context selector (internal / product / redistribute / outputs-only) that tailors this assessment.

The section opens with the SPDX 3.0.1 AI document band. It says whether the document is a draft or complete, counts its fields in four groups (filled from the scan or declared, optional, your decision, and required but empty) and names the elements whose required fields are still empty. For a model someone else published it adds that filling them matters only if you distribute the document yourself. Below it, “Show the document’s fields” unfolds a table of the model’s fields with their value (dates in your locale, choices by their label) and where the value came from; it starts open for a model described from a declaration. Each dataset’s fields are folded under it and open by themselves when they hold required fields still empty. The Overview’s AI card shows the same draft or complete state with a link that opens the questions. Fill in empty fields opens questions for exactly the fields the scan left open, starting at the first step that has something open, in up to six steps: the base models’ revisions, the model (the document’s author, its release and build dates, who made it, the weights it distributes, and an optional “use and scope” group), the training data (how the model used each dataset the card names, the datasets’ makers and dates, data the hub does not hold, and an optional “how it was trained” group), the service the model runs in (optional, described below), the decisions only the publisher can make (personal information, autonomy, safety risk), and a review. The step list shows how many items each step still holds, and a step left with items open is marked with a warning instead of a tick. “Unknown” is offered only where SPDX itself has such a value; a required date, author or address has none, so the question says that leaving it empty fails validation, quietly at first and as an error once you leave the field or the step. The review lists what will be saved, grouped like the steps; each “open” count jumps to its step and the first open field. Saving sends the answers to the server, which checks them against the scan and rewrites the document; you can save with required fields still open, and the document stays a draft until they are filled. Saving waits only on what the server would refuse: a value it cannot accept, or data the hub does not hold that has no name or address. An added entry left untouched is dropped. Answers in progress are kept while you look at other sections, and coming back shows a note that they were kept. Cancel asks for confirmation before it discards answers you have typed. The steps are boxes on a three-column page (steps, the question, a side note), and a step is marked done only after you have opened and left it; the review marks steps you have not opened yet. The screen is a column of boxes: the SPDX band, one box per model, one per declared service, a datasets table inside its own box, and the G7 checks as folded groups. A declaration saved earlier that no longer fits the scan is reported on the band with its reasons. A scan from before this document existed shows a button that writes it instead.
For a model, the questions include an optional Service step after the training data. It asks “Do you run this model in a service, such as an app or an API?” with three answers: yes, no (the document covers the model alone) and later. Only yes adds anything: the service’s name, version, address, provider (an organization) and release date, which SPDX requires of it, then folded groups for its purpose and whether a person is involved in the AI’s decisions (involved, fully automatic, or not known), its input and output kinds, its data flows (each added by saying what data it is, then given a direction), the external AI models it calls through an API (identified by name, provider, version and address only), and the standards it follows with a public disclosure page. A group opens by itself only when it holds something to fix. The service’s empty required fields keep the document a draft but never stop saving, and a service left empty is not recorded. Once a service answers whether a person is involved, the decisions step no longer asks the model’s autonomy. The model step also has a folded group for regulatory filings (training compute in FLOPs such as 3.2e24, how it was counted, and whether adversarial testing was done, with the EU AI Act and Korean AI Basic Act articles as references, not legal advice) and asks the model’s input and output kinds; a dataset’s known bias is asked with its main questions. A service saved after the scan goes into the SPDX 3.0.1 document at once; the band then says a new scan brings it to the CycloneDX SBOM and the G7 checks, with a re-scan button. After that scan, a service card on Models & datasets shows the declared service with a “Publisher’s declaration” badge: its provider, the model it runs, the number of data flows and the external models it calls. A G7 element met by such a declaration carries the same badge.


The G7 AI minimum-element checks are added only when the SBOM has a model component. For an AI SBOM generated by the scan itself they appear on Models & datasets, below the model cards; for one uploaded for review they appear on Conformance check instead, alongside the base format checks. Either way, the Overview leads an AI scan with a summary card — the model’s risk verdict, the G7 headline and the regulatory framework coverage (EU AI Act, Korea AI Basic Act) — that links into whichever of the two sections carries the detail. It is advisory, not a certification, and the same data is written to the _ai-profile files (see Artifacts).
Scan management
Section titled “Scan management”The home screen, opened from the rail’s Scan management link, the logo, or the top bar’s Scan management (clock) menu, lists every past scan saved on this machine. Each scan’s {Project}_{Version}/ subfolder under the output base is one entry. This is local files only: no account, no database.
A search box narrows the list by project or version. An At risk button, with its count, keeps only the scans whose worst finding is Critical or High. A Type menu keeps one scan type: Source, Container, RootFS, Firmware, AI model or SBOM. It lists only the types that exist and appears when there is more than one. The type comes from what the scan was pointed at and, where that leaves it open, from the root component the SBOM declares, so an analyzed supplier document reads as SBOM rather than as the Source its root usually claims to be. Each active filter also shows as a button under the bar that removes it, next to Clear filters and an “N of M” count. The total scan and project counts are plain text at the right of the bar. A filter that matches nothing says so and leaves the filters in place to undo.
The table sorts by scan, generated time, components or top severity. The first click on a column sorts it from high to low, a second click reverses it, and the column header says which way it runs. A long name, such as a firmware image’s file name, is shortened in the middle, with the full name in its tooltip. The Generated column shows a relative time (“2 hours ago”) with the exact time in the tooltip. For a project scanned more than once, the Components column shows the change since its previous scan (+7, -3) and an arrow beside the top severity says whether it got worse or better. A scan run with a refused declaration file carries a “Declaration refused” label and is left out of these comparisons.
Click a scan’s name to re-open its results. The menu at the end of each row (the three dots, named after the scan) holds Delete, which removes the scan’s subfolder. A prompt confirms first, because the files are removed from disk and nothing is kept to restore. Cancelling returns focus to the row’s menu button. On a narrow window the table becomes one stacked row per scan. With no scans yet the screen offers New scan, a link to an example result, and a note on what a scan produces. In the read-only demo the list has no New scan button and no delete menu, shows dates instead of relative times, and adds a strip that points to up to three scans to open first.
External lookup
Section titled “External lookup”Reachable from the top bar’s icon at any time, or from a Cmd/Ctrl+K search whose term looks like an advisory id, with or without a scan loaded. Type a CVE/GHSA/GO/PYSEC/RUSTSEC/OSV/GSD/MAL id, a purl, or a bare package name (which then asks for an ecosystem and version), and the server checks it live against OSV.dev: full detail for one advisory, or every known vulnerability for one package version. A package result is a list with one row per advisory (id, severity, title with the affected range, date); a row opens to show the CVSS score and vector, the dates, aliases, affected versions, description and references, and a note says when OSV.dev returned more advisories than are shown. A failed lookup says why (offline, upstream error, busy, unreachable, not a valid term) and offers Retry except for a term that is not valid. The URL (#/lookup?q=…, plus eco and ver when you typed a bare package name) is a shareable link that re-runs the same lookup on open.
This is the one feature that reaches outside the machine on its own initiative rather than as part of a scan — see Local-first by design for what that means for a closed network. Set EXTERNAL_LOOKUP=false to remove it (the icon, the search row and the screen) entirely.
Reporting a problem
Section titled “Reporting a problem”With a finished scan open, whether it succeeded or failed, “Report a problem” in the Help menu opens a dialog. A failed scan’s banner on the Overview has the same button. The dialog shows a diagnostics summary in full: the app and scanner image versions, the container engine, the scan mode and options, the result of each stage, and the [WARN] lines the scan collected. The summary is built from a fixed list of fields, so source contents, the scanned path and the project name are not part of it. Text taken from the scan itself (warnings and error messages) is filtered: user names in home-directory paths and text that looks like a credential are masked. The filter is best effort, and a folder name or other detail can remain, so read the summary before you paste it. Copy summary puts exactly the text you see on the clipboard, and Open the issue form opens the bug report form in your browser. Nothing is sent until you paste the text into the issue yourself. The summary is fetched when the dialog opens. Without a scan open (and in the read-only demo), the Help menu entry goes straight to the issue form. The run log has its own Copy log button, which copies the log as shown with credential-shaped text already masked; check it for paths and names too. The desktop app’s start screen also links to the issue form.
Accessibility
Section titled “Accessibility”BomLens does not claim conformance with WCAG (Web Content Accessibility Guidelines). What it measures is listed here, along with what it does not.
- Every CI run scans 13 result screens (source, AI and firmware scans) in the light and dark themes and in English and Korean, 52 combinations in all, with axe-core against the WCAG 2.2 level AA rule set. A violation fails the build. The scan includes color contrast and target size.
- A separate check (
npm run token:contrastindocker/web/frontend) reads the color tokens themselves. Every text color is at least 4.5:1 on the page, the card and its own tinted surface in both themes; the lowest is 4.7:1 (secondary text on the muted surface, light theme). Every fill color used for bars, dots and progress is at least 3:1 on those surfaces; the lowest is 3.0:1 (the medium-severity amber on the muted surface, light theme). - A classification is never carried by color alone: severity and license tiers also show their name in text, and a license tier also has its own marker shape. The segments of the stacked bars have no pattern of their own, so the legend under each bar is what names them.
- The first Tab stop is a skip link to the main content. The dependency tree has tree semantics and moves with the arrow keys. The bar segments that filter a list are buttons with a pressed state. The page language follows the UI language.
What is not covered: automated checks find only a part of the WCAG criteria, and no screen reader has been used to walk through the screens. The borders of text fields and cards are about 1.2:1 against their background, under the 3:1 that WCAG 1.4.11 asks for the boundary of an input; each field has a visible label. The report files (HTML) use the same color tokens but are not part of the axe scan.
The firmware upload tile appears automatically whenever the Docker engine is running. See the firmware guide for how it works and how to point it at a different image tag.
Note: the UI’s source scan (current folder / ZIP / GitHub) analyzes the directory with cdxgen inside the container, the same engine the CLI’s source mode uses. A lock file is not required — cdxgen resolves dependencies itself when one is missing (running
npm install,cargo generate-lockfile, and the equivalent for other ecosystems) — but it does need network access to fetch packages during that resolution.
Changing the port / on a conflict: if the default port (8080) is taken by another service, specify a different port:
UI_PORT=9090 ./scripts/scan-sbom.sh --ui # http://localhost:9090Reaching the UI from another machine: the UI is published to the loopback interface, so it answers only on the machine that started it. It runs scans through the engine socket, which is why it is not offered to the network by default. If you do need it elsewhere, set the bind address and put an authenticating proxy in front of it:
UI_BIND_ADDRESS=0.0.0.0 ./scripts/scan-sbom.sh --uiNote: even though the UI is easy, a Docker engine must be installed and running (free: WSL2 + docker-ce, or Rancher Desktop). The launcher detects a missing or stopped Docker and shows the install link.
OWASP BomLens, an OWASP Incubator Project ·Contributing
Copyright © 2026 SK Telecom Co., Ltd. ·Apache-2.0 ·Third-party licenses