Build · MSBuild & Cargo

Pinpoint the project, crate, analyzer, or proc-macro that slowed CI.

Slow builds silently drain hours from every developer every week — yet raw CI logs only tell you that the job took 9 minutes instead of 6. Codebase Pulse reads MSBuild binary logs (.binlog) and Cargo timing output directly on your runner and normalizes wall-clock time against the machine’s single-core CPU score.

When compile time or artifact size shifts, you see immediately whether a cloud VM was throttled or whether a specific .csproj, MSBuild target, Roslyn analyzer rule, Cargo proc-macro, build.rs script, or duplicate crate version caused the regression.

  • Save developer time

    No downloading 150 MB .binlog files locally just to find out which project or analyzer slowed the build.

  • Catch bloat before merge

    Spot heavy source generators, slow Roslyn rules, and duplicate crates on the PR before they tax every branch.

  • Hardware-calibrated baselines

    CPU single-core normalization filters out slow cloud VMs so noisy runners never trigger false build alarms.

PR-first workflow

Run and Guard: CI output and pull requests.

Developers do not need to leave GitHub, GitLab, or Azure DevOps to understand a build slowdown. At the end of the pipeline, pulse-agent summary posts a single Markdown report with compile-time deltas, artifact size changes, and compiler warnings.

  • Normalized compile time compared against the sliding clean-run baseline on your baseline branch.
  • Artifact size deadbands ignore tiny compiler jitter while flagging real binary or container bloat.
  • Build `--guard` fails the job on compilation errors or artifact size over threshold — not on compile-time regressions alone. Compile breakdowns live in the build Run step in the same pipeline summary.

Rollout without friction

Start passively or pass --warn-only to post the PR report with exit code 0. Enable --guard when your team is ready to block merges on regressions.

pulse-agent summary · AcmePlatform · Run

