ImGui Java

JNI based binding for Dear ImGui

Features

JNI based
Native communication layer made with generated JNI code. No dependencies, no problems.
Small and Efficient
Binding has a small memory footprint and uses direct native calls to work.
Fully Featured
All public API was carefully implemented with Java usage in mind.
Multi-Viewports / Docking Branch
Binding has a full support of Multi-Viewports and Docking.
FreeType Font Renderer
FreeType font renderer provides a much better fonts quality. See how to use.
Extensions
Binding includes several useful extensions for Dear ImGui. See full list.

To understand how to use ImGui Java - read official documentation and wiki. Binding adopts C++ API for Java, but almost everything can be used in the same manner.

ImGui Java has a ready to use implementation for GLFW and OpenGL API using LWJGL3 library. See imgui-lwjgl3 module.
Implementation is optional, yet optional to use. Advantage of Dear ImGui is total portability, so feel free to copy-paste classes or write your own implementations.

Additionally, there is an imgui-app module, which provides a high abstraction layer.
It hides all low-level code under one class to extend. With it, you can build your GUI application instantly.

Support

You can support the project to motivate its further development.

How to Try

Make sure you have installed JDK 8 or higher.

Demo

You can try binding by yourself in three simple steps:

git clone [email protected]:SpaiR/imgui-java.git
cd imgui-java
./gradlew :example:run

See example module to try other widgets in action.

How to Use

ImGui in LWJGL YouTube video by GamesWithGabe.
You can use this video as a basic step-by-step tutorial. It shows how to integrate binding with the usage of jar files.
Gradle and Maven dependencies could be used for this purpose as well.

Take a note, that integration itself is a very flexible process. It could be done in one way or another. If you just need a framework for your GUI - use Application module. Otherwise, if you need more control, the best way is not just to repeat steps, but to understand what each step does.

Application

If you don't care about OpenGL and other low-level stuff, then you can use application layer from imgui-app module. It is a one jar solution which includes: GLFW, OpenGL and Dear ImGui itself. So you only need one dependency line or one jar in classpath to make everything to work. You don't need to add separate dependencies to LWJGL or native libraries, since they are already included.

Application module is the best choice if everything you care is the GUI itself.

At the same time, Application gives options to override any life-cycle method it has. That means that if you are seeking for a bit more low-level control - you can gain it as well.

Example

A very simple application may look like this:

import imgui.ImGui;
import imgui.app.Application;

public class Main extends Application {
    @Override
    protected void configure(Configuration config) {
        config.setTitle("Dear ImGui is Awesome!");
    }

    @Override
    public void process() {
        ImGui.text("Hello, World!");
    }

    public static void main(String[] args) {
        launch(new Main());
    }
}

Read imgui.app.Application javadoc to understand how it works under the hood.

Dependencies

Gradle

repositories {
    mavenCentral()
}

dependencies {
    implementation "io.github.spair:imgui-java-app:${version}"
}

Maven

<dependencies>
    <dependency>
        <groupId>io.github.spair</groupId>
        <artifactId>imgui-java-app</artifactId>
        <version>${version}</version>
    </dependency>
</dependencies>

Raw Jar

Go to the release page;
Download java-libraries.zip;
Get imgui-app-${version}-all.jar;
Add the jar to your classpath.

Jar with all classifier already contains binding and lwjgl3 modules.
If you're using jar without the all classifier, add appropriate jars as well.

Both jars, with or without all classifier, have all required native libraries already.

Java Module System

If using Java 9 modules, you will need to require the imgui.app module.

Binding

Using binding without imgui-app module requires to "attach" it to the application manually. You can refer to imgui-app module to see how things are done there.

Dependencies

For simplicity, example of dependencies for Gradle / Maven only shows how to add natives for Windows. Feel free to add other platforms.

Native Binaries	System
imgui-java-natives-windows	Windows
imgui-java-natives-linux	Linux
imgui-java-natives-macos	macOS

Take a note, that you also need to add dependencies to LWJGL library. Examples below shows how to do it as well.

Gradle

repositories {
    mavenCentral()
}

ext {
    lwjglVersion = '3.3.1'
    imguiVersion = "${version}"
}

dependencies {
    implementation platform("org.lwjgl:lwjgl-bom:$lwjglVersion")

    ['', '-opengl', '-glfw'].each {
        implementation "org.lwjgl:lwjgl$it:$lwjglVersion"
        implementation "org.lwjgl:lwjgl$it::natives-windows"
    }
    
    implementation "io.github.spair:imgui-java-binding:$imguiVersion"
    implementation "io.github.spair:imgui-java-lwjgl3:$imguiVersion"
    
    implementation "io.github.spair:imgui-java-natives-windows:$imguiVersion"
}

