Understand what Windows was doing when your PC slowed down.
Windows Open Intelligence brings recorded activity, resource contributors, and supporting events into one local desktop app. Open a Windows trace, select the moment that matters, and follow each finding back to its evidence. You can also observe recent activity, save investigations, and compare equivalent attempts.
Engineering preview · MIT license · Contributing
| Start with a question | Explore the evidence |
|---|---|
| Which processes used resources during this interval? | CPU sample rankings, physical disk activity, captured file/network events and process lifetimes. |
| What changed between two attempts? | Saved investigations and comparisons with explicit measurement-compatibility checks. |
| What supports this finding? | Event details, attribution basis, captured stacks and trace-local evidence coordinates. |
Analysis runs locally, with no cloud account or upload required. Collection must already be running, or you need an existing ETL: the app cannot recover activity that was never recorded.
This is an engineering preview, open for use, inspection, and contribution. Existing functionality includes ETL analysis, bounded recent-history observation, saved investigations/comparisons, and guided WPR recording. Execution/dependency graphs and application-level causal diagnosis are not implemented. Windows 11 acceptance, the elevated helper's trust/storage review, and several performance gates remain open; this is not a stable, generally recommended executable release. See current checkpoints and verification.
The 13 October local Release build passed 116 tests with zero skips, including long-path cache, investigation and worker-executable regressions. The earlier extracted desktop passed its analysis, recovery, observation and saved-investigation checks; packaged replay handled 228 requests and 50,000 paged events. Dependency identity/advisory checks and package privacy regressions passed. These local results do not close the native Windows 11, elevated storage or helper-trust gates; see the release-remediation record and current validation.
These are genuine captures from the locally tested preview, using Microsoft's public SimpleAllocator-dotnet6.etl sample. They show recorded sample data, rather than measurements of your computer. Screenshot provenance.
Summary — choose an interval and compare the processes contributing recorded activity.
Explorer — connect activity to process lifetimes and browse individual events.
Evidence — inspect the recorded event, provenance and captured stack.
Start with the preview releases. Read each release's validation notes and asset list; a source-only preview requires the build instructions below. Previews are experimental and may be unsigned.
Extract WindowsOpenIntelligence-win-x64.zip into a local folder and open WindowsOpenIntelligence.exe. Keep the application, worker, recording helper, DLLs, and runtime files together. The package is self-contained; users do not need Visual Studio or the .NET SDK.
Windows 11 x64 is the release baseline. Local build and desktop tests ran on Windows 10 Pro build 19045 x64. Windows 11 acceptance is still pending.
- Choose Open recording and a local ETL.
- Inspect resource charts; hold Shift and drag on either resource chart, or enter seconds, then choose Zoom / apply.
- Compare contributors ranked by CPU, completed disk bytes, or summed recorded latency. Double-click a contributor to inspect its lifetime.
- Filter the paged Explorer, then double-click an event to see captured Evidence.
- Review Capture quality, adjust heuristic thresholds, bookmark intervals, and export Markdown or JSON.
Shift-drag selects and highlights a range across both resource charts without changing the applied analysis. Zoom / apply updates the charts, contributors, events and already-loaded stack/history views together. Back restores a previous applied range; Full trace restores the recording's duration while retaining process scope. Arrow buttons move the range by half its width. Chart totals are one-second display buckets; exact interval measurements replay boundary events.
Select a range and choose Pin A, then select another and choose Pin B. In Interval comparison, choose a contributor metric and Compare A/B. Totals and rates per selected second are shown separately, with differences calculated as B minus A. Swap A/B reverses the sides; Open A/B applies either stored range. Contributor rows match exact captured process lifetimes, including activity present on only one side. Inspect A/B sample opens representative evidence; Export page JSON saves complete interval totals and the displayed contributor page with source hash, ranges and limitations.
Both sides must use the same recording and process scope. Missing categories and unknown CPU weights remain unavailable; no observations in an available category means recorded zero, not proof of complete capture. Relative change from zero is unavailable. Unequal-duration rates do not establish equivalent work or causality. Event filters and the existing automatic preceding-30-second CPU baseline are separate. Opening a tab automatically uses the applied range; explicit Use interval and event-filter actions can apply the edited selection to their own view. See the WPA study and verification.
Open CPU stacks after importing a stack-bearing ETL. Use interval applies the selected interval/process and Function or Module grouping. The default function summary ranks self samples; inclusive counts credit each distinct frame once per sample, including recursive functions. Call tree preserves call-path context; Open path and Up navigate it. Select a function and choose Callers or Callees to focus its occurrence closest to the sampled leaf. Inspect sample opens representative captured evidence. Local-symbol loading applies to that inspected event and resets obsolete stack navigation.
Coverage shows selected samples, captured/missing stacks, unresolved frames and depth truncation. [No captured stack] is an accounting bucket, not a reconstructed call path. Self totals including that bucket reconcile to all selected samples. Milliseconds are unavailable when a row includes samples without known CPU weights; the coverage summary reports the known subtotal separately. Sample percentages use all selected samples, and inclusive rows must not be summed as total CPU. Event filters and resource report exports are separate. No new capture providers or automatic symbol downloads are enabled. See the PerfView source study.
In Explorer, expand Saved filters and include / exclude rules. Add rules for process name, category, operation or target using literal, case-insensitive Equals, Contains, StartsWith or EndsWith. Includes use OR within one field and AND across fields; any matching exclusion wins. The quick category/operation/target filters also apply. Apply / first page applies edits and resets paging; Previous page and Next page retain the displayed query even if you edit the controls. Right-click an event to include/exclude an attribute, inspect its captured evidence, or open its recorded process family.
Name and save a filter set to reuse it after restarting. Saving the same name replaces it; Load applies it in the current interval/process scope and Delete removes the saved set. Presets contain event filters only, never the selected interval or trace-local process lifetime. They live in %LOCALAPPDATA%\WindowsOpenIntelligence\event-filters.json; they may include sensitive captured paths or process names. Clearing filters keeps the interval and selected process. Event display filters do not alter resource rankings, reports or the source recording. See the Process Monitor study and executed verification.
Open Process history after importing an ETL. It retains captured parent/child lifetimes, including exited processes, with start/exit boundaries and resource measurements for the applied interval. Select a row and choose Focus family, Parent family, or All families; the Explorer's Process family button opens the selected lifetime directly. Pages contain at most 250 rows, while totals cover the whole family. Explore process opens that lifetime's recorded events; Inspect lifetime opens captured details.
Parentage does not establish a blocking dependency. Missing or ambiguous parents stay unresolved, unknown boundaries remain explicit, and unattributed activity is excluded from family totals. This view uses the imported ETL, not today's processes or the live snapshot history. See the source study and staged feature plan.
- Open Observe and choose Start observing before the activity you want to investigate. The app collects roughly one-second Windows API snapshots in a separate unprivileged worker.
- When a slowdown occurs, choose Mark slowdown. Review accounted process CPU, available physical memory, process I/O accounting, current contributors, and the retained lifetime list.
- Choose Stop observing when done. Unsaved history is in memory only and disappears when you stop or close the app. For event-level evidence, use a guided WPR recording or import an ETL.
The first sample is a counter baseline. Unreadable processes, missed ticks, clock changes, and counter resets remain visible as unavailable values or collection gaps. The ring allows up to 60 minutes but also caps process rows and estimated bytes; the displayed retained duration is the actual one.
Charts break across collection pauses. Long histories use at most 2,000 chart samples; a downsampled block with missing measurements leaves that metric blank. Investigations use the original retained snapshots, including every recorded gap.
- In Observe, start collection before reproducing the symptom. Mark the time it occurs, then open Investigate.
- Choose the recent interval or marked time, describe the symptom, and optionally select an observed application lifetime. Understand interval shows up to three deterministic observations, their coverage/limits, and a next measurement. Double-click a contributor or inspect a finding to see its snapshot coordinates.
- Create two investigations for equivalent attempts. Confirm the same task and the change you made before comparing. Duration and absolute resource use are shown together; incompatible measurements receive no calculated difference.
- Save evidence writes a bounded local
.woiinvestigation. Reopen saved files to compare separate sessions. Matching application path/version context requires explicit user confirmation; PID alone cannot match applications across sources. - Attach selected ETL preserves the selected imported trace report as a separate evidence source. Attachment does not imply clock alignment or a common cause. Export investigation/comparison reports after reviewing included names, machine metadata, notes, and references. Original ETL files and full snapshot records are excluded from report export.
Saved investigations contain recorded snapshot evidence and optional ETL report metadata, with a checksum for accidental damage detection. Findings are recalculated on reopen. This is not a tamper-proof evidence container. Local file limits are 128 MiB/container and 96 MiB/payload; pinned workspaces are bounded to eight investigations and 250,000 snapshot process rows. Close a pinned investigation to free its budget. Stopping observation discards its unsaved pinned investigations; saved files remain available.
- Choose Record activity, then Resources or File activity and a duration from 5 to 120 seconds.
- Select Start recording and approve Windows administrator elevation for the same Windows account. The UI and analyzer stay unprivileged.
- Reproduce the activity. Choose Stop and analyze, wait for the deadline, or cancel to discard the active session.
- A completed ETL is fingerprinted and imported automatically. Review its actual coverage, then use Save recording copy if you want another local copy.
Profiles request a fixed 128 MiB kernel buffer pool in WPR memory mode. Older buffers may be overwritten; the duration limit does not guarantee complete retained history. Collector files now use a protected WindowsOpenIntelligence.Collector\<Windows SID> directory at the root of the application's fixed local NTFS volume: installing on D: keeps this collector storage on D:. Completed recordings are read-only to the signed-in user; Save recording copy creates a user-owned copy. Analyzer caches remain under %LOCALAPPDATA%\WindowsOpenIntelligence\cache. Recording requires at least 2 GiB free space at start; a save can still run out of space. WPR receives protected temporary-directory paths, but service-side temporary writes have not been measured.
The helper owns a unique WPR instance and cancels only that instance. Existing tracing tools can still cause provider conflicts; a failed start is reported explicitly. No global WPR cancel or automatic takeover is used. Reopening recording controls attempts recovery of interrupted, verifiably owned sessions in protected storage. Legacy user-writable recording folders are preserved and excluded from privileged recovery. Native capture acceptance must be repeated after this storage change; earlier server checks do not validate the new paths or permissions.
The original ETL is read-only and SHA-256 fingerprinted. Reopening verifies fingerprints of ETLX, import metadata, and aggregate SQLite. Bookmarks are stored separately. Reports exclude the original ETL, but can contain paths, command lines, endpoints, and addresses; review them before sharing.
- Import limits: 1 GiB source, five million indexed events, 2 GiB combined derived files. Exceeding a limit fails explicitly. Maximum-size ETL decoding is not certified.
- Supported observations: process/thread lifetimes, modules, sampled CPU, physical disk transfers and recorded latency, logical file operations, TCP/IP or UDP, process working-set snapshots, and hard faults when captured.
- Unavailable measurements stay nullable. Provider requests and zero reported loss do not establish complete capture.
- CPU estimates use recorded sampling intervals and processor count. Rankings use sample weights when all contributing samples have known weights; otherwise they use counts. Native TraceProcessing comparisons on three public fixtures meet the unchanged 1% weight-agreement gate; wider WPA, recording-schema, and desktop-OS validation remains open.
- Physical disk bytes, logical file bytes, and network event bytes are separate measurements. Summed latency can overlap; it is not elapsed disk busy time.
- ETLX indices are derived coordinates, not original ETL byte offsets. Lifetime identities govern PID/TID joins; ambiguous attribution remains unattributed.
- Incident candidates are configurable heuristics, not diagnoses. Descriptions classify observations, resource attribution, and temporal correlation.
- Symbols load only from a local directory on request. No cloud analysis, HTTP service, online symbols, automatic startup, Windows service, custom driver, or automatic remediation is included.
Use x64 Windows and .NET SDK 10.0.402, pinned in global.json. NuGet versions are locked. You can install the SDK normally or use the local setup script:
.\scripts\setup-sdk.ps1
.\scripts\build.ps1
$env:DOTNET_ROOT = (Resolve-Path .\.tools\dotnet).Path # local SDK development apphost
.\src\Woi.Desktop\bin\Debug\net10.0-windows\WindowsOpenIntelligence.exe.\scripts\test.ps1 -DownloadFixtures
.\scripts\publish.ps1
.\scripts\export-source.ps1SDK, package, and public fixture downloads use the network during development. Product analysis remains local. Node.js is needed only for the developer replay stress script. See reproduction commands.
Packaging requires PowerShell 7 and now verifies locked package hashes, shipped dependency bytes, current NuGet advisories and the bundled runtime patch before publishing the ZIP. It fails if verification cannot complete. With an existing locked restore, publish.ps1 -NoRestore prevents dependency downloads; advisory JSON still requires network access. Dependency scope and native maintenance limits.
The Windows GitHub workflow builds locked dependencies, tests real ETLs, runs native controlled recordings, checks report export and desktop recovery, and stresses the packaged worker before uploading artifacts. The latest recorded successful Windows Server run passed these functional checks on source 1fdbe28. A later run for 12e6447 never started and executed zero steps, so it supplies no current-source remote validation. Server results do not establish Windows 11 compatibility or passing every performance budget.
The generated WindowsOpenIntelligence-source.zip contains source, dependency locks, workflow, docs, and notices. Source and application packagers share exclusions for saved investigations, interrupted saves, memory dumps, traces, databases and sidecars, credentials, keys, developer PDBs, SDKs, binaries, and local test artifacts. Docs and licenses must be tracked or explicitly required as reviewed public documents when Git metadata is present; source export also retains new nonignored code/build files. Both refuse redirected paths. Review added reports before sharing: permitted Markdown and JSON can still contain private evidence. The source is suitable for an experimental public repository; executable distribution remains an engineering preview subject to the open verification gates.
The worker also has a diagnostic CLI:
.\dist\WindowsOpenIntelligence\Woi.Worker.exe --analyze "D:\traces\recording.etl" --output "D:\reports\incident.json"See the product reassessment, the engineering timeline, architecture, capture design, protocol, roadmap, and contributing. Project code is MIT licensed; dependency notices are in THIRD-PARTY-NOTICES.md and licenses/.
The next-five-checkpoint status is recorded in checkpoints. The P3 experiment protocol and empty results ledger distinguish preparation from participant evidence.
Created and maintained by ard12. This project aims to make Windows performance investigations easier to follow: start with a symptom, narrow the interval, and inspect the evidence behind each finding. Contributions that improve clarity, correctness and reproducible Windows validation are welcome.


