Users can render the full graph of dependencies as well as identify the selection reason and origin for a dependency.
Dependencies can originate through build script declared dependencies or transitive dependencies.
You can visualize dependencies with:

- the built-in Gradle CLI `dependencies` task
- the built-in Gradle CLI `dependencyInsight` task
- link:https://scans.gradle.com/[build scans]

[[sec:listing_dependencies]]

include::sample[dir="snippets/dependencyManagement/declaringDependencies-dynamicVersion/groovy",files="build.gradle[tags=dependencies]"]
====

A link:https://scans.gradle.com/[build scan] can effectively visualize dynamic dependency versions and their respective, selected versions.

.Dynamic dependencies in build scan
image::dependency-management-dynamic-dependency-build-scan.png[]

<h2>Event timelines for running goroutines</h2>
{{range $i, $view := $}}
{{if $view.Ranges}}
{{if eq $i 0}}
<p>
  Large traces are split into multiple sections of equal data size
  (not duration) to avoid overwhelming the visualizer.
</p>
{{end}}
<ul>
	{{range $index, $e := $view.Ranges}}
		<li><a href="{{$view.URL $index}}">View trace by {{$view.Type}} ({{$e.Name}})</a></li>
	{{end}}
</ul>
{{else}}
<ul>

Running the `buildEnvironment` task visualises the buildscript dependencies of the selected project, similarly to how `gradle dependencies` visualizes the dependencies of the software being built:

----
$ gradle buildEnvironment
----

	and extend profstackdepth to apply to the CPU profiler and execution tracer.

	pagetrace: setting pagetrace=/path/to/file will write out a trace of page events
	that can be viewed, analyzed, and visualized using the x/debug/cmd/pagetrace tool.
	Build your program with GOEXPERIMENT=pagetrace to enable this functionality. Do not
	enable this functionality if your program is a setuid binary as it introduces a security

This also means that users can try the Gradle build without creating a new copy of the source tree.

 . link:https://scans.gradle.com[Create a build scan for the Maven build].
+
A build scan will make it easier to visualize what's happening in your existing Maven build.
For Maven builds, you will be able to see the project structure, what plugins are being used, a timeline of the build steps, and more.

// the following line will install handlers under the /debug/pprof/
// URL to download live profiles:
//
//	import _ "net/http/pprof"
//
// See the net/http/pprof package for more details.
//
// Profiles can then be visualized with the pprof tool:
//
//	go tool pprof cpu.prof
//
// There are many commands available from the pprof command line.
// Commonly used commands include "top", which prints a summary of the

==== Information about invalid consumable configurations

A project cannot have multiple configurations with the same attributes and capabilities.
In that case, the project will fail to build.

In order to be able to visualize such issues, the outgoing variant reports handle those errors in a lenient fashion.
This allows the report to display information about the issue.

=== Resolvable configurations report

Using external libraries in your Gradle projects can bring great convenience, but be aware that they can introduce complex dependency graphs.
Gradle's `buildEnvironment` task can help you visualize these dependencies, including those of your plugins.
Keep in mind that plugins share the same classloader, so conflicts may arise with different versions of the same library.

The separate link:https://plugins.jenkins.io/flaky-test-handler[Flaky Test Handler Jenkins plugin] can be used in addition to the JUnit Jenkins plugin to have such “flaky failures” also be visualized.

Tests are grouped and merged based on their reported name.
When using any kind of test parameterization that affects the reported test name,
or any other kind of mechanism that produces a potentially dynamic test name,