They have done that already. It’s called Kylin.

Yep. And the worst part is the Fear-of-Missing-Out when disabling them.

Like, there is nothing stopping you from just not doing the kingdom management mini-game, except that nagging feeling that you might actually miss out on some content…

Currently? Potionomics. I just wanted something that I can finish quickly, because of the upcoming release of House of Light, but now I am still not done with my play-through, so I kinda cannot start House of Light just yet.

But in a couple of days, as soon as I am done with Potionomics?

House of Light. And that for quite some time, I expect.

And the predecessor, Pathfinder: Kingmaker is amazing too.

I haven’t done much Rust coding this year yet, mainly because I am trying to learn Lean4 and spent the last couple of months writing a (partially) formally validated (but not very fast) Binary Heap in Lean4.

However, a few days ago I had an inspiration at night, that brought me back to my Rust spare time project: The visual novel engine I had started last year.

For now I only did a relatively small change, but it’s one that will save me a lot of time (and nerves) later on. I am using a Free Monad based embedded Domain Specific Language for writing the game logic. The change now was to wrap that Free Monad in a State Monad Transformer, which I use to store the game state in.

This idea seems to be working surprisingly well, and that has given me enough motivation to return to this project and to keep developing it further for now.

Long and boring explanation with way too much detail:

Sorry for going on a tangent, but there is a Rust-specific detail that makes this cool beyond the usual advantages of using a State Monad Transformer, and I cannot stop myself from sharing.

For composing a large Free Monad, do-notation is more or less a must-have. However, do-notation in Rust only works well with types that implement Copy. If you want to use any other type in do-notation, you can only access variables of it in the following two lines. An attempt to access the data later will lead to an ownership problem (explained here). I have tried to overcome this by adding additional syntax to do-notation, but that is a crutch at best.

So, this is where the State Monad Transformer comes in. It side-steps this problem by moving the state out of the do-notation block into the Free Monad’s Pure-nodes. That way it is readily available via the State Monad Transformer’s get()/put() functions, and the “use within two lines” limitation is not a big issue any more, as one can always get the value on one line, do something with it in the next line, and write the result back on the second line.

Oh, that just happened. We didn’t have established processes for promotions for a very long time. The company was a tiny startup when I joined (quite literally in the cellar of the company founder’s place), with a really flat hierarchy and no distinction in seniority.

At the point when the company started to set up a formal process for promotions, I had already been there for so long, that I was considered one of the most experienced people, and that’s how I ended up being filed under “senior coders” in the employee list basically since that category existed… It also was a bit weird, as that happened to coincide with all the COVID lockdown chaos, and I never had a formal promotion talk, just an email with an amandment to my contract, which I didn’t even read too carefully, so I didn’t realize at first that this was not just the yearly pay increase 😉.

Oh, and believe me, the impostor syndrome is strong with me. I would not have promoted me to that role.

I am not in the position to decide which tech we use at the studio, however, as a Senior my voice is certainly heard when it comes to tech decisions.

And for Unity I can only say: No tech is worth the risk of dealing with such a shady company.

Me neither. I only (have to) use Windows at work, all my own PCs have been running Linux for decades…

I do know however, that WSL emulates most (but not all) Linux syscalls, so you can ran (nearly) all Linux programs on Windows - including WINE. There is also a driver in Mesa so that you can render 3D graphics from within WSL on any DX12 graphics card.

They will likely write their own emulator, but don’t forget about WSL. You can already run WINE on Windows, I wouldn’t be surprised if you could also run FEX+WINE on Windows for ARM.

by intercepting syscalls and executing them directly

Not only syscalls. FEX and Box64 also allow using native libraries instead of emulating them. That leaves basically only the game logic to be emulated.

ARM based Deck would be a huge improvement to battery life. Don’t get your hopes up too high. You will need an emulation layer like FEX of Box64, and unlike WINE those do have quite a substantial overhead.

It is impressive how far those emulators have come, especially since they got the option to use native libraries instead of emulated ones, but the game logic itself will always need emulation…

This doesn’t mean it can’t be done, it just means that the ARM CPU needs to be pretty fast to counter the emulation overhead, and that’s why I have my doubts about the energy efficiency…

