Free tools Windows power users keep installed
One-click scans. No signup required.
Ulyp lets you record a selected Java or Kotlin JVM execution path and inspect its method-call tree and captured values afterward in a desktop UI. It can help explain what a framework or library is doing when ordinary step-through debugging is awkward—but bytecode instrumentation can substantially change execution speed, so treat a recording as evidence of call flow, not a reliable performance measurement.
What Ulyp records—and what it does not
Ulyp is an open-source tracing debugger for Java and Kotlin applications running on the JVM. Its project README describes it this way: “The tool records everything you app does, and you then can analyze the execution flow.” That is the project’s description, not a guarantee that every runtime action or value is captured. The documented workflow uses a Java agent to instrument bytecode, writes a recording file, and opens that file in a JavaFX desktop interface for inspection. The basic repository example requires no application-code changes. Ulyp repository and README
The useful evidence is selected method-level flow: which instrumented methods ran and, depending on configuration, information about their arguments, returns, or other values. This is not a complete heap snapshot. Some objects may be represented by class and identity hash code; collections and arrays have separate capture controls, and strings may be length-limited. Check the README for the exact release you install because options and defaults can change. The implementation discussion describes how entry/exit advice and per-thread event buffers contribute to recording overhead. Andrey Cheboksarov’s DZone implementation discussion
When a method-call recording is useful
Inspecting framework and library behavior
A recording can make nested calls visible when documentation describes an abstraction but not the path a particular invocation takes. In the DZone tutorial’s Jackson example, the author records repeated ObjectMapper.readValue calls and observes a larger first call tree than the second, attributing the difference in that demonstration to lazy deserializer initialization and caching. This is an illustration of one run, not a general Jackson performance result.
Recommended Free Tools
#1 Best Overall
The same tutorial follows a transactional Spring service through a generated proxy, DynamicAdvisedInterceptor, TransactionInterceptor, and transaction-manager interactions. That call path helps connect a declarative transaction annotation with the framework machinery invoked for the selected operation. DZone tutorial and examples
Learning an unfamiliar codebase
For onboarding or a difficult bug, record a small, reproducible action and inspect its call tree. This can reveal an unexpected delegation, branch, or library boundary that is hard to find from the application’s entry point alone. Use the recording to form a hypothesis, then check relevant source code, documentation, or a targeted test; a trace shows what was recorded, not why the code behaves that way.
Rank #2
How to make a focused Ulyp recording
The following follows the repository’s documented agent workflow. Substitute the path and matcher for your own environment, and consult the README matching your Ulyp version for supported options and defaults.
- Build or download the agent. Obtain the Ulyp agent using the project’s repository instructions: https://github.com/cheb0/ulyp.
- Choose a narrow recording trigger. Configure a method matcher, for example
-Dulyp.methods=**.HibernateShowcase.*, to begin recording when a matching method is reached. The project also documents package inclusion and exclusion filters for controlling scope. - Choose an output file. Set a destination such as
-Dulyp.file=/tmp/recording.datso you can find the resulting recording after the run. - Start the JVM with the agent. Add
-javaagent:/path/to/ulyp-agent-1.0.0.jarto the application’s JVM arguments, along with the selected Ulyp system properties. - Run a representative path. Exercise the smallest realistic action that can expose the behavior you want to understand. A narrow trigger and workload make a recording easier to navigate and limit unnecessary instrumentation.
- Open and inspect the recording. Use Ulyp’s desktop UI to open the output file, inspect the call tree, and follow relevant captured values. Confirm an interpretation against source or documentation rather than treating the trace as a complete explanation.
Documented configuration includes method matching, package filters, optional call-duration timestamps, constructor capture, collection and array recording, and string capture length. Lambda and static-block capture are marked experimental in the project documentation. These are version-sensitive controls; enabling more capture can add overhead and may collect values you do not need.
In the DZone tutorial’s Java 21 Jackson demonstration, the launch configuration includes --add-opens for java.base/java.lang and java.base/java.lang.invoke. Those flags belong to that example and version context; they are not established as universal Ulyp requirements.
Account for instrumentation overhead
Ulyp’s agent inserts advice at method entry and exit. Events are buffered per thread and encoded or written through background work, while some values—collections and arrays, for example—may be recorded synchronously when enabled. This can alter both workload and timing.
Rank #4
Cheboksarov’s 2024 DZone tutorial estimates that a typical Java application may run “somewhat about x2-x5” slower while recording, with CPU-bound applications potentially worse. This is the author’s experience estimate, not an independently validated benchmark or a universal multiplier. The actual effect depends on the application, instrumentation scope, and capture settings. The tutorial advises local or development use and cautions against production use. Do not use an instrumented trace as a latency benchmark; validate timing with a less intrusive method appropriate to the question.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Ulyp, JFR, or Android Studio Profiler?
Choose by the evidence you need and the runtime you are investigating. These tools answer related but different questions.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
| Tool | Target | Evidence and scope | Overhead and best fit |
|---|---|---|---|
| Ulyp | Java/Kotlin JVM applications | Instrumented selected method call trees and configurable captured values; scope can be narrowed with method matchers and package filters. | Instrumentation can substantially perturb execution. Use it to explain a selected control-flow path or inspect library/framework calls. |
| Java Flight Recorder (JFR) | JVM applications | JVM events and sampled CPU/thread information for runtime diagnosis. Oracle’s Java SE 25 guide says most Java Application event types are recorded only when longer than 20 ms by default; thresholds can be lowered. | Lowering event thresholds can increase overhead. Prefer it when investigating CPU load, thread stalls, monitor waits, I/O, garbage collection, or other runtime bottlenecks. Oracle Java SE 25 JFR troubleshooting guide |
| Android Studio Profiler method recording | Android apps | Java/Kotlin method recording with timestamps at method entry and exit. | Google recommends keeping method recordings to five seconds or less to reduce instrumentation overhead and warns that tracing timings can differ from production. This is Android-specific guidance, not a Ulyp measurement. Android Developers method-recording documentation |
In practical terms, use Ulyp when you need to see which selected methods and values participate in a path. Use JFR when the question is about runtime events or resource bottlenecks, and Android Studio Profiler for Android-specific method traces. Oracle’s Java SE tools overview also describes the broader JVM diagnostic-tool context: Oracle Java SE Tools.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
