Jogl FAQ

JOGL FAQ

What are the Runtime OpenGL Version Requirements ?
The current JOGL2 spec is in WIP state, but mostly finished. We do not require any extra features of GL versions > 1.1, hence it shall just work.

E.g. if you want to Just query their availability e.g.: gl.isExtensionAvailable("GL_VERSION_1_3")
 * support OpenGL platforms not supporting a version &gt; 1.2
 * use GL &ge; 1.3 features optionally

If you call a &gt; 1.2 GL function where it is not available, a GLException is thrown.

JOGL requires at least an OpenGL version 1.1, due to it's dynamical function binding starting with OpenGL 1.2.

Use and test Autobuilds
I like to summarize how to manually test the JOGL autobuilds, starting with 2010-11-10.

You can fetch autobuilds from one the autobuild folder.

Runtime Version Check
The simplest verification of a JOGL build is to use the runtime version check.

For JOGL, it should run 2 tests. - JOGL Platform: Linux 2.6.35.7-x86_64-k10-x8-risa (os), amd64 (arch) JOGL Platform: littleEndian true, 32Bit false, a-ptr bit-size 64 JOGL Platform: Java 1.6.0_21, Sun Microsystems Inc., http://java.sun.com/, is JavaSE: true
 * Just the VersionInfo of the JAR's manifest file

JOGL package javax.media.opengl JOGL Implementation-Title = Java Bindings for OpenGL Runtime Environment JOGL Implementation-Version = 2.0-b211-20101110 JOGL Specification-Vendor = JogAmp Community JOGL Manifest-Version = 1.0 JOGL Created-By = 1.6.0_21-b06 (Sun Microsystems Inc.) JOGL Implementation-Vendor = JogAmp Community JOGL Implementation-Commit = 0893339854e3f4a4fab7b19e073304973e763b10 JOGL Ant-Version = Apache Ant 1.8.0 JOGL Implementation-Vendor-Id = com.jogamp JOGL Trusted-Library = true JOGL Specification-Title = Java Bindings for OpenGL API Specification JOGL Implementation-Branch = master JOGL Specification-Version = 2.0 JOGL Extension-Name = javax.media.opengl -

 - JOGL NEWT Test main GLAvailability[Native[GL4bc true[4.1 (compatibility profile, any, new)], GL4 true[4.1 (core profile, any, new)], GL3bc true[3.3 (compatibility profile, any, new)], GL3 true[3.3 (core profile, any, new)], GL2 true[3.0 (compatibility profile, any, new)], GL2ES1 true, GLES1 false, GL2ES2 true, GLES2 false], Profiles[GLProfile[GL2ES2/GL2], GLProfile[GL2ES1/GL2], GLProfile[GL2/GL2], GLProfile[GL4/GL4], GLProfile[GL3/GL3], GLProfile[GL4bc/GL4bc], GLProfile[GL2GL3/GL2], GLProfile[GL3bc/GL3bc],, default GLProfile[GL2/GL2]]] JOGL NEWT Test main Swap Interval -1 JOGL NEWT Test main GL Profile   GLProfile[GL2/GL2] JOGL NEWT Test main CTX VERSION  3.0 (compatibility profile, any, new) - 3.0.0 NVIDIA 260.19.12 JOGL NEWT Test main GL           com.jogamp.opengl.impl.gl4.GL4bcImpl@76497934 JOGL NEWT Test main GL_VERSION   3.0.0 NVIDIA 260.19.12 JOGL NEWT Test main GL_EXTENSIONS JOGL NEWT Test main              GL_ARB_blend_func_extended GL_ARB_color_buffer_float  -
 * VersionInfo plus OpenGL platform information

The first test does not involve any native method calls and shall always succeed, where the latter initializes the native libraries and OpenGL, which information is being dumped as well.

Both results are dumped to the file test.log , which you should send to us in case of a bugreport.