⚠ Build Summary
Engine: MSBuild | Job: AcmePlatform | Compile Time: 480.00s
┌─────────────────────────────────────────────────────────┐
│ Compare: vs previous run on main (projects & deps).     │
│ Baselines: median clean runs on main (time & artifacts).│
└─────────────────────────────────────────────────────────┘
Status: Success | Trend: Declining (worse vs baseline)
┌───────────────┬───────────┬───────────┬────────────────────┐
│ Metric        │   Value   │ Baseline  │       Delta        │
├───────────────┼───────────┼───────────┼────────────────────┤
│ Compile Time  │  480.00s  │  359.08s  │ +120.92s (+33.7%)  │
│ Artifact Size │ 405.1 MiB │ 368.1 MiB │ +37.0 MiB (+10.1%) │
│ Errors        │     0     │     —     │         0          │
│ Warnings      │    45     │     —     │         0          │
└───────────────┴───────────┴───────────┴────────────────────┘
Added dependencies
┌──────────────────┬─────────┬───────────┐
│ Package          │ Version │ Ecosystem │
├──────────────────┼─────────┼───────────┤
│ Polly.Extensions │  8.4.0  │   NuGet   │
└──────────────────┴─────────┴───────────┘
Removed dependencies
┌────────────────────┬─────────┬───────────┐
│ Package            │ Version │ Ecosystem │
├────────────────────┼─────────┼───────────┤
│ coverlet.collector │ 10.1.0  │   NuGet   │
└────────────────────┴─────────┴───────────┘
Project compile time changes (vs previous run)
Total compile vs previous run: +118.67s (+32.8%).
Per-unit wall clock can move opposite to total compile when work runs in parallel or incremental/cache mix changes.
┌─────────────────────────────────────┬──────────┬─────────┬──────────┬───────────────────┐
│ Name                                │ Category │ Current │ Baseline │       Delta       │
├─────────────────────────────────────┼──────────┼─────────┼──────────┼───────────────────┤
│ AcmePlatform.Backend.Billing.csproj │ Project  │ 422.34s │ 263.04s  │ +159.31s (+60.6%) │
└─────────────────────────────────────┴──────────┴─────────┴──────────┴───────────────────┘
Top compile & engine changes (vs previous run)
Total compile vs previous run: +118.67s (+32.8%).
Per-unit wall clock can move opposite to total compile when work runs in parallel or incremental/cache mix changes.
┌────────────────────────────────────────────────────────────────────────────────────┬───────────────────────────┬──────────┬──────────┬──────────────────┐
│ Name                                                                               │ Category                  │ Current  │ Baseline │      Delta       │
├────────────────────────────────────────────────────────────────────────────────────┼───────────────────────────┼──────────┼──────────┼──────────────────┤
│ CoreCompile                                                                        │ MSBuild Target (net11.0)  │ 371.60s  │ 296.30s  │ +75.30s (+25.4%) │
│ Microsoft.NetCore.CSharp.Analyzers.Performance.CSharpConstantExpectedAnalyzer      │ Roslyn Rule (net11.0)     │  31.26s  │  16.05s  │ +15.21s (+94.8%) │
│ _GetProjectReferenceTargetFrameworkProperties                                      │ MSBuild Target (net11.0)  │ 1236.71s │ 1228.32s │  +8.40s (+0.7%)  │
│ JasperFx.SourceGenerator.CommandDiscoveryGenerator                                 │ Roslyn Analyzer (net11.0) │  2.24s   │    —     │      +2.24s      │
│ Microsoft.AspNetCore.App.Analyzers                                                 │ Roslyn Analyzer (net11.0) │  2.01s   │    —     │      +2.01s      │
│ Microsoft.Extensions.Configuration.Binder.SourceGeneration                         │ Roslyn Analyzer (net11.0) │  1.51s   │    —     │      +1.51s      │
│ Microsoft.AspNetCore.Analyzers.RouteEmbeddedLanguage.RoutePatternAnalyzer          │ Roslyn Rule (net11.0)     │  0.93s   │    —     │      +0.93s      │
│ Microsoft.CodeAnalysis.CSharp.Analyzers.MetaAnalyzers.CSharpRegisterActionAnalyzer │ Roslyn Rule (net11.0)     │  0.87s   │    —     │      +0.87s      │
│ Microsoft.EntityFrameworkCore.InternalUsageDiagnosticAnalyzer                      │ Roslyn Rule (net11.0)     │  0.87s   │    —     │      +0.87s      │
│ Xunit.Analyzers.CrossAppDomainClassesMustBeLongLivedMarshalByRefObject             │ Roslyn Rule (net11.0)     │  0.79s   │    —     │      +0.79s      │
│ GenerateBuildDependencyFile                                                        │ MSBuild Target (net11.0)  │  54.62s  │  54.01s  │  +0.60s (+1.1%)  │
│ _GenerateRestoreProjectPathWalk                                                    │ MSBuild Target (net11.0)  │  67.92s  │  67.46s  │  +0.46s (+0.7%)  │
└────────────────────────────────────────────────────────────────────────────────────┴───────────────────────────┴──────────┴──────────┴──────────────────┘
Target framework breakdown
Per TFM compile time & artifact size vs previous run
┌─────────┬─────────┬──────────┬───────────────────┬───────────┬───────────┬────────────────────┐
│ TFM     │ Compile │ Baseline │     Compile Δ     │ Artifacts │ Baseline  │     Artifact Δ     │
├─────────┼─────────┼──────────┼───────────────────┼───────────┼───────────┼────────────────────┤
│ net11.0 │ 469.61s │ 348.89s  │ +120.72s (+34.6%) │ 405.1 MiB │ 368.1 MiB │ +37.0 MiB (+10.1%) │
└─────────┴─────────┴──────────┴───────────────────┴───────────┴───────────┴────────────────────┘
Artifact size by project
┌───────────────────────────────────────────┬──────────┬──────────┬─────────────────────┐
│ Project / output                          │ Current  │ Baseline │        Delta        │
├───────────────────────────────────────────┼──────────┼──────────┼─────────────────────┤
│ AcmePlatform.Simulation.NoiseSimulator    │ 2.9 MiB  │ 86.7 KiB │ +2.8 MiB (+3360.4%) │
│ AcmePlatform.Agent.Application.Tests      │ 20.9 MiB │ 18.0 MiB │  +2.8 MiB (+15.8%)  │
│ AcmePlatform.Agent                        │ 15.7 MiB │ 12.9 MiB │  +2.8 MiB (+22.1%)  │
│ AcmePlatform.Simulation.PipelineSimulator │ 9.7 MiB  │ 6.9 MiB  │  +2.8 MiB (+41.3%)  │
│ AcmePlatform.Engines.BuildEngine.Tests    │ 12.4 MiB │ 9.6 MiB  │  +2.8 MiB (+29.7%)  │
│ AcmePlatform.Engines.TestsEngine.Tests    │ 12.4 MiB │ 9.6 MiB  │  +2.8 MiB (+29.7%)  │
│ AcmePlatform.Core.Tests                   │ 9.6 MiB  │ 6.8 MiB  │  +2.8 MiB (+42.0%)  │
│ AcmePlatform.Benchmarks                   │ 42.2 MiB │ 39.3 MiB │  +2.8 MiB (+7.2%)   │
│ AcmePlatform.Domain.Tests                 │ 12.3 MiB │ 9.4 MiB  │  +2.8 MiB (+30.2%)  │
│ AcmePlatform.Agent.Infra.Tests            │ 20.8 MiB │ 18.0 MiB │  +2.8 MiB (+15.8%)  │
└───────────────────────────────────────────┴──────────┴──────────┴─────────────────────┘
Full build timeline, engine breakdown, and history in Codebase Pulse.

