I can't imagine Java Minecraft ever to have run well on a mid-range Raspi.

So how did they break that?

* run both server and client when in singleplayer - doubles memory use

* turn byte block IDs into object pointers - octuples memory use for blocks

* make all game content into JSON object trees with huge amounts of indirection - adds about a GB of objects deserialized at startup that used to be simple if/then ladders

* add a whole bunch of code to handle these object trees, don't know how much this adds but probably 100MB of code when you include the raw class files through to the JIT-optimized assembly.

> run both server and client when in singleplayer - doubles memory use

When did this change? It's been like that for as long as I can remember. It's actually a very common thing for games to do because it requires less code. Also it doesn't actually double memory use - game content can be shared, textures/meshes/audio is only on the client, etc. The chunk and entity data would need to be duplicated but they should be smaller.

> Chunk data was traditionally the biggest part of Minecraft's memory use until they added a bunch more garbage.

But that's only really because it is extremely light on assets that are typically large in other games.

I'm a bit indifferent about this. Obviously they made a lot of decisions that aren't good for performance but it's a tradeoff. Notch was most productive working in Java so he could pump out updates quicker, and it helped with modding even though builds were obfuscated. NBT helped maintain backwards compatibility of worlds and probably helped with modding too. If they had done things differently then Minecraft may not have been the huge success that it is.

They even managed to pessimize the assets. They did this by, during startup, pre-converting every possible rendering state of every block in the game into a static 3D model made out of Java objects (Vertex, Face, etc). This wastes about a GB of RAM.

Before Minecraft 1.8, blocks were rendered by running block-specific code for each block to render it in the needed state. One function would append a ladder to a vertex buffer, another function would append a cube to a vertex buffer, another one for stairs, etc. Since the same code block would render any material variant and direction variant of stairs, this didn't use excessive memory.

I know that in 1.8, the biggest single waste of models was redstone dust, because it comes in 16 power levels and approximately 3^4 side connection states (connected, not connected, and connected up the side of a block, but not all combinations are possible) which is over 1000 unique models. Not sure if this is still the case.

Inefficient but surely beneficial to modding.

> pre-converting every possible rendering state of every block in the game into a static 3D model made out of Java objects (Vertex, Face, etc). This wastes about a GB of RAM.

Alternatively, these are the game's assets, so it isn't a waste. Running the code to generate blocks all the time wouldn't be ideal so caching makes sense but I don't know why they wouldn't lazily populate it.

It's extra infuriating that online sources report the game running flawlessly but seem to ignore input lag.

    DXVK_CONFIG="dxgi.syncInterval = 0; dxgi.maxFrameLatency = 1; dxgi.maxFrameRate = 60" gamescope -f --immediate-flips -- %command%

I also manually disabled vsync in the game's `local.cfg` XML file.

I love where "gaming on Linux" is going. But I have the feeling the hype on Youtube etc. is in part created by content creators, and doesn't faithfully represent the actual situation (surprise!).

Now when people ask me what time it is and I say 1845, they often follow up with "What time is it really for normal people?"

Quarter 'til 19 of course.

This is a common thing to say, but when during the development of human civilization has this actually been the case? Is agriculture designed around humans more than hunting/gathering? Is industrialized work more designed around humans than agrarian society?

I don't mean to sound pessimistic or technocratic; quite the contrary. But I think we shouldn't project our desire for equanimity onto romantized versions of civilization.

It looks like absolute hell of constant distraction making it impossible to reach a state of flow.

I've bounced off Claude Code (et al) multiple times.

But very recently I've had some successes. With some bulk bug fixes, it felt the same as scripting data quality fix ups. With proof of concepts in mind, tried 3 very different ideas.

Two quickly flamed out, revealing that I needed to chew on those ideas (a lot) more. If we're measuring how to "fail faster", I'd score these as useful efforts.

But one has been a very unexpected delight to work on. Almost addictive, like coding feels when you're in the flow.

Any way. The current mania for coding harnesses is total insanity. Mario of Pi.dev fame is spot on and far more insightful and articulate than me.

Cast their spells, explosive violence

Russian night time flight perfected

Flawless vision, undetected

(Sabaton)

It may seem a joke but you actually can learn history with Sabaton.

But yeah, what's moderation and what's excessive is subjective.