JOGL Demos
Let’s assume we are in the test directory ‘test’, from which we operate from this point.


 * Get jogl-demos.zip. Extract the archive, i.e. unzip jogl-demos.zip


 * Get jogl-2.0-pre-20090702-linux-amd64.zip. In case we have build a reference implementation (RI) the substring ‘pre-yyyymmdd-’ will be dropped. Replace the version 2.0 with the latest available and the OS/arch linux-amd64 with your test platform. Extract the archive, ie unzip jogl-2.0-pre-20090702-linux-amd64.zip . Create a symbolic link or rename the archive directory from jogl-2.0-pre-20090702-linux-amd64 to jogl, ie ln -s jogl-2.0-pre-20090702-linux-amd64 jogl.
 * If you like to test the binding to NV’s Cg, download and install

We assume java is in your binary search path.

On X11/Unix and MaxOSX you can test the build as follows:

sh java-run-newt.sh demos.es2.RedSquare -GL2 -GL2 -GL2 sh java-run.sh demos.gears.Gears

and with debug output

sh java-dbg-newt.sh demos.es2.RedSquare -GL2 -GL2 -GL2 sh java-dbg.sh demos.gears.Gears

On Windows you shall be able to run:

java-win32.bat demos.es2.RedSquare -GL2 -GL2 -GL2 java-win32.bat demos.gears.Gears

and with debug output

java-win32-dbg.bat demos.es2.RedSquare -GL2 -GL2 -GL2 java-win32-dbg.bat demos.gears.Gears

The windows scripts are pretty simple and flat.

The magic unix scripts offer more features and can be used either in the autobuild environment or in your development one. Looks up and invokes profile.jogl, finds gluegen, sets the environment variables (CLASSPATH, LD_LIBRARY_PATH & PATH). JOGL profiles are one of JOGL_ALL, JOGL_ES1_MIN, JOGL_ES1_MAX, JOGL_ES2_MIN, JOGL_ES2_MAX, JOGL_GL2ES12_MIN, JOGL_GL2ES12_MAX, JOGL_GL2_MIN, JOGL_GL2_MAX. Looks up the set of JAR files necessary to satisfy the chosen JOGL-PROFILE.
 * setenv-jogl.sh  []
 * jogl/etc/profile.jogl  []

This allows you to test a specific environment, ie ES2 without GL2 and AWT, using JOGL_ES2_MIN. For this case I would recommend the native ES2 implementation from imageon SDK_OGLES2_LINUX_PCEMULATION_2.02.22.0756.

Bugreports & Testing
For all bug reports, please add the following information to
 * your bug report
 * your email

Using our bug tracking system is strongly recommended. We also have a bug overview page available via this wiki.

JOGL, Platform and OpenGL Version
Please perform a runtime version check, which provides the following information:


 * Platform
 * OS & version
 * Architecture
 * OpenGL Version
 * Java version (java -version)
 * JOGL version
 * GIT revision
 * Autobuild version

Send us the resulting file test.log.

Detailed Bug Information

 * Your Test case
 * Source code, a junit test would be best.
 * Invocation command-line
 * Exceptions, stdout/stderr log file

Adding a comprehensive junit test would help us the most to reproduce the bug, to discuss it with you and to achieve a good response time. You may add it to your bug report directly or better, give us your git repository pull request.

If possible, please add the following system properties to enable DEBUG logging: -Dnewt.debug=all -Dnativewindow.debug=all -Djogl.debug=all

For example:

java -Djava.awt.headless=true -Dnewt.debug=all -Dnativewindow.debug=all \ -Djogl.debug=all demos.es2.RedSquare 2>&1 | tee RedSquare.report.log

To test applets use the jcontrol panel or edit ~/.java/deployment.properties directly and


 * Add JRE Arguments: -Djava.awt.headless=true -Dnewt.debug=all -Dnativewindow.debug=all -Djogl.debug=all
 * Enable logging/trace
 * Show the console window, or just use th latest log-file in ~/.java/deployment/log/