Under the hood

How the build engine works.

Build regressed +33% vs baseline — Backend.Billing, CoreCompile, and a Roslyn rule drove +120s compile.

  1. 01

    Runner-normalized duration & noise filtering

    Shared cloud runners vary wildly in CPU speed and disk I/O. Pulse benchmarks the runner’s single-core performance and monitors CPU spikes, RAM pressure, and disk thrashing. Noisy runs are flagged and excluded so slow VMs never corrupt your build trend.

  2. 02

    .NET: .binlog down to target & Roslyn rule

    Pulse parses MSBuild binary logs automatically. Compare two builds across five levels: slowest .csproj projects, MSBuild targets (CoreCompile, ResolvePackageAssets), Roslyn analyzers, individual analyzer rules, NuGet dependency diffs, and output artifact sizes.

  3. 03

    Rust: Cargo timings, phases & duplicate crates

    Ingests cargo --timings and compiler JSON messages to separate rustc frontend time from LLVM codegen. Spots heavy proc-macros, slow build.rs native compilations, and duplicate crate versions compiled in the same graph.

Engineering questions answered

What your team can answer in 10 seconds

  • “Why did our CI build jump from 5 minutes to 8 minutes this week?”

    Compare any run against your baseline branch or the previous build to see the exact .csproj, Cargo crate, Roslyn analyzer, or proc-macro that added wall-clock time.

  • “Was the build actually slower, or did GitHub Actions give us a slow VM?”

    Every run records raw wall-clock time alongside CPU-normalized duration and system resource telemetry (CPU %, RAM %, Disk I/O).

  • “Which Roslyn analyzer or source generator is taxing every developer build?”

    Pulse breaks down analyzer execution time by assembly and individual rule ID so architects can disable or tune rules that cost seconds on every compile.

  • “Did a dependency update quietly bloat our build output?”

    Track total and per-artifact byte deltas with configurable deadbands, alongside added, removed, or upgraded NuGet packages and duplicate Cargo crates.

Forensic web UI

When the CI output or PR headline is not enough.

Most runs end with CI output or a PR comment. When you need to investigate a structural bottleneck, audit a release branch, or compare historical runs, open the full Build views in Codebase Pulse.

01 · Run Overview & Baselines

Normalized compile trends and hardware calibration

See at a glance whether compile time is trending up across commits or if a spike was caused by a degraded CI runner. Clean runs update the sliding baseline; noisy runs stay visible for audit but never skew the median.

  • Dual comparison against branch baseline and previous run
  • Hardware telemetry strip: CPU single-core score, core count, RAM, and disk I/O
  • Compiler warning and error counts compared run-over-run against baseline

Zero-code on the runner

Wrap the commands you already run.

No SDK in your application. Pulse enables and reads the artifacts your toolchain already emits and uploads metadata to the product backend.

.NET

Artifacts: MSBuild .binlog (/bl and /p:ReportAnalyzer=true auto-injected)

.NET

# Pulse automatically injects /bl and /p:ReportAnalyzer=true$pulse-agent build -- dotnet build$pulse-agent summary --vcs-token ${GITHUB_TOKEN}

Rust

Artifacts: cargo --timings + JSON diagnostics (auto-enabled)

Rust

# Pulse automatically injects --timings and --message-format$pulse-agent build -- cargo build$pulse-agent summary --vcs-token ${GITHUB_TOKEN}