The JRuby Blog

The Ruby Programming Language on the JVM

Getting Started with JRuby and Java 7

Published by Charles Oliver Nutter on

Unless you’ve been living under a rock, you’ve probably heard about the new hotness for JRuby:
Java 7’s support for dynamic languages. You may also have heard about the huge perf gains
that JRuby’s seeing when running on Java 7. How can you try it yourself?

Get Java 7

The reference implementation for Java is OpenJDK, and
OpenJDK 7 has been out for almost six months now.
The current version is 7u2 (‘u’ stands for ‘update’), and includes a
number of improvements
over the GA (‘General Availability’) release.

Most platforms have easy access to OpenJDK builds. I’ll summarize the steps here.

Linux, Windows, and Solaris

Oracle provides binary downloads for Windows, Linux, and Solaris on its site. The JavaSE
page links to
both JDK and JRE download pages. You’ll probably want the JDK, since it includes other
JVM-related dev tools, but the JRE will work too. Download, install, and you’re ready.

Additionally, package managers for Linux and Solaris will likely soon have OpenJDK 7u2
packages available, if they don’t already.


The official preview of OpenJDK for OS X lags behind,
but you can get the current builds from the
openjdk-osx-build project. The build
you want is currently labeled “OpenJDK-OSX-1.7-x64-u2-b21”, but any build labeled “1.7”
and “u2” in the future will get what you need. The .dmg provides either a self-contained
JDK for you to drop onto your system or a .pkg installer that does it for you.

Update: Henri Gomez, the primary guy behind openjdk-osx-build, has set up a page specifically
for the update builds. Grab the JDK or JRE from his
OpenJDK7JDK7UOSX page.

Update 2: Oracle now has a supported build of Java 7 update 4 for OS X, so you can get it
from them! It only supports Lion, though, so if you’re on Snow Leopard you will still need
to use a build from Henri or build it yourself.


The OS X work is based off the “bsd-port” branch of OpenJDK. There are links to Java 7 package
information for FreeBSD, NetBSD, DragonFly BSD, and OpenBSD on the
BSD Port wiki. These may not be updated to
7u2 yet.

Why Update 2?

We haven’t previously made a lot of noise about Java 7 and JRuby, nor assembled a
blog post/tutorial like this, primarily because Java 7 GA was missing key optimizations
in the invokedynamic subsystem. JRuby 1.7 will make heavy use of invokedynamic, and if we had
released it before those optimizations were in place, it would have given people a bad
impression of the power of invokedynamic.

Update 2 now has a small set of optimizations that make a very large difference. If you intend
to start playing with JRuby 1.7 builds, we strongly recommend you use OpenJDK 7u2 or higher.

Update: Your jruby -v output should look something like this:

jruby (ruby-1.8.7-p352) (2011-12-19 f404f75) (OpenJDK 64-Bit Server VM 1.7.0-u2-b21) [darwin-amd64-java]

The important bit is that “u2” appear somewhere in that line.

Getting JRuby

Of course getting JRuby is always pretty easy.

JRuby 1.6.x (current release)

The current release of JRuby is always available on the JRuby homepage.
Here, you’ll find tarballs, zipfiles, Windows installers, and JRuby in other forms. Download,
unpack, add bin/ to PATH, and you’re ready.

If you want to get the leading edge of the JRuby 1.6 line, including fixes that have not yet
been released, you can download a nightly snapshot from JRuby’s
release snapshots page.

You can also install JRuby through RVM or rbenv, using rvm install jruby or
rbenv install jruby-1.6.5, respectively. This is our recommended procedure for folks
already using RVM or rbenv. It’s also possible to build/install JRuby 1.6.x snapshots using
rvm install --branch jruby-1\_6 jruby-head.

Windows users may be interested in pik, an RVM-like
tool for managing Ruby installations. It supports JRuby, naturally.

There are also JRuby packages for most major Linux and BSD variants. They’re not always
up-to-date, however.

Finally, you can clone JRuby from the JRuby github repository
and build the jruby-1_6 branch.

JRuby 1.7.x (in development)

Update: JRuby 1.7.0.preview1 has been released!
We are very interested in bug reports for the new invokedynamic support, and wanted to get
this preview out for people to test. There will be issues, don’t think for a moment there
will not…but that’s what previews and release candidates are for. Help us make 1.7.0

JRuby 1.7 is not out yet…we had been waiting for OpenJDK 7u2 to drop before starting
our finalization process. But we’re looking for folks to start playing with it now. Until we
release JRuby 1.7, you can get it a few different ways.

Simplest is probably to grab a snapshot from the JRuby’s
master snapshots page. You’ll find the usual complement
of packages and installers there.

RVM can install JRuby master using rvm install jruby-head.

And of course, you can clone from Github and build the master
branch yourself, by running ant. JRuby runs fine from the working copy.

Use the Right Java Version