Get the Source Code
Create a local copy/branch of a git repository either anonymous:


 * git clone git://github.com/sgothel/gluegen.git gluegen
 * git clone git://github.com/sgothel/jogl.git jogl
 * git clone git://github.com/sgothel/jogl-demos.git jogl-demos

or via SSH and your user credential, so you can easily push back your changes to the github server:


 * git clone git@github.com:username/gluegen.git gluegen
 * git clone git@github.com:username/jogl.git jogl
 * git clone git@github.com:username/jogl-demos.git jogl-demos

X11: OpenGL library is not picked up correctly, no OpenGL available
In case you are running a DRI machine, eg ATI's proprietary driver or an open source one, you may need to ensure that the environment variable LIBGL_DRIVERS_PATH is set properly.

I ran into this while testing the 32bit builds on a 64bit machine as a different user. Since LIBGL_DRIVERS_PATH is only setup for the desktop user on Ubuntu, some /etc/X11/Xsession.d/ script, I couldn't get a GL context to work.

So I had to set mine to the value: export LIBGL_DRIVERS_PATH=/usr/lib/fglrx/dri:/usr/lib32/fglrx/dri

See also: Ubuntu fglrx bug entry

How to develop Cross-Device Applications
First you have to pick your lowest common denominator of an OpenGL profile, ie OpenGL ES1 or ES2. For either we offer an intersecting desktop GL profile, GL2ES1 or GL2ES2. Use the latter while creating your GLCapabilities. Build and run your application with the minimum GL profile JARS, e.g. on the desktop use:

~/jogl-demos>. ./setenv-jogl.sh JOGL_GL2ES12_MIN ../jogl/build

Here you are on a Unix platform (not Window) and your common build subdirectory is 'build'. jogl-demos/setenv-jogl.sh is provided within jogl-demos, which itself utilizes jogl/etc/profile.jogl.

This uses the GlueGen/JOGL JARS:
 * gluegen-rt.jar
 * nativewindow.core.jar
 * jogl.core.jar
 * jogl.util.jar
 * jogl.gl2es12.x11.jar
 * jogl.util.fixedfuncemu.jar
 * newt.core.jar
 * newt.ogl.jar

On a mobile device using CVM, you would use:
 * gluegen-rt-cdc.jar
 * nativewindow.core.cdc.jar
 * jogl.core.cdc.jar
 * jogl.util.cdc.jar
 * jogl.egl.cdc.jar
 * jogl.gles1.cdc.jar or jogl.gles2.cdc.jar
 * jogl.util.fixedfuncemu.cdc.jar
 * newt.core.cdc.jar
 * newt.ogl.cdc.jar

Please check JOGL Deployment also.

Now, the same Java application shall run on all devices, desktop and mobile. See demos.es1.RedSquare of the jogl-demos repository.

On the desktop you may run the ES1 demo:

~/jogl-demos> sh java-run-newt.sh demos.es1.RedSquare -GL2ES1

and the output is: null RedSquare.run 0 User screen size 0x0 Detected screen size 1920x1200 GLProfile[GL2ES1/GL2ES12] Entering initialization GLProfile[GL2ES1/GL2ES12] GL Profile: GLProfile[GL2ES1/GL2ES12] GLProfile[GL2ES1/GL2ES12] GL:com.sun.opengl.impl.gl2es12.GL2ES12Impl@b815859 GLProfile[GL2ES1/GL2ES12] GL_VERSION=3.0.0 NVIDIA 185.18.14 GLProfile[GL2ES1/GL2ES12] GL_EXTENSIONS: ..

How to use JOGL in Applets (part 1)
A Java Applet using JOGL may utilize 2 methods
 * New JNLP Applet
 * Applet-Launcher

Standard JNLP Applets are supported starting with Java 6u14, however, if you run MacOSX or an older version of Java, you may need to use the Applet-Launcher.

Below we utilize both, the standard JNLP mechanism of 6u14 as the default, or falling back to our Applet-Launcher.

You will find the JNLP file applet-gears.jnlp further below, which is being used in case of a JNLP launch, otherwise it is ignored and the archive tags are being used, hence the applet-launcher will be started.

