How to develop your IntelliJ IDEA plugins even faster with JRebel

Back in my NetBeans times I wrote several articles (1, 2) about using Zeroturnarounds JRebel to develop NetBeans plugins faster by not restarting nor reloading the whole target-platform. JRebel is a Java agent, so it can be used with nearly every Java-based application. Even for developing IDEA plugins. And here is how you do it:


  1. Buy a JRebel license or get a free one for your open-source plugin at myRebel
  2. Install the JRebel plugin for IDEA from the plugin manager (for bundling JRebel, a configuration UI and debugging support)
  3. Activate the plugin using the license from step 1
  4. Update the your Run- or Debug configuration with the Java agent configuration – based on the standard documentation)
    For example: -agentpath:/Users/markiewb/Downloads/jrebel/lib/libjrebel64.dylib


  1. Run / debug your plugin using the configuration created above – JRebel should show its banner and an IDEA instance should load
  2. Edit your Java sources as normal and when you want to get the changes reloaded then compile the project/all the changed files (thus the sources are compiled into class-files and JRebel can pick up the changes)
  3. Reinvoke your plugins actions (or what ever) in the target platform – your changes should be picked up


Note 1 Not all changes will be picked up. JRebel does not have yet official support for this usage scenario. Especially changes in the plugin.xml won’t be picked up. But within existing or new Java classes you can code and refactor as much as you like!

Note 2 If you are on Mac OS consider to install JRebel separately. I had issues to set the Java agent with the bundled JRebel from the JRebel IDE plugin. Do you see the culprit in -agentpath:/Users/markiewb/Library/Application Support/IntelliJIdea2017.2/jr-ide-idea/lib/jrebel6/lib/libjrebel64.dylib? The whitespace!

Note 3 Of course this also works when you write plugins for the other Java based IntelliJ platform IDEs like WebStorm, PHPStorm and so on.


Improved Maven-based NetBeans Platform Application Development using JRebel

Some months ago I already blogged about how to tweak the pom.xml of your Maven-based NetBeans platform application so that you can use JRebel to reload your changes. [1] This process has been simplified in the meantime. Thanks to Peter Hansson for letting me know. Steps:

  • Install the JRebel NetBeans IDE Plugin (from the Plugin Center or from your IDE)
  • Make sure “Compile on Save” is enabled for your project.
  • Make sure the “Enable/Disable JRebel” toolbar button is checked.
  • Generate a rebel.xml file: In the context menu of the project choose “Open JRebel panel” and check the checkbox next to your project in the JRebel Panel.
  • Alter the properties section of the pom.xml like this
        <!-- for JRebel 5.x / JRebel 6 Legacy Client -->
            <>-J-javaagent:"${current.jrebel.agent.path}" -J-Drebel.log=true ${}</>
        <!-- for JRebel 6.x (Non-Legacy Client)-->
            <>-J-Xbootclasspath/p:C:\temp\rebelboot.jar -J-javaagent:"${current.jrebel.agent.path}" -J-Drebel.log=true ${}</>

    The NEW and COOL thing is that you do not have to bother yourself with the path of the JRebel jar file anymore. The JRebel NetBeans IDE plugin sets the path to the JRebel jar from your IDE into the Maven property “current.jrebel.agent.path” and you can reuse it in your pom.xml. Now there will be no hardcoded paths anymore, when you check-in your pom.xml to SCM – except the JRebel6 bootclasspath edge-case.

  • run the module – the application with your module and JRebel should start up
  • make changes to your classes and JRebel will pick them up

Here a screenshot to illustrate the previous steps: 2014-09-03_23h34_17 Tested with NetBeans 8.0, JRebel NetBeans IDE Plugin 5.6.2 [1]

Maven-based NetBeans platform development with JRebel 6 – minor update

Some months ago I wrote about how easy it is to use JRebel for development of NetBeans platform module [1]. That article was focused mainly on standard ant-based modules. But recently I started to convert my plugins to the maven-based approach. At the same time I started testing JRebel 6 in an EAP. This combination didn’t work as described in one of my previous blog entries [2], but I figured it out and I like to document it using this blog post.