Ironically, the most complicated part of this process is making sure your system is set up
correctly to use Java 7 instead of some other version. The simple answer is to hardcode the
Java 7 bin/ dir in your shell’s PATH, but that’s both inelegant and incompatible with some
systems’ preferred mechanisms. Here’s a short survey of more elegant ways to easily swap Java


As with most things, Linux variants don’t agree on how to manage multiple alternative versions
of a given package. Below I summarize the “blessed” way to do it on various Linux flavors.

Alternatively, you can rig up a trivial shell function or script that, when run, rewrites your
environment to point at the target Java installation. See the “pickjdk” script for OS X below.

Debian variants (Debian, Ubuntu, etc)

On Debian, your command of choice will be update-java-alternatives. This resets a set of
global symlinks to point at the Java installation you prefer. It’s not the most elegant way,
since the change is made globally, but it is the blessed way.

RedHat variants

RedHat has a similar command called “alternatives”, under which there’s a “java” namespace.
the JBoss 5 docs have a nice page on
setting the default JDK on RHEL

Gentoo and other Linux variants

I have so far been unable to find a way to easily manage multiple installed Java versions on
Gentoo. Feel free to submit suggestions in the comments.

Update: Gentoo’s mechanism is the java-config command. java-config -L lists all
installed runtimes, and java-config -set X sets the default to runtime X.


On Windows, your best best is generally to put the preferred Java version’s bin/ dir in PATH.
If you have other suggestions, feel free to comment.


Your best option will be to use the oft-tweaked “pickjdk” script, which scans installed JDK
versions and presents a menu. Selecting a version rewrites your environment to point at that
version. I prefer my pickjdk variant, since it allows specifying an install number directly
without going through the menu.

An alternative is to configure your environment manually. Java installations are located under
/Library/Java/JavaVirtualMachines; set JAVA_HOME to
/Library/Java/JavaVirtualMachines/1.7.0u.jdk/Contents/Homeand prepend $JAVA_HOME/bin to
your PATH. You’re ready to go.

Update: There’s an easy way to find available JAVA_HOMEs: the java_home command.
/usr/libexec/java_home will return the path to the default JVM (from Java Preferences).
You can also specify -v 1.7 for the first Java 7 (1.7) install, or pass -V to
list all available JVMs.

You can also open up the Java Preferences utility (located in /Applications/Utilities)
and drag your preferred Java version to the top. This is a global change, and will affect
any programs that use the default Java version. Because the GUI parts of the OS X Java 7
preview are still in development, THIS IS NOT RECOMMENDED.

Other OSes

I don’t know the proper mechanism for managing Java installations on the other BSDs
or on Solaris. Feel free to comment.

Try It Out!

Once you’ve got JRuby installed and in PATH (via whatever mechanism) and Java 7 installed
and in PATH (via whatever mechanism), you’re ready to test it out! Start up jirb,
launch your favorite JRuby-based app, or just run some benchmarks.

If you’re especially interested in performance, try out
from JRuby’s benchmark suite. It’s a pure-Ruby implementation and benchmark of a red/black
tree, and a good representation of the kind of performance improvements you should see
from JRuby on Java 7. There’s plenty of other benchmarks in our suite and in the wild…
play around and let us know how it goes.

What to Expect

Java 7 brings a lot of performance updates, even without invokedynamic. If you’re using JRuby
1.6.x, you should see an immediate performance improvement moving from Java 6 to Java 7. I
have heard reports of anywhere from 10-30% faster applications.

If you’re trying out JRuby master (1.7), you should see even more significant improvements.
JRuby 1.7’s use of invokedynamic means that Ruby code runs faster, optimizes better, and uses
fewer resources. In fact, if you don’t see better performance with JRuby 1.7 versus JRuby
1.6 on Java 7, please report an issue at JRuby’s bug tracker. You’ve
probably found a flaw in our compiler…a flaw we’ll want to fix before release.

As a bit of a teaser, here’s my numbers running the red/black tree benchmark
from above (the numbers are time in seconds). Compared to JRuby on Java 6, JRuby
on Java 7 without invokedynamic is around 25% faster, and JRuby with invokedynamic is nearly
3 times faster.

It’s also worth mentioning that invokedynamic isn’t “done”. There’s a new optimizer planned for
Java 7u4 and my OpenJDK friends tell me there are many opportunities to increase performance.
JRuby on Java 7 will just keep getting faster.

JRuby has room to grow as well. We’re using invokedynamic heavily for the upcoming 1.7 release,
but there’s many places yet to be adapted. The performance you see today is not the end of the
story…there’s a lot more we can do.

Your Turn

That’s about it for this tutorial. Hopefully you’ll be up and running on JRuby with Java 7
very quickly. If you have any trouble, please comment…we’ll try update this article with
fixes and suggestions. And I repeat my call for feedback on JRuby master + Java 7…this is
the future of JRuby, and it could be the future of high-performance Ruby. Let’s work together
to make it awesome!