The below demo is online here.

Note: It is important for the startup time to have the same JVM arguments in the applet tags, as well as within the JNLP applet description, here see property sun.java2d.noddraw. Only if JVM arguments of the JNLP applet description are satisfied by the applet tag’s JVM, the plugin will not need to start a new JVM. OF course, the applet tag’s JVM spec may exceed the JNLP applet’s one.

Note: A bug on MacOSX is known, launching 2 JOGL applets in 2 tabs.

<applet code="org.jdesktop.applet.util.JNLPAppletLauncher" width=600 height=400 archive="http://download.java.net/media/applet-launcher/applet-launcher.jar,              http://download.java.net/media/jogl/jsr-231-2.x-webstart/nativewindow.all.jar,               http://download.java.net/media/jogl/jsr-231-2.x-webstart/jogl.all.jar,               http://download.java.net/media/gluegen/webstart-2.x/gluegen-rt.jar,               http://download.java.net/media/jogl/jsr-231-2.x-demos-webstart/jogl-demos.jar">         

Where the referenced JNLP file applet-gears.jnlp looks as follow:

 <jnlp href="applet-gears.jnlp"> JOGL JNLP Applet Gears Demo Sun Microsystems, Inc.    <homepage href="http://jogl-demos.dev.java.net/"/> Gears Demo Brian Paul's Gears demo ported to Java and JOGL. <offline-allowed/>

<j2se href="http://java.sun.com/products/autodl/j2se" version="1.4+"/> <property name="sun.java2d.noddraw" value="true"/> <jar href="http://download.java.net/media/jogl/jsr-231-2.x-demos-webstart/jogl-demos.jar" main="true"/> <jar href="http://download.java.net/media/jogl/jsr-231-2.x-demos-webstart/jogl-demos-util.jar"/> <extension name="jogl-all-awt" href="http://download.java.net/media/jogl/jsr-231-2.x-webstart/jogl-all-awt.jnlp" />

<applet-desc name="Gears-Applet" main-class="demos.applets.GearsApplet" width="640" height="480"> </applet-desc>

What is Newt's Threading Model for native window events ?
As of today, Newt's default threading model to handle native events is the event dispatch thread (EDT) model.

Newt's EDT impl. creates one EDT per NEWT Display, as the Display is a unique abstraction of a graphics device connection serving all of it's Screens and Windows.

EDT is being used to
 * dispatch native Screen and Window events
 * lifecycle Screen and Window functionality
 * create / destroy
 * reparenting
 * native repaint calls (if no AnimatorControl is attached and animating)

EDT is not
 * blocking your rendering with event dispatching,
 * needed for pipelining your rendering commands,
 * hence not hindering your high performance rendering in it's own thread, eg an Animator

Using EDT is not mandatory, and you can turn it off in the NewtFactory, and deal with the event dispatch manually.

It's introduction was necessary to allow a peace of mind, high performance and reactive solution of the dispatch event problem. Some OS, especially MS-Windows, require one to create the native Window and dispatch it's events from the same native thread. As it was easy to handle these requirements from a simple test application, as it is difficult to solve this from a framework operating with multiple temporary threads, a web browser for example.

How to use Newt with multiple Windows & Threads
Newt is capable of handling multiple threads and windows.

For best performance, you may create one thread per window, if possible.

Below you see the invocation of the ES2 RedSquare jogl-demos utilizing multiple threads.


 * Single thread (Unix, Win32) java -Djava.awt.headless=true demos.es2.RedSquare -GL2
 * Single thread (MacOSX) java -XstartOnFirstThread -Djava.awt.headless=true demos.es2.RedSquare -GL2
 * Multiple threads & windows (Unix, Win32) java -Djava.awt.headless=true demos.es2.RedSquare -GL2 -GL2 -GL2 -GL2
 * Multiple threads & windows (MacOSX) java -XstartOnFirstThread -Djava.awt.headless=true com.sun.javafx.newt.util.MainThread demos.es2.RedSquare -GL2 -GL2 -GL2 -GL2

