Voice Chat Interaction

This server side Fabric mod allows Simple Voice Chat to interact with your Minecraft world.

## Downloads

– [Modrinth](https://modrinth.com/mod/voice-chat-interaction)
– [Third party Paper port](https://github.com/iGalaxyYT/voicechat-interaction-paper)

## Features

– A custom, configurable vibration frequency for voice
– Talking in voice chat activates sculk sensors
– Talking in voice chat is detected by the warden
– Optional support for whisper and group chat vibrations
– Talking while sneaking doesn’t trigger vibrations (Configurable)
– Configurable volume threshold

## Config Values

*config/vcinteraction/vcinteraction.properties*

## Credits

– [Fabric API](https://github.com/FabricMC/fabric)
– [Polymer](https://github.com/Patbox/polymer)

Version Numbering Converter

# VNC (Version Numbering Converter)

Version Numbering Converter (VNC) is a Java library for working with Minecraft versions across both numbering families:

– Classic Java-style versions such as `1.20.6` and `1.21.11`
– Year-based drop versions such as `24.1`, `25.4`, and `26.1.1`

It covers two use cases:

– Pure version modeling and conversion through `MinecraftVersion`, `VersionScheme`, and `MappingTable`
– Bukkit/Paper runtime detection through `VNC`, including server constants, player version resolution, protocol lookup, and version comparisons

## Highlights

– Exact historic mappings from `1.0.0` through `1.21.11`
– Drop support for current lines such as `25.4`, `26.1`, and `26.1.1`
– Protocol lookup for exact releases and published snapshots
– A runtime bridge for Bukkit/Paper with legacy-compatible constants like `SERVER_VERSION`
– String-based comparisons that correctly handle patch-sensitive boundaries like `1.20.5`

## Core API

### 1. Parse and inspect versions

“`java
MinecraftVersion classic = MinecraftVersion.parse(“1.21.11”);
MinecraftVersion drop = MinecraftVersion.parse(“26.1”);

classic.isClassic(); // true
classic.getVersion(); // “1.21.11”
classic.getProtocol(); // 774
classic.supportsHex(); // true

drop.isClassic(); // false
drop.getVersion(); // “26.1”
drop.getProtocol(); // 775
“`

### 2. Convert between numbering schemes

“`java
String dropName = VersionScheme.MOJANG.toDrop(“1.20.3”); // “23.2”
String classicName = VersionScheme.MOJANG.toClassic(“25.2.2”); // “1.21.8”

String customClassic = VersionScheme.CROA_CUSTOM.toClassic(“25.4”); // “1.22”
String customDrop = VersionScheme.CROA_CUSTOM.toDrop(“1.22.1”); // “25.4.1”
“`

### 3. Create your own mapping scheme

“`java
MappingTable table = new MappingTable()
.registerLine(30, 1, “1.50”, “1.50.1”)
.registerMapping(“1.51”, “30.2”);

VersionScheme scheme = VersionScheme.mapped(table);

scheme.toDrop(“1.50.1”); // “30.1.1”
scheme.toClassic(“30.2”); // “1.51”
“`

### 4. Resolve protocols

“`java
Integer protocol = MinecraftVersion.protocolForIdentifier(“1.20.6”); // 766
Integer snapshot = MinecraftVersion.protocolForIdentifier(“26.2-snapshot-3”);

MinecraftVersion newest = MinecraftVersion.fromProtocol(754); // 1.16.5
List all = MinecraftVersion.versionsForProtocol(767); // 1.21, 1.21.1
“`

## Bukkit / Paper runtime API

`VNC` exposes a runtime snapshot of the current server:

“`java
MinecraftVersion server = VNC.SERVER_MINECRAFT_VERSION;
String classic = VNC.SERVER_CLASSIC_VERSION;
String drop = VNC.SERVER_DROP_VERSION;
int protocol = VNC.SERVER_PROTOCOL;
double legacy = VNC.SERVER_VERSION;

boolean modernRegistry = VNC.isAtLeast(“1.20.5”);
boolean legacyCommands = VNC.isBefore(“1.13”);
boolean inRange = VNC.isBetween(“1.19”, “1.21.11”);
“`

Player version resolution uses ViaVersion when present and falls back to the server version otherwise:

“`java
MinecraftVersion playerVersion = VNC.player(player);

if (playerVersion.supportsHex()) {
// Safe to send RGB formatting to this player
}
“`

## Why use the string helpers?

`SERVER_VERSION` is still available for compatibility with older plugins, but patch-sensitive checks should prefer:

“`java
VNC.isAtLeast(“1.20.5”);
VNC.isBefore(“1.21.9”);
VNC.compare(VNC.SERVER_MINECRAFT_VERSION, “26.1”);
“`

That avoids the common limitations of comparing versions only as `double`.

## Requirements

– Java 8+
– For the Bukkit runtime helpers: a Bukkit/Paper-compatible runtime on the classpath
– Optional: ViaVersion, if you want `VNC.player(…)` to resolve the effective client version instead of the server version

VMinus

**This mod is deprecated for Forge and will recieve continued development on Fabric 1.21.1+**

Recipe banning is removed on the latest Forge versions to prevent the breaking of all modded recipes. No future fixes or features will be implemented for Forge versions.

**VMinus** is a mod that can edit, remove, and replace items, blocks, entities, and more (vanilla or modded) with simple json files. It can be done data-driven which is the first of its kind, but also optionally config driven if you do not understand datapacks. VMinus also has the capability with jsons to allow for global, tagged, and conditional modification to dynamically edit many features at once.

**Major Features**
– Changing many properties of any item such as stack size, durability, food properties, attributes, rarity, tooltips and more.
– Changing many properties of any block such as block sounds, destroy time, blast resistance, light levels, slipperiness and more.
– Changing of entity attributes and other niche properties (entity property modification will be expanded).
– Editing of every enchantment property for all vanilla enchantments.
– Ability to add mob variants for most vanilla mobs.
– Removing and replacing items from existing as items in-world, in simple recipes, in creative menus/JEI, and in simple loot tables.
– Removing and replacing blocks in all worldgen and placement.
– Removing entities from spawning and in /summon
– Removing any enchantment.
– Couple new commands such as heal, fire, freeze, and durability.
– Many new attributes to use such as critical damage, mining speed, magic protection and more.
–

VLCVideoAPI-Pol

# VLCVideoAPI
VLC API to play video and audio on Minecraft. Works on Fabric and Forge. It’s an API for developers.

[![](https://jitpack.io/v/dev.polv/vlcvideo-api-polcinematics.svg)](https://jitpack.io/#dev.polv/vlcvideo-api-polcinematics)

## How to use
### For users
1. Download the latest release from the [releases](https://github.com/polvallverdu/VLCVideo-API-PolCinematics/releases) or [modrinth](https://modrinth.com/mod/vlcvideoapi-pol).

### For developers

You can you use it with Gradle by adding the following to your `build.gradle`:
“`groovy
repositories {
maven { url ‘https://jitpack.io’ }
}

dependencies {
implementation(“dev.polv.VLCVideo-API-PolCinematics:vlcvideoapi:2.1.0”)
}
“`

And for fabric/forge subprojects:
“`groovy
dependencies {
modApi(“dev.polv.VLCVideo-API-PolCinematics:vlcvideoapi-{fabric/forge):2.1.0”)
}
“`

## Past contributors
– [Nick1st](https://github.com/Nick1st)

## Currently supported platforms
– [x] Windows 10/11
– [ ] macOS
– [ ] Linux

Vanilla Keybind Manager

# Vanilla Keybind Manager
[![License](https://img.shields.io/github/license/Fallen-Breath/fabric-mod-template.svg)](http://www.gnu.org/licenses/lgpl-3.0.html)
[![workflow](https://github.com/sakura-ryoko/vkm/actions/workflows/gradle.yml/badge.svg)](https://github.com/sakura-ryoko/vkm/actions/workflows/gradle.yml)

Use this addon to make MaLiLib keybinds to show incompatibilities with Vanilla Keybinds, and then edit the Vanilla keybinds if they conflict.

Tired of fixing keybinds from different Keybind systems? This is your solution.

## DEFAULT HOTKEY: `O + C`

![Default-Hotkey](https://github.com/sakura-ryoko/vkm/blob/multi/Default-Hotkey.png?raw=true)

_or optionally access it using the MaLiLib Config Switcher from 1.21+._

[![Join Sakura’s RyokoCraft Discord](https://sakuraryoko.com/files/1398873/discord-300px.png)](https://discord.gg/ryokocraftmc)

vJourney

# vJourney

**Turn your server’s quest system into a native Minecraft experience.**

vJourney lets you create fully custom quest trees that live inside Minecraft’s own advancement menu — no external GUIs, no extra commands for players to memorize. Just open advancements and play.

—

## ✦ What is vJourney?

vJourney is a Paper plugin that uses Minecraft’s built-in advancement screen as a quest board. You define quests in simple YAML files, connect them into branching trees, and players progress through them naturally — all inside the familiar advancement interface they already know.

Every quest can have three visual states: **blocked**, **in progress**, and **completed** — each with its own description, so players always know what to do next.

—

## ✦ Features

– **Visual quest trees** built on the native advancement menu — no external GUIs
– **Branching paths** with parent/child hierarchy, multi-parent convergence, and hidden branches that reveal themselves as players progress
– **Three frame styles** — task, goal, and challenge — to distinguish quest types visually
– **Rich trigger system** supporting mob kills, item holding, region entry, BetonQuest tags and points, PlaceholderAPI values, permission nodes, and more
– **Progress counters** with live display in the quest tooltip
– **Persistent or state-based** completions — quests can lock in permanently or react to changing conditions
– **Announcements** — local chat, global chat, title, actionbar, and toast notifications, fully configurable per quest
– **Custom icons** with support for custom model data (ItemsAdder / Nexo compatible)
– **Multiple tabs** — organize quests into independent categories, each with its own icon, background, and display order
– **Vanilla advancements** can be hidden so only your quests are shown
– **Bilingual** — ships with `en_US` and `pt_BR` out of the box

—

## ✦ How It Works

You create a `.yml` file inside `plugins/vJourney/categories/`. Each file is one tab in the advancement menu. Inside it, you define quests and connect them with `parent` links to form a tree.

“`
[Arrive at the Village] ──► [Villager’s Request] ──┬──► [The Mine Problem] ──┐
│ ├──► [Village Council]
└──► [Lost Harvest] ──┘
“`

Players see the full tree, track their progress in each quest’s tooltip, and unlock new branches as they complete objectives. Hidden branches can reveal secret paths, side quests, and surprise rewards.

—

## ✦ Trigger System

Quests complete automatically when their trigger condition is met. Built-in triggers include:

Soft dependencies are detected automatically — triggers only activate for plugins that are actually installed.

—

## ✦ Requirements

—

## ✦ Quick Setup

1. Drop `vJourney.jar` and `UltimateAdvancementAPI.jar` into your `plugins/` folder
2. Start the server — a working example category is generated automatically
3. Copy or edit the example file to create your first quest tree
4. Run `/vjr reload` to apply changes live, no restart needed

> 📖 **Full documentation** — syntax reference, all triggers, positioning guide, and complete examples — is available on the [Wiki](https://vorpix.net/vplugins/wiki/vJourney).

Vivecraft Spigot Extension

# Vivecraft Spigot Extensions
VSE is a companion plugin for [Vivecraft](https://modrinth.com/mod/vivecraft), the VR mod for Java Minecraft.
VSE is for [Spigot](https://www.spigotmc.org/), [Paper](https://papermc.io/software/paper) and [Folia](https://papermc.io/software/folia) servers and adds several enhancements for VR players.

# Features
– Vivecraft players will see other Vivecraft players head, arm and leg movements.
– Support for Vivecraft 2-handed archery.
– Assign permission groups for VR players.
– Fixes projectiles and dropped items from VR players.
– Shrinks Creeper explosion radius for VR players from 3 to 1.75m (Configurable)
– Reduces Mobs melee attack radius for VR players ny -0.4m (Configurable)
– Support for Vivecraft Roomscale Blocking (Toggleable)
– Support for Vivecraft Dual Wielding (Toggleable)
– Support for Vivecraft Climbey Tools (Toggleable)
– Support for Vivecraft Arrow Headshots (Configurable)
– Support for faster block breaking (Toggleable)
– Option to limit server to Vivecraft players only.

See the config.yml when you run the plugin, or the [Config](https://github.com/Vivecraft/Vivecraft-Spigot-Extension/wiki/Config) wiki entry for all available configuration options.

# Versioning
The plugins version number is split into two parts, the first part is the Vivecraft version that the plugin supports the features of, and the second part is the release version, this increments with fixes or when adding support for new Minecraft versions.
Example:
`1.3.3-0`: This version supports the features of Vivecraft `1.3.3` and is the first release for that version

# Using Proxies
When using proxy servers you might need to add a compatibility plugin to your proxy server so that our data is correctly forwarded to the spigot/paper/folia server.
A this moment we have extensions for
– BungeeCoord: [Vivecraft BungeeCord Extensions](https://github.com/Techjar/Vivecraft_BungeeCord_Extensions/releases)
– Velocity: [Vivecraft Velocity Extensions](https://github.com/Techjar/Vivecraft_Velocity_Extensions/releases)

# Metadata
VSE provides Spigot metadata on `Player` objects so other plugins can provide special support for handed interactions or somesuch. If you aren’t sure what metadata is, check the [Spigot documentation](https://hub.spigotmc.org/javadocs/spigot/org/bukkit/metadata/Metadatable.html). The API supports multiple plugins using the same metadata key, so make sure you filter to our specific plugin name (`Vivecraft-Spigot-Extension`).

For details on available data see the [wiki](https://github.com/Vivecraft/Vivecraft-Spigot-Extension/wiki/Metadata)

# API
We also have an API to access more data, like the history of all available body parts, for more details on that see the [wiki](https://github.com/Vivecraft/Vivecraft-Spigot-Extension/wiki/API).

Vivecraft

# Vivecraft
Vivecraft is the mod that transforms Minecraft into an exceptional VR experience in room-scale or seated play!
More info [https://www.vivecraft.org/](https://www.vivecraft.org/ “https://www.vivecraft.org/”).

Vivecraft is a well-known VR mod that goes way back. Due to this it has some code practices that are no longer used and makes development and collaboration harder. In respons we’ve started to recode it using more modern methods, to stay up to date and more compatible with other mods. The result is being able to play Vivecraft on Forge, Fabric and Quilt!

Need help or have any questions? Feel free to come to our Discord server [https://discord.gg/jYyyv7zhSW](https://discord.gg/jYyyv7zhSW)

## FAQ

### Isn’t Vivecraft for Forge?
In the past Vivecraft was only available on Forge. However, we have rewritten it so it can run on Fabric and Quilt as well.

### Can other players see my hands/What about NONVR?
This mod also has **NONVR included** in the jar. VR Is disabled by default, and can be enabled in the Main menu.

For other players to see your hands, they need to have this mod on their client and the server either needs this mod, or the [Vivecraft Spigot Extension](https://modrinth.com/plugin/vivecraft-spigot-extension) (if the server is a spigot/paper server).

### Does it work with MCXR?
No this is a separate mod, and does not interface with MCXR

### Does it run natively on the Quest?
No, but maybe in the future.
In the meantime, there is [Questcraft](https://questcraft.org/ “https://questcraft.org/”) which uses a modified version of this, to make it compatible with the Oculus/Meta Quest.

### What about Sodium/Iris … Will it work?
Sodium does work.
Iris works.
Any other mod is untested. Mod compatibility is an important thing to us, however, it is not simple. For now we focus on getting it to be stable, after which, we will work on compatibility.

### What about Optifine?
Since 1.0.0 Optifine is compatible with the mod, but not required

### What about 1.19.0?
There is one version available for it, but it will not get any further updates.

Vitae

# Vitae

Vitae is a data-driven entity framework for NeoForge 1.21.1 that lets you create custom animated mobs, bosses, and NPCs through datapacks.

## Features

– Custom entities defined entirely in JSON
– GeckoLib animation support
– Multi-phase boss behavior
– Data-driven abilities and combat logic
– Optional KubeJS integration for scripting
– Support for custom loot, boss bars, and spawn rules
– Demo content included for testing and reference

## Optional Integrations

– KubeJS for custom events and ability logic
– External spell bridges for modpack-specific compatibility

## Notes

Vitae is a framework mod, not a content mod. It is meant to be extended through datapacks and optional scripts by modpack authors.

Visual Novel Framework

# Visual Novel Framework

#### This is a Framework to give Mod Maker and others to add VN-like cutscenes/scenes inside the game.

## Description

This mod requires a Script to Play.

The mod leverages Vanilla Resource Pack system, so installing a script is identical to installing a Resource Pack. Drag and drop into the Resource Pack folder. Inside the script, usually, there should be a ‘trigger word’

Name a mob this ‘trigger word’ and right click it with the item to talk with it.

Have fun!!!

#### Features

* Dialogue System, VN Style
* Custom Scripting / Pseudo DSL and a Framework and an SDK for Script Development
* Branching Dialogue
* Variable Tracking System (inside the game)
* 2D Sprite, like Visual Novel
* Multiple Sprite System!
* Align Character Position and Such~

#### CUSTOM SCRIPTS!?!?

* YES!
* I made a scripting language just for this in Python!
* Use the Hikarin SDK to create and compile scripts!
* More info can be found in the SDK Read Me

#### Compatibility?

Okay this is an interesting topic.

Since this mod relies on two things, the Mod Itself and the SDK/Framework there are some notes about compatibility:

* Script written using the newest SDK will always be compatible with the Older Version of the mod.
* If the script contains a missing feature (Say, you made a script using the latest SDK and run it in the Mod Beta version that doesn’t support background), well, the script will run, just the background won’t change.
* Script written using the older SDK will always be compatible with the Newer Version of the mod. (Though, this may vary, but backwards compatibility should always be possible. Report a bug for problems with Compatibility.).

What about Cross Mod Compatibility? Modpacks?

* The Visual Novel Engine running inside Minecraft is written in Pure Java it is independent of Minecraft itself.
* The ‘modded’ / ‘minecraft’ part of thing is the UI. A mod that messes with how Minecraft handle UI (overrides the Guigraphics for example), will not be compatible.
* On that note, feel free to use this on your mod, modpacks, whatever~

#### Coming Soon

* DBMS for permanent variable and state tracking (Might be out of scope, but ironically available in Alpha version)
* Animation Feature (Not out of scope and is being worked on, but ironically is the one getting put on hold)

Mod Github Page: [Minecraft Visual Novel Framework](https://github.com/Iteranya/MinecraftHikarinMod)

SDK Github Page (to make scripts): [Hikarin Visual Novel SDK](https://github.com/Iteranya/hikarin-framework)

### Can I Use This In My Modpack???

Yes, Go Ahead, This Thing Is Made For That!!!

But… Consider letting me know / discuss it with me so I can help you with getting it set up.

Since script development is somewhat separate from Modding, it can be a bit confusing if you’re not used to Python.

Discussion + Query: [My Discord Server](https://discord.gg/Apr4MTE3vm)