(Btw: I have tried running several AMD64 games on my A311D powered MNT Reform laptop with Box64. It’s impressive how well the emulation runs, and how many games are actually playable already. However, I also encountered a lot of games that don’t reach enjoyable FPS on that hardware. With a faster ARM chip though…)

It depends on what kind of patent. I just googled the term I had used before, and it is indeed what I expected it to be: https://en.wikipedia.org/wiki/Design_patent

And yes, that name is stupid. That’s why I am happy that my native language, German, has a better distinction between “Patent” (what you described) and “Geschmacksmuster” (design patent).

About patents being public: They are. That’s because the idea behind patents is that after they expire, anyone can use them to build the technology they describe. The temporary exclusive usage rights that they offer are meant as an incentive for inventors to publish their findings. The only problem is that the legal situation did not keep up with the creativity of patent lawyers… (I will stop now, otherwise this will turn into an endless rant about how broken the patent system is.)

I’m not sure how the term “patent” is to be interpreted here. It could be used like back in the days when Apple sued Samsung because their phone had rounded edges too…

Like a “design patent” (sorry, I’m not a native English speaker, so I’m unsure if this is the correct translation).

A lot of the pals in the game look quite close to Pokémon. Not identical, of course, but so similar that one just has to wonder if the design has been “inspired” by Pokémon…

Amnesia.

Short answer: Whales.

Long answer: Watch the South Park episode on the topic. They explain it in detail. It’s titled “Freemium Isn’t Free”.

Need to enshittify it enough to make the AI features feel like an improvement.

This. There is very little need for third-party tools, as long as you don’t want to install a whole lot of games. After all, the installation process only happens once per game, and also without tools it doesn’t take very long.

As a step-by-step guide:

• Download the games from the GoG website. You can find them if you hover the site’s header bar, where your user-name is displayed. There’s a “Games” button which brings you to the list of games, where you can download the installers directly. The downloads are listed under “Download Offline Backup Game Installers”.
• Unpack the game installer.
  • Innoextract is your friend here. No need to run the installer, just unpack the files. Works with both, Windows and Linux games.
  • Alternatively, if it’s a native Linux game, you can just run the installer directly on the Steam Deck.
    • For Windows games you can theoretically also use Proton directly on the deck. However, the process is annoying, so I won’t go into details.
  • Alternatively, you can run the installer on your desktop PC and copy the files to the Deck via sftp.
• Add the game to Steam Library. This can be done in Desktop Mode. There’s a menu entry in Steam’s “Games” menu for that.
  • In the File Browser, you need to disable the file filter, as it (iirc) only shows .desktop files by default. You’ll want the game’s executable though.
• If it’s a Windows game, go to the game’s properties page in Steam, and force a specific compatibility tool for it, namely some recent version of Proton.
  • For native Linux games this step is usually not needed, but some very old games need to set the Steam Linux Runtime here.
  • For DOS games, check out my blog post about DOSBox on the Deck.
    • I don’t know how well it works on the Deck (never tried it, as I don’t feel it’s necessary), but there would also be boxtron.
• Last, but not least, use sgdboop to set some artwork.

I would be very surprised if they wouldn’t fix all 50 filesystems.

In all projects I have worked on (which does not include the Linux kernel) submitting a merge request with changes that don’t compile is an absolute no-go. What happens there is, that the CI pipeline runs, fails, and instead of a code review the person submitting the MR gets a note that their CI run failed, and they should fix it before re-opening the MR.

That’s a very good point. I hadn’t considered potential lack of domain knowledge at all. In that case Rust might even help, because it’s easier to write interfaces that can’t be used wrong - so that even someone without the needed domain knowledge might be able to fix compile issues without breakage.

Behind all the negative tone there is a valid concern though.

If you don’t know Rust, and you want to change internal interfaces on the C side, then you have a problem. If you only change the C code, the Rust code will no longer build.

This now brings an interesting challenge to maintainers: How should they handle such merge requests? Should they accept breakage of the Rust code? If yes, who is then responsible for fixing it?

I personally would just decline such merge requests, but I can see how this might be perceived as a barrier - quite a big barrier if you add the learning cliff of Rust.