The serialization of the main Java class through com.sun.javafx.newt.util.MainThread may be used for all platforms, since it only takes effect on MacOSX. This allows you an almost platform independent invocation of your multithreaded Java applications.

On MacOSX, com.sun.javafx.newt.util.MainThread will occupy the main thread and serializes all native window related tasks through it. This mechanism is thread safe utilizes reentrant locking.

Why using AWT for high performance is not a good idea ?
AWT (on many implementations) holds the lock to the underlying native resources, e.g. X11 display, screen and window surface, hence we have to obey these locks for any GL action bound to such.

This is still pretty standard matter as long these locks only have to be applied to the actual resource in use.

On AWT, it turns out that we have to use the global JAWT toolkit lock for any native operation, ie OpenGL. This might not be a problem for a single threaded GL application, but if you start a multithreaded beast, you will recognize that it will stumble around.

You can verify this behavior with the ES1 RedSquare demo:

java demos.es1.RedSquare -awt -swapi 0 -GL2 5s: 3379f, 675 fps, 1 ms/f; total: 5s, 675 fps, 1 ms/f Even here you may experience some stuttering ..
 * AWT - No VSync - One Thread

If you force disabling the toolkit lock: java -Dnativewindow.nolocking=true demos.es1.RedSquare -awt -swapi 0 -GL2 The demo may freeze forever .. due to native locking.

java -Djava.awt.headless=true demos.es1.RedSquare -swapi 0 -GL2 5s: 5958f, 1191 fps, 0 ms/f; total: 5s, 1191 fps, 0 ms/f Runs much smoother .. without the stuttering locking experience ..
 * NEWT - No VSync - One Thread

This becomes much clearer with more threads:

java demos.es1.RedSquare -awt -swapi 0 -GL2 -GL2 -GL2 5s: 772f, 151 fps, 6 ms/f; total: 5s, 151 fps, 6 ms/f
 * AWT - No VSync - Three Threads

java -Djava.awt.headless=true demos.es1.RedSquare -swapi 0 -GL2 -GL2 -GL2 5s: 1669f, 333 fps, 2 ms/f; total: 5s, 333 fps, 2 ms/f
 * NEWT - No VSync - Three Threads

Why using Swing for high performance is not a good idea ?
First, all this inherents all arguments from 'Why using AWT for high performance is not a good idea ?

Second, it involves compositioning using different methods, some may not be available on some platforms.

From fast to slow:

1.) External Java2D's GLContext and FBO object.
 * GL stuff HW accelerated.
 * Available on some platforms: Linux/Windows Sun's Java2D impl.
 * Setup with System property 'sun.java2d.opengl' to 'true'.
 * Renders directly into Java2D's FBO object, if available.

2.) Own PBuffer GLContext, which has to be composed.
 * GL stuff HW accelerated.
 * Available on most platforms: No dependency to Java2D implementation.
 * Renders into an own offscreen drawable, and copies it over to AWT's BufferedImage.

3.) Own Pixmap GLContext, which has to be composed.
 * GL stuff unlikely hw accelerated.
 * Available on most platforms: No dependency to Java2D impl.
 * Renders into an own offscreen drawable, and copies it over to AWT's BufferedImage.

As you see, no straight forward HW rendering is involved, assuming that even the windowing manager is using offscreen surfaces - you would have 2 compositions here already.

At least (1) would be 'acceptable' here, if available, but if only (2) is available - the performance would not match the state of the art!

Sure, it might be enough for some UIs or static pictures .. or so, otherwise, I would prefer the 'overlay' method, ie using a GLCanvas within a Swing component, while no menu is being shown.

However you do it .. the generic AWT 'restrictions' apply here as well.

Using OpenGL without a visible component
Sometimes you might want to do OpenGL work without a visible GLDrawable or before making your drawable visible.
 * http://jogamp.762907.n3.nabble.com/Binding-textures-without-showing-the-GLCanvas-tp960145p960234.html