Using Java 25 to make Minecraft run just a bit faster

2026-07-17T00:00:00+00:00

Since versions of 1.20.5 and higher, Minecraft started to require Java 21. After Minecraft v26.1, the Java requirement got boosted to Java 25.

Java 25 has added some experimental command line arguments which make the game run a bit smoother.

Here's how you can take advantage of them.

The command line arguments I'm talking about, of course, are:

-XX:+UseZGC -XX:+UnlockExperimentalVMOptions -XX:+UseCompactObjectHeaders

In technical terms, what it does, is that it enables a different newer version of the garbage collector, as well as a different object representation format.

It doesn't mean too much normally, but in a scenario where you're, for example, playing modded minecraft and the mods are constantly using the memory to the point where it quickly runs out of it, it cleans up the memory in a smoother way, thus making the game freeze less if it's constantly running out of memory.

In addition to that, the compact object headers make the game just a bit more efficient at using the memory.

The only problem is that if the game is expecting Java 21, you may get some complaining from your launcher, which is what I'm gonna talk about next.

How do I do the thing??

Let's start things off by fetching an installation of Java 25. For this, I recommend using the GraalVM build of Java specifically, as it's a slightly different version of Java which can be a bit more efficient at running the game than OpenJDK (the version of Java used by most things.)

Step 1: Install Java 25.

If you can deal with the GitHub interface, you may go to the release page of GraalVM on GitHub, and fetch it from one of the releases, or alternatively, the convenience links in the very convenient table.

I have a very convenient table of my own, though, ⬇️

Platform	Java 25
🪟 Windows (x64)	Download ⤵️
🍏 MacOS (aarch64)	Download ⤵️
🐧 Linux (x64)	Download ⤵️
🐧 Linux (aarch64)	Download ⤵️

After you download the archive, you need to extract it in a place that's not too important but not too unimportant.

Step 2: Launcher setup.

1. Modrinth.

Go into the settings of your instance:

And then in the Java and memory option, enable the Custom Java Installation, and find where you extracted that Java archive, go into the bin folder within it, and select the java executable (java.exe on Windows)

It may give you a red X, but it doesn't mean that it won't work just yet.

Enable the Custom Java arguments, and insert the following into it:

-XX:+UseZGC -XX:+UnlockExperimentalVMOptions -XX:+UseCompactObjectHeaders

After this, you can try launching the game and it should hopefully work.

If it doesn't work, try making sure you're pointing at the right executable.

2. Prism Launcher.

Right click on your instance, select edit, and then go in the Settings tab in the side panel.

After that, select the Java tab in the settings.

Afterwards, either press browse on the Java Executable section or type in the path to the java (or java.exe) file manually. It is located within the bin folder in the archive you extracted earlier.

Make sure to check to disable the "Skip Java compatibility checks" option.

You can try pressing "Test Settings" after you select the java executable to make sure it works.

Afterwards, scroll down, check the "Java Arguments" option below, and put in the command line arguments into it:

-XX:+UseZGC -XX:+UnlockExperimentalVMOptions -XX:+UseCompactObjectHeaders

Afterwards, make sure to try to launch the game and see if it works.

If it doesn't, make sure the path to the executable you're pointing to is correct.

Have fun!

That is not a Linux distro. It is a config.

2025-09-25T00:00:00+00:00

Ubuntu and Debian are distros.

Fedora Atomic and Bazzite are distros.

Arch is a distro, CachyOS is a distro.

But they're not the same.

Ubuntu has a similar workflow to Debian, it has the same kinds of software and both have the same package manager (apt), but at the same time, they're not always compatible and they're not even supposed to be.

What about, for example, Bazzite. What's the difference between Bazzite and Fedora Atomic?

Well, Bazzite is just Fedora Atomic but with different settings and other different preinstalled stuff, it targets a different workflow and a different kind of audience.

Coming from Fedora Atomic, Bazzite would be pretty much just, yknow, Fedora Atomic, but slightly different.

CachyOS and Arch? If you hide all of the branding, it would be hard to tell the difference.

So what's a distribution, something ducks walk on?

A Linux distro is quite literally, a distribution of the linux kernel, as well as other software. Most likely, alongside the kernel, your average linux distro might feature GNU coreutils, systemd, something like grub or systemd-boot, and something like dracut.

So, now we know what a linux distro is, but why am I making the article?

I'm making the article because, by the definition, any kind of distributed distro which comes with an installer or something is a distribution, but I feel like there are some cases which would benefit from having a more specific label.