Maven

<properties>
    <lwjgl.version>3.3.1</lwjgl.version>
    <imgui.java.version>${version}</imgui.java.version>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.lwjgl</groupId>
            <artifactId>lwjgl-bom</artifactId>
            <version>${lwjgl.version}</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.lwjgl</groupId>
        <artifactId>lwjgl</artifactId>
    </dependency>
    <dependency>
        <groupId>org.lwjgl</groupId>
        <artifactId>lwjgl-glfw</artifactId>
    </dependency>
    <dependency>
        <groupId>org.lwjgl</groupId>
        <artifactId>lwjgl-opengl</artifactId>
    </dependency>
    <dependency>
        <groupId>org.lwjgl</groupId>
        <artifactId>lwjgl</artifactId>
        <classifier>natives-windows</classifier>
    </dependency>
    <dependency>
        <groupId>org.lwjgl</groupId>
        <artifactId>lwjgl-glfw</artifactId>
        <classifier>natives-windows</classifier>
    </dependency>
    <dependency>
        <groupId>org.lwjgl</groupId>
        <artifactId>lwjgl-opengl</artifactId>
        <classifier>natives-windows</classifier>
    </dependency>
    
    <dependency>
        <groupId>io.github.spair</groupId>
        <artifactId>imgui-java-binding</artifactId>
        <version>${imgui.java.version}</version>
    </dependency>
    <dependency>
        <groupId>io.github.spair</groupId>
        <artifactId>imgui-java-lwjgl3</artifactId>
        <version>${imgui.java.version}</version>
    </dependency>
    <dependency>
        <groupId>io.github.spair</groupId>
        <artifactId>imgui-java-natives-windows</artifactId>
        <version>${imgui.java.version}</version>
    </dependency>
</dependencies>

Raw Jars

Go to the release page;
Download java-libraries.zip and native-libraries.zip (native-libraries-with-freetype.zip for FreeType font rendering);
Get imgui-binding-${version}.jar and imgui-lwjgl3-${version}.jar from java-libraries, and binary libraries for required OS from native-libraries archive;
Add jars to your classpath;
Provide a VM option with location of files from the native-libraries (or native-libraries-with-freetype) archive.

VM option example:

-Dimgui.library.path=${path}
-Djava.library.path=${path}

Both imgui.library.path and java.library.path are equal with the difference, that java.library.path is standard JVM option to provide native libraries.

Java Module System

If using Java 9 modules, ImGui Java has Automatic Module Names:

Package	Module
imgui-java-app	imgui.app
imgui-java-binding	imgui.binding
imgui-java-lwjgl3	imgui.lwjgl3
imgui-java-natives-windows	imgui.natives.windows
imgui-java-natives-linux	imgui.natives.linux
imgui-java-natives-macos	imgui.natives.macos

Extensions

All extensions are already included in the binding and can be used as it is. See examples in the example module for more information about how to use them.

ImNodes | Example
A small, dependency-free node editor for Dear ImGui. (A good choice for simple start.)
imgui-node-editor | Example
Node Editor using ImGui. (A bit more complex than ImNodes, but has more features.)
ImGuizmo | Example
Immediate mode 3D gizmo for scene editing and other controls based on Dear ImGui.
implot | Example
Advanced 2D Plotting for Dear ImGui.
ImGuiColorTextEdit | Example
Syntax highlighting text editor for ImGui.
ImGuiFileDialog | Example
A file selection dialog built for ImGui.
ImGui Club MemoryEditor | Example
Memory editor and viewer for ImGui.

Freetype

By default, Dear ImGui uses stb-truetype to render fonts. Yet there is an option to use FreeType font renderer. Go to the imgui_freetype to read about the difference. Binding has this option too. Freetype especially useful when you use custom font with small (~<16px) size. If you use the default font or a large font, stb will be fine for you.

There are two types of precompiled binaries: 1. with stb (the default one) 2. with freetype. You can decide by yourself, which kind of libraries for any system you want to use.

Take a note, that for Linux and macOS users using of freetype will add a dependency to the libfreetype itself. This is not the case for Windows users, since dll binaries are compiled fully statically and already include freetype in themselves.

For fully portable application use default binaries.
You can still use freetype binaries for Windows builds without worry though.

For better fonts use freetype binaries.
Don't forget to make clear for your Linux/Mac users, that they will need to install freetype on their systems as well.

Dependencies

