Compiling/ Running/ Debugging

IntelliJ IDEA is capable of debugging Java, Ruby, Groovy, JavaScript, ActionScript, and other code, offering unified user interface that allows you to keep complete track of the debugging process via fully customizable layout of Console, Variables, Frames and Watch views. Plus, Selective Step Into for better complex statement calls debugging, object instance markup and automatic variable watching, accompanied by smart recursion analysis in the Stack view, and more — everything tied together to create productive application debugging environment.


Annotation processors support

IntelliJ IDEA fully supports Java Annotation Processors.

Annotation Processors Annotation Processors (click to enlarge)

You can read this blog article that explains their use.

Multiple compilers supported


In IntelliJ IDEA, you have an option of compiling your sources with the javac, jikes, or eclipse compiler. No matter which one you use, your sources will be compiled against target JDK libraries.

Dependency-based make

Using dependency-based make will get IntelliJ IDEA to automatically re-compile all modified classes together with those depending on them.

Possibility to specify target JDK

The application you are developing with IntelliJ IDEA may have to be compatible with an arbitrary version of JDK. Now, with the new, module-based, project structure, this requirement may apply even to particular modules. This can be easily achieved with the help of the target JDK option, so that your project or a separate module will be compiled, run and debugged under a specified JDK version, independently of the JDK used for running IntelliJ IDEA itself.

Ability to automatically copy resource files from the source to output directory

Sometimes you might need some of your resource files located in the source directories to be automatically copied to the project output. IntelliJ IDEA provides you with a flexible option to specify patterns for the necessary files (with the possibility to use regular expressions) so that not all but only the proper resources are copied.

Quick and easy navigation from compilation errors to the corresponding source


The convenient compilation results view enables you to navigate to the source of any compilation error or warning in the code with a single key-stroke. Even while in the editor, you can easily navigate through all of your compilation errors with the help of the next/previous shortcuts.

Running and Debugging

Thread dump analyzis in debugger

You can take snapshots of arbitrary threads and dump them to dedicated debugger tabs for closer investigation.

New, flexible user interface layout

debug Flexible Tool Window

User interface that streamlines the debugging process and makes analyzing data easier and more intuitive.

Fast and powerful debugger with HotSwap support

Debugger New UI

IntelliJ IDEA includes a JPDA-based debugger with a simple, easy to use user interface.

Code completion, intention actions, and syntax/error highlighting will ease speed up your work in different debugger dialogs. IntelliJ IDEA also supports the HotSwap feature that allows you to modify and recompile code during debugging, without need to restart.

Smart Selective Step Into

Smart Step Into

Debugging of complex call statements is made easier than before: now you can select which part of the call you want to debug.

Customizable marks for object instances

Keep you focused on the debugging process and let track different object instances at ease. Plus, you can opt to automatically mark values referenced by static final fields with the corresponding field name.

Intelligent recursion analysis

Debugger Recursion

This feature simplifies debugging with highlighting of recursive calls in Frames view, letting you easily analyze them and find probable cases of infinite recursion.

Multiple execution profiles


IntelliJ IDEA allows you to configure multiple execution profiles for applications, applets, JUnit tests, remote processes and WebLogic instances, making it easy to either run or to debug your software. You can quickly select a configuration to run or debug, directly from the main toolbar.

Sharing run configurations

Run configurations can be saved in project file, which allows sharing them among team members

Temporary run/debug configurations


You can run any class or test, containing the main() method, directly from the Editor, or one of the project views. IntelliJ IDEA will automatically create a temporary run/debug configuration for the class, so that you can later save it as a permanent one, if necessary, or just use during the current IntelliJ IDEA session.

Temporary configurations are supplied with semi-transparent icons, for easier recognition.

Colored output in console


IntelliJ IDEA allows you to visually distinguish data originating from different sources: output from a standard output stream is colored in black, from a standard error stream is colored in red, and user input is colored in green.

Multiple types of breakpoints

In addition to the standard line breakpoints, IntelliJ IDEA suggests a set of features helping you in different aspects of the debugging process:

  • Exception breakpoints You can set up an action that will be executed whenever an exception of the specified type is thrown. There's a possibility to react on caught or uncaught exceptions only or both.
  • Field modification/access watchpoints You can track access or modifications of an arbitrary chosen field. By using instance filters, you can watch the access and modification events only on the fields of a certain class instances
  • Method entry/exit breakpoints This type allows you to track method entry and exit events

For each breakpoint type, you can define filters (Instance filters, Class filters and Pass count conditions) as well as specify the following properties:

  • Conditions You can specify a boolean expression for a breakpoint. The debugger will pause on the breakpoint only if the condition is evaluated to 'true'
  • Dependencies

The breakpoint can depend on another one, which means that it won't be hit until the specified breakpoint is hit.

Custom object display in debugger


IntelliJ IDEA allows you to specify how different objects are displayed in the debugger, by class basis. You can assign expressions to display, instead of just standard String representation. You may, for example, want to display the User object only by login or full name. This saves your time incredibly when you need to analyze complex debugger output. The so-called Type Renderers can be customized through the Debugger dialog of the IDE Settings.

Navigation to source from exception stack traces


When you run or debug your program in IntelliJ IDEA and some exception trace is printed to the console, you may easily navigate from the console directly to the source code with one click. Also you can quickly output the full thread dump right in the console.

If you get an external stack trace (from QA engineer or bug tracker), just copy it to the IntelliJ IDEA's Stack Trace Analyzer, and the stack trace will appear in the console with the navigation to source available. Read more about analysis of external stack traces.

Step Over, Step Into, Step Out, Force Step Into, Run to Cursor, Pop Frame


Stepping commands allow you to precisely control the program execution by allowing you to step over to the next line of code, jump into the current method about to be called and to step out of the current method.

The step filters allow you to specify classes, packages, or class patterns that you do not wish to step into. This is useful if you are only interested in tracing through your own code and want to avoid stepping into outside libraries. Nevertheless, if during debugging you come across such classes, and you feel the need to step into them, IntelliJ IDEA provides you with the Force Step Into action, so that you can override the exclusion rule for a particular case.

The Pop Frame command pops the last debugger frame from the stack and restarts from the preceding execution point

Remote debugging

IntelliJ IDEA's debugger is capable of attaching itself to a running process using either socket or shared memory transport. This makes it possible to debug server-side programs (such as servlets) that are executed in the context of an application server. IntelliJ IDEA integrates with multiple application servers and provides general support for JSR45 servers for JSP debugging.

Read more about integration with application servers.

Expressions evaluations

You can create a list of watches, where each of expressions will be evaluated whenever the debugger is paused. You can also evaluate a single arbitrary expression in the context of a selected execution point, and the expression may contain method calls (Alt + F8).
All expressions are evaluated in the context which you are debugging.

Variable modification

Allows you to replace the value of a selected variable with the value of an arbitrary evaluated expression.

Tooltips with variable values right in the editor

Whenever a mouse pointer is over a local variable or a field in the editor a tooltip with the item's value will be shown.

Ability to export threads state to a text file

Whenever the debugger is paused, there is a possibility to save the information about the threads currently running in a text file or the clipboard.

Configurable set of types to show as toString() by default

Using this feature, you can configure the way an object instance is rendered by the debugger. You may need to view all objects with redefined toString() method as toString(), or specify object patterns.

Alternative view for Collection classes

Convenient way to explore standard java collections (Lists, Sets, Maps) when they are presented in an array-like view. You are also provided with an option to limit the number of shown elements.

Ability to copy node text to the clipboard

Ability to invoke toString() on an object and copy the resulted string to clipboard.

to the top