If I will make a distro based on NixOS, and the only difference from NixOS is the default configs being changed, can I really call it a linux distribution?

By the prior definition of "linux distro", it would count as a linux distro, because it is a literal distribution of linux.

But in terms of my own personal feelings, it feels significantly different, than, for example, Ubuntu being derived from Debian. That is because Debian and Ubuntu are different enough where you don't really see them as one thing.

If someone makes some crappy collection of packages and configs for Arch and Hyprland, and distributes it, and somehow earns money from it, it would count as a distro, and I can't say it is not, because under the definition it is. But it also feels wrong.

How can this count as it's own thing when it's clearly not??

We need clearer naming schemes

As a solution, we can come up with linux distro tiers.

Root tier - A distro which is directly responsible for packaging and distributing software. Has it's own infrastructure. For example, Debian, Arch, NixOS, Fedora. It is usually the one other distros are based on.
Derivative tier - A distro which is based on some sort of other distro, such as Ubuntu being based on Debian, or for example, SteamOS being based on Arch. It might be aimed towards a specific group or workflow, but uses preexisting infrastructure, while maybe adding some on top. The key thing is that it is either incompatible, or does not aim to be compatible with the original distribution it derives from.
Config tier - A distro which adds some stuff on top of a preexisting distro without significantly altering anything, especially anything on the backend. It is entirely compatible with the distro it is based on.

Think, for example, I cannot run Ubuntu software on Debian without recompiling. That's because, while Ubuntu is kind of based on Debian, it has it's own infrastructure and it's own packages, and the release cycle is dramatically different. Debian packages are more "stable". This is why i'd call it a derivative tier distro.

Meanwhile, something like CachyOS is a config tier distribution of Arch.

They are just Arch but with preinstalled stuff. CachyOS is just Arch but aimed to be slightly more user friendly and comes with it's own repository of packages which are meant to be compatible with Arch Linux.

But, at the same time, there's also a weird inbetween scenario. SteamOS is based on Arch, uses Arch packages, and by all means is an Arch distro, but it is dramatically different to Arch.. IF you do not activate the command to make it mutable, and IF you do not set the system password which would allow you to use sudo. I guess that makes it more of an.. uhhh.. semi-derivative tier distro?

I don't know.

Constant quantization (CQP) in ShareX

2024-12-06T00:00:00+00:00

TL;DR

Enable custom commands and replace the normal CBR bitrate setting, which is like:

-b:v 6000k

With:

-rc constqp -cq 24

-rc constqp enables CQP
-cq 24 sets the quantization to 24

The story

I'm a big fan of high quality recordings, and I'm an even bigger fan of small file sizes, which is exactly why I love CQP.

CQP or "Constant Quantization Parameter" is a Variable Bitrate setting which basically reduces or increases the bitrate to maintain a similar video quality for each second of the video. Higher quantization means less overall quality for the video.

In my OBS settings, for recordings, I always enable CQP with Nvidia or CRF with x264 because it makes desktop screen recordings super high quality but with really small filesizes, small enough to shove the video straight into a discord server, where the maximum file size for non paying "citizens" is like 10 MBs. (Well it used to be 8 MBs then they updated it to 25 MBs and then down to 10 MBs but that's not the point of this post)

I am also a big fan of ShareX and while using the video recording option in it, as usual, I realised that I should probably enable CQP in it too, but it doesn't come with any kind of CQP options if you're using the H264 Nvidia option.

After seeing that it does not have a CQP option, I started googling for how to enable CQP in ffmpeg, which is where I realised that it is very much not documented.

So I jumped straight into the word meatgrinder (with my meatgrinder of choice being LLama 3.1 70B of the duckduckgo variety), put in the arguments used by ShareX, and asked it to modify the arguments so it will use CQP instead of CBR. It told me that I should remove -b:v 6000k and replace it with -rc constqp -cqp 18, which ended up not working, because -cqp isn't a real argument. It is actually -cq.

After enabling custom commands, I replaced the bitrate setting with the before mentioned arguments and it worked. The ffmpeg params which I ended up having are:

-f dshow -thread_queue_size 1024 -rtbufsize 256M -audio_buffer_size 80 -framerate $fps$ -i video="screen-capture-recorder":audio="virtual-audio-capturer" -c:v h264_nvenc -r $fps$ -preset p4 -tune hq -rc constqp -cq 24 -movflags +faststart -c:a aac -ac 2 -b:a 128k -y "$output$"

Only difference is that I changed the constant quality parameter to be 24 instead of 18, because having a slightly lower quality is totally fine for me.