Yes, it is true. There are a lot of reasons, I want to explain some of them, or at least bring the idea nearer
Sounds like magic and it is not magic. If you use kotlin, you use a different style of programming
and that indeed can make it faster (e.g. map[key]?.let vs if map.containsKey(key)) map.get(key) …
Also language features help out here (e.g. removing function call layers with inline).
Delegates can cache values (especially maps) and make observers light (at least from code perspective)
Sometimes I do/allow dirty hacks (no proper opengl buffer unbinding, disabling bloated features like biome noise). Also some stuff just gets implemented half way and some bugs (e.g. transparency) are a side effect, but they are not major.
Code should be simple. I try to write everything as simple as possible, not like Minecraft. Minecraft has a lot of pieces that are not understandable. Normally simple codes is faster.
From time to time I am profiling minosoft and analyzing the current code sequence. It sometimes is pretty obvious why things are slow, sometimes it takes longer, but in either way I am doing changes and then I profile them again until it is fast enough.
You can profile memory in two ways:
Sounds for most daus bad, but your system memory has 1 job: getting used. With that principle in mind I can cache a lot of things (like 3d biomes) or block states. That often makes things WAY faster. I am using as much memory as needed to improve performance.
The higher the allocation rate, the more (useless) memory bandwidth is used and the garbage collector needs to work. Despite loving final (i.e. immutable) things, I am reusing objects in all performance critical parts (especially in physics and rendering). That makes things a lot faster.
Meant in the meaning that a lot of stuff is not yet implemented. Should be a bad thing?
Sometimes I am implementing things completely different from minecraft, but the result is the same (e.g. beds, signs not as block entity)
Minosoft does everything with shaders and vbos (vertex buffer object). Minecraft often still uses legacy opengl (i.e. pushing matrices, ...).
Most modern cpus have 8 cores. Minecraft does most important stuff on one thread (one cpu core). Minosoft is mostly not aware of "static threads". That means that all operations are executed in parallel and timed that almost all operations can make use of modern cpus.
Checking stuff for every version is expensive. Only one version is easy :)
All data is dynamic and "liable". That needs to be corrected (e.g. maps over arrays for registry id mapping)