Use the same native libraries as you would, but with -ft suffix in the end.

Modified Gradle Example

```
repositories {
    mavenCentral()
}

ext {
    lwjglVersion = '3.3.1'
    imguiVersion = "${version}"
}

dependencies {
    implementation platform("org.lwjgl:lwjgl-bom:$lwjglVersion")

    ['', '-opengl', '-glfw'].each {
        implementation "org.lwjgl:lwjgl$it:$lwjglVersion"
        implementation "org.lwjgl:lwjgl$it::natives-windows"
    }
    
    implementation "io.github.spair:imgui-java-binding:$imguiVersion"
    implementation "io.github.spair:imgui-java-lwjgl3:$imguiVersion"
    
    // This is the main difference
    implementation "io.github.spair:imgui-java-natives-windows-ft:$imguiVersion"
}
```

Native Binaries With FreeType	System
imgui-java-natives-windows-ft	Windows
imgui-java-natives-linux-ft	Linux
imgui-java-natives-macos-ft	macOS

If you're using raw dll/so files, go to the release page and use libraries from the native-libraries-with-freetype.zip archive.

Binding Notice

Binding was made with Java usage in mind. Some places of the original library were adapted for that.
For example, in places where in C++ you need to pass a reference value, in Java you pass primitive wrappers: ImInt, ImFloat etc.

One important thing is how natives structs work. All of them have a public field with a pointer to the natively allocated memory.
By changing the pointer it's possible to use the same Java instance to work with different native structs.
Most of the time you can ignore this fact and just work with objects in a common way.

Read javadoc and source comments to get more info about how to do specific stuff.

How to Build Native Libraries

Ensure you've downloaded git submodules. That could be achieved:

When cloning the repository: git clone --recurse-submodules https://github.com/SpaiR/imgui-java.git
When the repository cloned: git submodule init + git submodule update

Windows

Make sure you have installed and available in PATH:
- JDK 8 or higher
- Ant
- Mingw-w64 (recommended way: use MSYS2 and install mingw-w64-x86_64-toolchain group)
Build with: ./gradlew imgui-binding:generateLibs -Denvs=windows -Dlocal
Run with: ./gradlew example:run -PlibPath="../imgui-binding/build/libsNative/windows64"

Linux

Install dependencies: openjdk8, mingw-w64-gcc, ant. (Package names could vary from system to system.)
Build with: ./gradlew imgui-binding:generateLibs -Denvs=linux -Dlocal
Run with: ./gradlew example:run -PlibPath=../imgui-binding/build/libsNative/linux64

macOS

Check dependencies from "Linux" section and make sure you have them installed.
Build with: ./gradlew imgui-binding:generateLibs -Denvs=macos -Dlocal
Run with: ./gradlew example:run -PlibPath=../imgui-binding/build/libsNative/macosx64

In envs parameter next values could be used windows, linux or macos.
-Dlocal is optional and means that natives will be built under the ./imgui-binding/build/ folder. Otherwise /tmp/imgui folder will be used. On Windows always use local build.

License

See the LICENSE file for license rights and limitations (Apache-2.0).

Name		Name	Last commit message	Last commit date
Latest commit History 477 Commits
.github		.github
bin		bin
buildSrc		buildSrc
config/checkstyle		config/checkstyle
docs		docs
example		example
gradle/wrapper		gradle/wrapper
imgui-app		imgui-app
imgui-binding-natives		imgui-binding-natives
imgui-binding		imgui-binding
imgui-lwjgl3		imgui-lwjgl3
include		include
vendor		vendor
.editorconfig		.editorconfig
.gitignore		.gitignore
.gitmodules		.gitmodules
LICENSE		LICENSE
README.md		README.md
build.gradle		build.gradle
gradlew		gradlew
gradlew.bat		gradlew.bat
publish.gradle		publish.gradle
settings.gradle		settings.gradle

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

ImGui Java

Features

Support

How to Try

Demo

How to Use

Application

Example

Dependencies

Java Module System

Binding

Dependencies

Java Module System

Extensions

Freetype

Dependencies

Binding Notice

How to Build Native Libraries

Windows

Linux

macOS

License

About

Releases

Packages

Languages

License

Trolobezka/imgui-java

Folders and files

Latest commit

History

Repository files navigation

ImGui Java

Features

Support

How to Try

Demo

How to Use

Application

Example

Dependencies

Java Module System

Binding

Dependencies

Java Module System

Extensions

Freetype

Dependencies

Binding Notice

How to Build Native Libraries

Windows

Linux

macOS

License

About

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages