Accepted answer

You can use Eclipse's drop to frame command to re-enter the current method from the top. But it won't unroll any state changes that have happened, so it may not work depending on the sort of method you're in.

Another really cool tool that actually does let you step back and forward in time is the Omniscient Debugger. It works by instrumenting classes as they're loaded in the classloader, so it can record everything that your code does. It can do very cool things, like answer "when, where, and why was this field assigned its current value?". The UI is rather clunky, and it can have a hard time handling large code bases, but for some cases it can really save a lot of time.

Update: Chronon provides a commercial product that it describes as a "DVR for Java", which appears to do a lot of the same things as the ODB.


The question doesn't specify an Eclipse language, and many of the answers assume Java.

If using C++ and GCC with the GDB debugger, Eclipse has Run->Move to Line which does the job and functions like the Visual Studio Set Next Statement. In this case, Eclipse is using the capability that is in GDB.

If using Java, I'm not aware of a way to it with Eclipse or Netbeans, although other answers have suggested plugins. Eclipse does have the "drop to frame" command which works for Java in my version (Juno SR1). If I modify and save code within a function in debug mode, the execution line automatically moves to the top of the current function and I can continue from there. Not the same as specifying the line, but it is something.


I was looking for this feature in eclipse too. I know the visual studio can do that. Actually you can drag the current line marker and drop anywhere back in code. I'm not pretty sure if the changes to variables can be undone. But it is still very useful even so and saves lots of time. I've been waiting for this in eclipse for a very long.


I am biased, but Chronon does exactly what you are looking for.

Drop to Frame isnt exactly stepping back, since if the method has changed anything on the heap it wont be reverted.


Yes, Eclipse CDT has support of historical debugger feature.

Open Debug Configuration -> Debugger -> Enable Reverse Debugging at startup .

Than you can press shift+F5 or shift+F6 for step back like F5 or F6 for step forward.


Beyond what's been mentioned in earlier answers - i.e. Eclipse's drop to frame feature in the debug view, which restarts debugging earlier in the stack frame (but does not revert global/static data) and Omniscient debugger, which is a bit raw and not so much evolving - there are a few Eclipse-based tools that could be used to "go back" in (run)time:

JIVE extends Eclipse Java debugger with the ability to record the program states. The JIVE perspective provides some useful UML diagrams that are updated while the program is running. These diagrams provide an overview of the state of the application (object diagram) and of the stack trace (sequence diagram). You can query the memorized trace and step back and forward in time and see the corresponding diagrams.

Diver only records method calls and does not really record program states like JIVE. Every method call event is stored for later retrieval and analysis. It extends the Java Run and Debug configurations mainly to specify filters. Trace can be paused/resumed/filtered at runtime. Once recorded, the Diver perspective can display it in an interactive sequence diagram.

JIVE and Diver are open source projects issued from academic research. As of November 2012 both projects are active.

Chronon is a commercial product, but they have free licenses for students and open source projects. From what's being claimed on their website it's probably the most comprehensive recorder since it's able to replay the recorded history, step back and forth, allowing as they say time traveling debugging. Also Eclipse isn't needed for recording.

All of these plugin are quite greedy in resources so it's best to have a good spec machine and use their filter feature. A definite requirement to run them successfully is to extend the heap space in eclipse.ini.

In my case I've tried to use JIVE and Diver to debug an XML parsing program but always ended up freezing eclipse due to lack of resources. Diver could be tricky to run on linux 64bit, it works on ubuntu 32bit and possibly other 32bit distros using these tips. Diver works on Windows, better yet on a Windows 64bit + 64bit JVM otherwise you will be limited to a maximum heap space of 1.3-1.6Gb on 32bit windows. JIVE works great on my linux 64bit, and seems to work fine on other platforms.

Related Query

More Query from same tag