Steps to get maven-based nbms running using JRebel 6

  • enable “compile on save”
  • generate rebel.xml to /src/main using the context menu of jrebel (this way it will be copied to target/classes)
  • alter the properties-section of the pom.xml like this
            <>-J-noverify -J-javaagent:e:/tools/jrebel/jrebel.jar -J-Drebel.log=true ${}</>
  • run the module – JRebel will create a bootstrap file in your temp directory once and will quit the execution
    JRebel: Starting logging to file: C:\Users\markiewb\.jrebel\jrebel.log
    [INFO] JRebel is now building a boot class cache.
    [INFO] This will only happen on this first run, or after manually deleting the rebel boot folder.
    [WARNING] JRebel bootclasspath not specified!
    [WARNING] Make sure to add -Xbootclasspath/p:C:/Users/markiewb/AppData/Local/Temp//rebelboot.jar to jvm arguments
    [WARNING] Otherwise this warning will appear again, and you won't be able to start your application
    [INFO] System will exit now, please restart the application to run with JRebel enabled.
  • add the bootclasspath argument with the path from the previous output to too (please note the “-J” prefix, that is important) (If NetBeans does not start, try to remove ${} from the <>-parameter
            <>-J-noverify -J-Xbootclasspath/p:C:\Users\markiewb\AppData\Local\Temp\rebelboot.jar -J-javaagent:e:/tools/jrebel/jrebel.jar -J-Drebel.log=true ${}</>
  • run the module – the application with your module and JRebel should start up
  • make changes to your classes and jrebel will pick them up

Tested with Win7 64bit, Oracle JDK 1.7.0u40, JRebel 6.0.0-M3, NetBeans IDE 7.4



  • Tested with Win7 64bit, Oracle JDK 1.7.0u45, JRebel 6.0.0-M6, NetBeans IDE 7.4Patch2
  • Added comment about removing ${}


NetBeans platform development with JRebel even more simplified

Many things in the JRebel universe have changed in the last months. Several new versions of JRebel were released, Zeroturnaround acquired Javeleon [1] and the JRebel-Plugin for NetBeans IDE got better and better.

Especially the support for developing NetBeans platform/RCP applications has been improved. In my posts [2], [3], [4] I showed you how to configure JRebel to reload your changes within NB platform/NB IDE modules. These are mostly obsolete. The whole process has been simplified, the number of manual steps have been reduced. For example: you don’t need to modify any property-file anymore to tell NetBeans to load the JRebel as javaagent.

Please note that the following description only applies to ant-based module development. The maven-based module development still requires some additions to the pom.xml to get JRebel running.

So if you want to use JRebel to “instantly reload” your compiled changes to a fixed- (or locally compiled bleeding-edge-dev-) version of NetBeans IDE (or your own target platform) you have to follow these simple steps:

  1. install the JRebel-NetBeans-Plugin from the plugin portal and register your license, if not already done
  2. open your module (or open a module from the checkout sources of NB IDE)
  3. generate a rebel.xml in the source folder of the module – let the JRebel-plugin do this for you (right click on the project node, then “Generate rebel.xml“)
  4. make sure that the JRebel icon in the toolbar is checked (this is important, because this tells the plugin to add the -javaagent argument to command line of the next run/debug)
  5. run the module (you will see the JRebel headers in the output window, which means JRebel is loaded, and the target platform with your module activated will be opened)
  6. make your changes to the code, compile via F9 (this includes saving – that’s the trick)
  7. go back to the previously started instance of the target platform, repeat your actions and the changes in code are reloaded instantly (Please note that reloads of changes to layer.xml or additions to aren’t supported. In this case you still have to “build” and “run” the module again.)

This makes it much easier (at least for me) and I hope this simplicity will also attract other developers to write plugins or even to contribute to NB IDE development.

Tested with NB7.3/7.4dev, JRebel-NB-Plugin 1.5.1 and JRebel 5.2.2.


Update 2013/10/13: To use JRebel with locally compiled bleeding-edge-dev version of NetBeans IDE you still have to set the tryme.arg.hack property in nbbuild/ as described in [2]

For example: tryme.arg.hack=-J-Dnetbeans.full.hack=true -J-noverify -J-javaagent:c:/Users/markiewb/AppData/Roaming/NetBeans/7.4/jrebel/jrebel.jar -J-Xbootclasspath/p:C:/Users/markiewb/AppData/Local/Temp//rebelboot.jar -J-Drebel.log=true

Tested with JRebel 6.0-M3 and NB7.4

NetBeans IDE module development with JRebel

This post is mostly obsolete: See for an updated version.

In my previous post i showed you how to create your own nbm-modules with the help of JRebel. Today i will show you how you can use JRebel to fasten up the development of the NetBeans IDE platform modules.

So if you want to use JRebel to “instantly reload” your compiled changes to a locally compiled bleeding-edge-development-version of NetBeans IDE you have to follow these steps:

  1. checkout the sources
  2. run “ant” to compile the sources and build a NetBeans installation
  3. open a module to be changed from the checkout sources
  4. create or open \nbbuild\
  5. add the line: tryme.args=-J-noverify -J-javaagent:d:/tools/JRebel/jrebel.jar -J-Drebel.log=true (update the path to the correct installation folder)
  6. create or generate a jrebel.xml in the sourcefolder of the module – let the JRebel-plugin do this for you
  7. run the module against the previously compiled version of NetBeans IDE (now called “target-platform“) using the context menu-entry “Run” (you will see the default JRebel headers in the output window, which means JRebel is loaded, and the Target-IDE will be opened)
  8. make your changes to the code, compile via F9
  9. go back to “target-platform“, do your actions again and the changes are reloaded instantly

FYI: The info about the correct location was taken from

Fast NetBeans module development with JRebel – with screencast

This post is mostly obsolete: See for an updated version.

Based on a previous post i made a small video screencast to show how to use JRebel to improve your productivity when developing NetBeans modules.

1. Preconditions and setup

  • NetBeans 7.1.2/7.2.x installed (should work also with other version, but only these two were tested)
  • a valid installation of JRebel > 4.5.x (tested with 4.5.x, 4.6, 4.6.2, 5.0.0)
  • a valid license for JRebel – can also be the free social one – has to be configured in the JRebel configuration wizard
  • JRebel Netbeans Plugin 1.2 installed (use the update center) – required for debugging JRebel-instrumented code and generating rebel.xml
  • Change shortcut for “compile” to CTRL-S (Compile includes saving) – the equivalent to eclipse “Build automatically” or NetBeans “Compile on save” (Because “compile on save” is not yet available for module development projects)

2. Step by step

  •  Follow the instructions to generate a sample project @
  •  Select “Generate rebel.xml” in the context menu of your project, select the root path of your sources
  •  Add the following line to \nbproject\ (can be found in the Projects-panel named as “NetBeans Platform Config”)
    run.args.extra=-J-noverify -J-javaagent:d:/tools/JRebel/jrebel.jar -J-Drebel.log=true
    These parameters are taken from the offical JRebel documentation
  • Run the project -> a new NetBeans instance should be opened
    Note the output of the activated JRebel plugin in the output window of the development:
    JRebel: Starting logging to file: D:\tools\JRebel\jrebel.log
    [2012-05-19 12:05:05] #############################################################
    [2012-05-19 12:05:05]
    [2012-05-19 12:05:05] JRebel 4.6.2 (201205021440)
    [2012-05-19 12:05:05] (c) Copyright ZeroTurnaround OU, Estonia, Tartu.
    [2012-05-19 12:05:05]
    [2012-05-19 12:05:05] Over the last XXX days JRebel prevented
    [2012-05-19 12:05:05] at least XXX redeploys/restarts saving you about X,X hours.
    [2012-05-19 12:05:05]
    [2012-05-19 12:05:05] Over the last XXX days JRebel prevented
    [2012-05-19 12:05:05] at least XXX redeploys/restarts saving you about X,X hours.
    [2012-05-19 12:05:05]
    [2012-05-19 12:05:05] This product is licensed to XXXX
    [2012-05-19 12:05:05] until XXX
    [2012-05-19 12:05:05] #############################################################
  • Ignore the OSGI-exceptions (JRebel does not yet officially supports nbm-development) – UPDATE: this seams to be fixed in JRebel 5.0.0
  • Change the method content, change fields, do some refactoring …
  • CTRL-S for compiling including saving (see setup above)
  • execute the action in the target IDE again -> JRebel will reload the code

Netbeans module development with JRebel

This post is mostly obsolete: See for an updated version.

In [project]\nbproject\ add the following line

run.args.extra=-J-noverify -J-javaagent:e:/tools/jrebel/jrebel.jar -J-Drebel.log=true


  • This requires a proper installation of jrebel in the path e:/tools/jrebel/
  • Do not forget to generate a rebel.xml into the root of your classpath
  • You have to compile the changed java source manually by Menu->Run->Compile file(“Compile-on-save” is not yet available for netbeans modules)
  • There will be some OSGI-exceptions when running/debugging the application, but class reloading works properly.

Tested with NetBeans IDE 7.1 RC2 (Build 201111302200)+7.1, JRebel 4.5.3

Other resources:

Update: You can also have a look at Javeleon

Update 2: In maven-based nbms you can run modules the following way (JRebel 4, 5)

  • enable “compile on save”
  • generate rebel.xml to /src/main using the context menu of jrebel (this way it will be copied to target/classes)
  • alter the properties-section of the pom.xml like this
            <>-J-noverify -J-javaagent:e:/tools/jrebel/jrebel.jar -J-Drebel.log=true ${}</>
  • run the module the normal way – you will accounter some osgi-exception as mentioned above
  • make changes to your classes and jrebel will pick it up like [207230] JRebel: Reloading class ''.
  • small issue: the jrebel-messages do not appear on the output-window – but in jrebel.log

Update 3:
@mkleint also blogged about JRebel and NBM-development at