Compatibility
Minecraft: Java Edition
Platforms
Tags
Creators
Details
UIcore — Build Interactive Menus Inside the Minecraft World
A world-space UI framework for Minecraft servers.
YAML Configuration · Public Java API · No Required Resource Pack · Paper & Folia Support
🚀 Rethink Minecraft Server Interfaces
Why limit your server's interface to traditional chest inventories when menus can become part of the game world itself?
UIcore is a world-space user interface framework designed for Minecraft servers. Instead of opening a conventional inventory screen, UIcore places interactive menu elements around the player's camera, creating an interface that feels integrated into the Minecraft environment.
Text labels, buttons, item previews, player avatars, toggles, and input fields can become part of a unified interactive scene.
Players interact with these elements using a visual cursor, allowing them to navigate menus, hover over buttons, trigger actions, switch between screens, and enter text through Minecraft's chat system.
UIcore gives server owners and plugin developers greater flexibility when designing interfaces, making it possible to create experiences that go beyond conventional inventory-based menus.
✨ Key Highlights
- World-space interfaces: Display menu elements directly in the Minecraft world.
- Interactive controls: Buttons, tooltips, hover feedback, click animations, and more.
- YAML-based configuration: Create menus without developing a separate Java plugin.
- Public Java API: Extend the framework with custom logic and components.
- Dynamic elements: Change text, materials, and visibility based on individual player states.
- Schematic previews: Display player-specific structures without modifying real blocks.
- Optional integrations: Connect UIcore with other server plugins when needed.
- No mandatory resource pack: The bundled examples use vanilla Minecraft items.
Whether you are building a simple navigation menu or a more complex interface system, UIcore provides the tools needed to create interactive experiences directly inside Minecraft.
🧩 Features
🖱️ 1. Interactive Screens and Navigation
Create complete menu screens using interactive elements positioned around the player's camera.
UIcore supports:
- Text labels: Display information as part of your interface.
- Interactive buttons: Let players trigger actions through menu elements.
- Visual cursor navigation: Move between interactive elements using an in-game cursor.
- Hover feedback: React when the player points at an element.
- Cursor styles: Customize cursor behavior and appearance through supported styles.
- Tooltips: Provide additional information about menu elements.
- Click animations: Give players visual feedback when interacting.
- Click cooldowns: Control how frequently actions can be triggered.
- Screen transitions: Navigate between different menus and screens.
These features allow developers to build interactive layouts that feel more like a dedicated game interface than a traditional inventory menu.
🔄 2. Dynamic Content, Input, and Player States
UIcore is not limited to static menu layouts.
Its state and condition systems allow interface elements to react to player actions and server-side logic.
Available functionality includes:
- Chat-based text input: Receive user input through Minecraft chat.
- Toggle controls: Build elements with multiple selectable states.
- Permission checks: Restrict actions based on player permissions.
- Click requirements: Define conditions that must be satisfied before an action executes.
- Per-player element states: Maintain individual interface states for different players.
- Dynamic text: Change displayed labels based on element state.
- Dynamic materials: Update the item or material shown by an element.
- Conditional visibility: Show or hide elements depending on their state.
For example, a settings screen can display different toggle states for individual players, while unavailable options can be hidden or presented differently according to configured conditions.
This makes UIcore suitable for interfaces that need to reflect player-specific information and server behavior.
🎒 3. Item Displays, Player Avatars, and Galleries
Minecraft items can be used as visual components inside your custom interface.
UIcore provides functionality for:
- Displaying Minecraft items.
- Showing player avatars.
- Creating item galleries.
- Using reusable element templates.
- Building slots with selectable contents.
These capabilities can be used to design item selectors, visual catalogs, profile screens, collections, and other interfaces where visual content plays an important role.
Instead of relying entirely on inventory slots, developers can organize items as part of a custom world-space layout.
🏗️ 4. Player-Specific Schematic Previews
Preview structures directly inside a menu without changing the actual Minecraft world.
UIcore supports up to four player-specific schematic previews using the Sponge .schem format, versions v2 and v3.
Key characteristics:
- Display up to four schematic previews within a menu.
- Send preview data only to the relevant player.
- Keep the actual world blocks unchanged.
- Use previews as part of building selectors, catalogs, or other custom interfaces.
This allows players to inspect a structure visually without requiring it to be physically placed in the world.
Current limitation: Schematic previews display block states but do not reproduce container or other block-entity contents, entities, or biomes.
👁️ 5. Player Visibility, Privacy, and Damage Settings
Different interfaces may require different levels of isolation from the surrounding game world.
UIcore provides per-menu settings that control how the player and interface interact with other players.
You can configure:
- Whether nearby players can see a menu's display elements.
- Whether the player who opened the menu is hidden from other players.
- Whether other players are hidden from the menu user.
- Whether damage from other players is allowed or blocked while the menu is open.
These settings are useful when designing interfaces for server hubs, game-mode selection, and other situations where the player's interaction with the surrounding world needs to be controlled.
🛠️ Two Ways to Build: YAML and Java API
UIcore is designed for both server administrators and Java plugin developers.
You can configure menus using YAML or extend the framework through its public API.
📝 YAML Menu Configuration
Create and manage interfaces through YAML configuration files.
This approach allows server owners to define menus without having to write a separate Java plugin for every interface.
YAML is suitable for:
- Server navigation menus.
- Player profile screens.
- Settings interfaces.
- Game-mode selectors.
- Item galleries.
- Other configurable menu systems.
Menu files are stored in:
plugins/UIcore/menu/
After adding or modifying a menu, reload the configuration with:
/uicore reload
For configuration structure, supported elements, actions, and examples, refer to the Menu Authoring Guide.
☕ Public Java API
For more advanced development, UIcore exposes a public Java API.
Developers can extend the framework by registering:
- Custom actions: Define additional behavior when players interact with elements.
- Data providers: Supply information from external systems or your own plugins.
- Conditions: Add custom requirements and interaction logic.
- Custom components: Extend the available interface elements.
This makes UIcore useful not only as a configurable menu plugin but also as an interface foundation for other Minecraft server systems.
The API allows developers to connect UIcore interfaces to their own plugin functionality rather than building an entirely separate UI system.
🎮 What Can You Build with UIcore?
UIcore can serve as the interface layer for many different Minecraft server features.
🏠 Server Hub and Navigation
Build a central navigation interface that gives players access to different sections of your server.
Use buttons, labels, item displays, and screen transitions to organize navigation.
👤 Player Profiles
Create profile interfaces featuring player avatars, information, items, and interactive actions.
Dynamic states and data providers can be used to connect the interface to player-specific information.
⚙️ Settings Menus
Build configurable settings screens using toggles, conditions, and individual player states.
Elements can update their appearance or visibility depending on the selected state.
🛒 Shops and Item Catalogs
Use item displays and galleries to create visual catalogs of available items.
Connect menu actions to your own purchasing or transaction logic.
🌍 Game-Mode Selection
Design selection screens for different game modes or server destinations.
Combine visual elements, navigation buttons, and player-specific conditions.
🏰 Building and Structure Galleries
Let players preview schematic structures before choosing them.
Display supported Sponge schematic previews without modifying real world blocks.
🔌 Custom Plugin Interfaces
Use the Java API to create interfaces for your own plugins, including custom actions, data sources, conditions, and components.
Note: These are examples of systems that can be built using UIcore's features. Application-specific logic, such as payment processing, persistence, or game-mode management, must be implemented or provided by the relevant server plugins.
🔗 Integrations
UIcore supports integration with other Minecraft server plugins.
Built-in Optional Integrations
- Vault
- LuckPerms
Additional Optional Integrations
- PlaceholderAPI
- FancyNpcs
- SkinsRestorer
- CraftEngine
All listed integrations are optional.
UIcore can start without these plugins installed. However, features that depend on a particular integration require the corresponding plugin to be present.
This allows server owners to use the core framework without installing unrelated dependencies.
📋 Requirements and Compatibility
Before installing UIcore, make sure your server meets the following requirements.
| Component | Requirement |
|---|---|
| Minecraft | 1.21.1 or newer |
| Server software | Paper or a compatible server implementation |
| Folia | Supported with regional constraints |
| PacketEvents | 2.14.0 (required) |
| Java runtime | Version required by the selected Minecraft and server build |
| UIcore plugin/API bytecode | Java 17 |
| Vault / LuckPerms | Optional |
| PlaceholderAPI / FancyNpcs / SkinsRestorer / CraftEngine | Optional |
Folia Compatibility
UIcore declares support for Folia.
When running on Folia, all elements belonging to a menu scene must remain within the camera's region.
This restriction should be considered when designing and positioning world-space interfaces.
Java Compatibility
UIcore's plugin and public API are compiled using Java 17 bytecode.
However, this does not mean that every supported Minecraft server version can run on Java 17.
Always use the Java runtime required by your selected Minecraft version and server implementation.
For tested server builds and additional compatibility information, see the Compatibility Matrix.
🚀 Quick Start
Getting started with UIcore only requires a few steps.
Step 1 — Install the Plugins
Download UIcore and its required dependency, PacketEvents 2.14.0.
Place both plugin files in your server's plugins/ directory.
Step 2 — Start Your Server
Start or restart the Minecraft server.
UIcore will generate its configuration files and three bundled example menus.
Step 3 — Open the Demo Menu
Run the following command:
/uicore run demo_main
This opens the main demonstration menu.
To close the currently opened menu, use:
/uicore stop
Step 4 — Create Your Own Menu
Add or modify YAML menu files in:
plugins/UIcore/menu/
Use the existing examples and the menu authoring documentation as a reference.
Step 5 — Reload the Configuration
After making changes, execute:
/uicore reload
This loads your updated menu configuration.
Step 6 — Explore the Documentation
For a more detailed setup and configuration walkthrough, use the following resources:
🎥 Video Demonstrations
See UIcore interfaces in action.
Bundled Menu Walkthrough
Explore the demonstration menus included with UIcore.
▶️ Watch the bundled menu walkthrough
Custom Server Menu
See an example of a custom server interface created with the framework.
▶️ Watch the custom server menu demonstration
⚠️ Current Limitations and Important Notes
UIcore provides a flexible foundation for Minecraft world-space interfaces, but some features have technical limitations.
Schematic Preview Limitations
Schematic previews currently display block states.
They do not reproduce:
- Container contents.
- Other block-entity contents.
- Entities.
- Biome information.
These limitations should be considered when designing building preview systems.
Console Command Restrictions
Executing console commands from menus is disabled by default.
To enable specific console commands, an explicit allowlist must be configured.
This prevents menu configurations from automatically receiving unrestricted console command execution.
NoChatReports Compatibility
On certain client configurations, NoChatReports may interfere with signed chat behavior and text input used by UIcore menus.
Refer to the compatibility documentation for the observed issue and its documented workaround.
Folia Regional Restrictions
When using Folia, keep all elements of a menu scene within the camera's region.
Server Build Compatibility
Compatibility may vary depending on the selected Minecraft version, server implementation, and installed plugins.
Consult the published Compatibility Matrix before deploying UIcore to a production server.
💻 Open Source and Licensing
UIcore is an open-source project distributed under the GNU Affero General Public License v3.0 (AGPL-3.0).
The source code is available for inspection, modification, and further development under the terms of the license.
Source Code: github.com/kekaop/UIcore
License: AGPL-3.0
Developer: Orven
Credits and Original Project
UIcore is based on CustomScreenMenu by wuhaoxian123.
The project is published with permission from the original developer.
🌟 UIcore — Interfaces That Become Part of Your World
UIcore provides a different approach to Minecraft server interface design.
Instead of restricting players to conventional inventory screens, it enables developers to create interactive, camera-centered menus using familiar Minecraft elements.
With YAML configuration, a public Java API, dynamic states, schematic previews, and optional integrations, UIcore can serve as the foundation for a wide range of custom server interfaces.
Build menus that feel like part of Minecraft, not just another inventory window.