Simple GUI management solution.
Alternatives To Opengui
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
19 years ago2July 30, 2012JavaScript
GUI Tool for Behat's users and Product Owners
6 years ago20otherJava
Automatically exported from
4 years ago4Java
Simple GUI management solution.
5 years agomitJava
Software resources for two Safari presentations: (1) Object Oriented GUI design in Java; (2) Design Patterns in Java GUI Development
2 years agoapache-2.0Java
GUI Java implementation of the popular game sudoku.
Tdt4140 Improvify App3
5 years agoJava
Workout app (nicknamed Improvify) for a NTNU course TDT4140.
Image Sort3
6 years agoJava
ImageSort is a program that sorts images according to their RGB values using different basic sorting algorithms and allows the user to scroll through sorted images through a graphical user interface. The GUI also allows user change the variables used to sort the images, and then resort the images.
Gui Check3
9 years agogpl-3.0Java
UI testing library for Java
Group 13 City Move2
4 years agoJava
12 years agoJava
Alternatives To Opengui
Select To Compare

Alternative Project Comparisons

OpenGUI version Build Status

Simple GUI management solution.

Installation (Maven)

Just use my public repository and set the scope to compile.

There's no any jar file to install on the server. You just compile it with your plugin.


Installation (Non-maven)

Download and copy the source-code into your src folder.

Keep in mind that you need following dependencies to get it to work.


This API should be compatible with all Bukkit or Spigot versions since 1.0. I would recommend running it on a version higher than 1.7.2 though.

It was tested on Minecraft version 1.12.2.


It is fairly simple. OpenGUI has two possible usages. Object-based or standard.

Standard, and the simplest usage example:

public class YourPluginClass extends JavaPlugin {
    public static void showGUI(Player player) {
        // Register the listeners.
        // Create the GUI inventory using our special wrapper.
        GUI gui = new GUI("&cSimple Title", Rows.FIVE);
        // Create GUIExtender class and provide the GUI information.
        SimpleGUI simpleGUI = new SimpleGUI(gui);
        // Some additional GUI settings like entering/dragging items.
        // Set specific enterable/draggable items
        simpleGUI.getGuiSettings().addEnterableItem(Material.GOLDEN_APPLE, 1);
        // Set event to occur when user tries to enter non-enterable item
                inventoryClickEvent -> 
                            "You can not enter that item!"));
        // Set event to occur when user enters an item successfully
                inventoryClickEvent ->
                            "Entered an item!"));
        // #1 Set an item to a specified slot and assign an ItemBuilder
        simpleGUI.setItem(0, new ItemBuilder(Material.DIRT, 1).setName("&aTest!"));
        // #2 Add an item with assigned ItemBuilder
        simpleGUI.addItem(new ItemBuilder(Material.DIAMOND));
        // #3 Add an item with assigned ItemBuilder and ElementResponse event. (onClick)
        simpleGUI.addItem(new ItemBuilder(Material.GOLD_AXE), event ->
                System.out.println("On click event!"));
        // #4 Set items all together using ItemPack class.
                new ItemPack(1, new ItemBuilder(Material.WOOD)),
                new ItemPack(2, new ItemBuilder(Material.STONE)),
                new ItemPack(3, new ItemBuilder(Material.DIAMOND_ORE)),
                new ItemPack(4, new ItemBuilder(Material.EMERALD)));
        // Add an element response to slot 0.
        simpleGUI.addElementResponse(0, event ->
                System.out.println("On click event at slot 0!"));
        // Add an element response to slot 1 and assign "pullable" value.
        // It means that you can pull out that item from the GUI and take it with you.
        simpleGUI.addElementResponse(1, true, event ->
                System.out.println("On click event at slot 1!"));
        // Add WindowResponse event.
        simpleGUI.addWindowResponse(new WindowResponse() {
                public void onOpen(InventoryOpenEvent event) {
                public void onClose(InventoryCloseEvent event) {
        // Remove an item from slot 0.
        // Open inventory.
        // WARNING: This is important that you use our method.
        // You can use player.openInventory(inventory)
        // only when not using overrided items. (More on that in object-based usage)

Object-based usage. (A little more complicated, this is for advanced users who are familiar with basics of object-oriented programming!)

Custom GUI creation

public class TestGUI extends GUIExtender {

    // Simple custom GUI, here you can add your items and prepare it for show.
    // Functionality of this object will be extended in the future.
    public TestGUI() {
        super(new GUI("&cSuper Title", Rows.THREE));

        // Add possible to enter material

        // Here we can set our GUIExtenderItem class extension as a normal item.
        setItem(0, new TestItem());
        // Every functionality from standard usage is of course here.
        // You can add/set items, add element response or other listeners.
        // You can even override all the methods, but I don't see any useful outcomes of this.
    public void onOpen(InventoryOpenEvent e) {
    public void onClose(InventoryCloseEvent e) {

Custom Item (Element) creation

public class TestItem extends GUIExtenderItem {

    public TestItem() {
        // We can set here the default ItemBuilder,
        // but there's no need for it as we're overriding the getItemBuilder method


    // You can change resulting item just before the player opens the inventory.
    // The assignment of the item is made in GUIExtender.openInventory(player) method.
    public ItemBuilder getItemBuilder(Player player) {
        if (player.getName().equals("pl.socketbyte.opengui.Test"))
            return new ItemBuilder(Material.DIAMOND)
                    .setLore("Very nice", "Diamond");
        return new ItemBuilder(Material.GRASS)
                .setLore("Gross", "Grass");

    // ElementResponse implementation.
    public void onClick(InventoryClickEvent event) {

Now you can show your amazing objects to the player using

TestGUI testGUI = new TestGUI();


OpenGUI in 1.2 offers Serializable classes that allow to easily configure your GUI from config.yml file.

If you want to use it from config, you need to use different objects.

SerializableSimpleGUI instead of SimpleGUI

SerializableGUI instead of GUI

SerializableItemBuilder instead of ItemBuilder

Congratulations! You can save now your SerializableSimpleGUI using

configuration.set("gui", yourSimpleGUI)

Of course you can read GUI from config like this:

SerializableSimpleGUI gui = (SerializableSimpleGUI) configuration.get("gui")


  canDrag: true
  canEnterItems: true
    title: '&2&lDrop'
      # action ID on slot 0 etc.
      0: on_click_action_0
      1: on_click_action_1
      2: on_click_action_2
      3: on_click_action_3
      4: on_click_action_4
      5: on_click_action_5
    - slot: 0
        material: DIAMOND
        amount: 1
        durability: 0
        name: null
        lore: null
    - slot: 1
        material: GOLDEN_APPLE
        amount: 1
        durability: 1
        name: null
        lore: null
    - slot: 2
        material: COAL
        amount: 48
        durability: 0
        name: null
        lore: null
    - slot: 3
        material: CHORUS_FLOWER
        amount: 1
        durability: 0
        name: null
        - Hi!
        - Boi!
    - slot: 4
        material: JACK_O_LANTERN
        amount: 1
        durability: 0
        name: '&6Hello!'
        lore: null
    - slot: 5
        material: LAPIS_BLOCK
        amount: 1
        durability: 0
        name: null
        lore: null

Like you can see, OpenGUI offers additional action id parameters. You can find them in SerializableSimpleGUI and use them like this:

simpleGUI.hasAction(int slot)
simpleGUI.getActionFor(int slot) // returns String

You can use them to append different ElementResponse actions for each item. It allows to create dynamic GUIs right from your configuration file.

Enchantments are currently not supported. To be added in 1.2b


Project supports JUnit 4. Test code is generated automatically using EvoSuite 1.0.5.

At the end...

This project is not well written, or amazing in any case. It's usage is heavily inspired by AmpMenus but it's a bit more rich in functionalities and still supported.

If you have any questions or issues feel free to use github issues forum. If you want to contribute on the project you of course can.

License and Terms of Use

No license basically. You can do everything with the code, but you can't distribute or sell it.

Popular Gui Projects
Popular Junit Projects
Popular User Interface Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.