There’s also reTux which is another game using the same assets.

Personal data storage can be decentralized, although that’s missing the social part of the social network.

Identities are set up through a centralized system that in theory they could change, but I wouldn’t bet on it.

Relays supposedly can be decentralized, but need to handle all data on the network. So they require massive hosting costs that keep going up as more people use bluesky. Only large corporations can likely afford to run them, and that hasn’t happened yet.

That’s definitely a factor to consider, but running binary blobs that you don’t have the source for is also a risk. It comes down to what threat vectors you think are important and what risks you’re willing to take.

It’s probably because they use busybox instead of gnu utilities so it’s not technically GNU/Linux, but yeah.

Short answer is Trisquel if you like Ubuntu/Debian, Parabola if you like Arch, and Guix if you like frustration.

The libre kernel is a bit of a pain regarding wifi and bluetooth, and depending on your graphics card the drivers aren’t going to run quite as well. You might need to get new a wireless card/usb, since there’s only a few modern chips that work with it.

There’s a list of distros on gnu.org that use the libre kernel by default, if you want to look at more options. PureOS is based on Debian focused on privacy and security. Hyperbola is based on Arch with 32 bit and BSD options.

Personally I use Guix, which is an amazing abomination with awesome features that most people don’t care about. I wouldn’t recommend it for most people unless you are coming from NixOS, know a lisp dialect, and/or are willing to put in a lot of effort.

It was pretty heavily associated with the alt right a decade ago as it was getting more popular. Some alt right meme communities like frenworld and clown world were centered around it, with overtly fascist pepe variants. It’s gotten more popular in a lot of other circles, but if someone identifies enough with it to use as a profile picture I’d at least check their posting history.

Looks good. I’ve always found it annoying that lemmy doesn’t do this by default.

I’m not sure about the license though. Creative Commons recommends against using their licenses for software, since it doesn’t include terms regarding source code, doesn’t handle patents, and it’s usually incompatible with free software licenses.

Google is still appealing it, so at best that will happen next year. But yeah, they’re probably adjusting their budget in anticipation.

Mozilla is set up as a non-profit with a for profit company as a subsidiary. The corporate Mozilla handles working on Firefox, mostly using money from Google for setting it as the default search engine. Because of that separation I don’t think they can easily mix those two piles of money together.

There’s this section from their FAQ:

Don’t Mozilla products, like Firefox, earn income?

Firefox is maintained by the Mozilla Corporation, a wholly-owned subsidiary of the Mozilla Foundation. While Firefox does produce revenue — chiefly through search partnerships — this earned income is largely reinvested back into the Corporation. The Mozilla Foundation’s education and advocacy efforts, which span several continents and reach millions of people, are supported by philanthropic donations.

There’s Mines3D on android, although the graphics are still 2d and it’s a pain to play.

I feel like it’s really far from being open. Besides the training data not being open, the more popular ones like llama and stable diffusion have these weird source available licenses with anti-competitive clauses, user count limits, or arbitrary morality clauses.

It makes sense that if you’re designing a language, you’d like the language you made and would want to use it. It’s fine for compilers like that to exist, and even be the main one used, but ideally it shouldn’t be the only compiler.

But there are technically ways to bootstrap a language without writing it in another language (other than a small core in assembly or something). You could design a tiny compiler that only handles a small subset of your language, then write a better compiler using only the features available in that subset. You can do this for several layers of compilers until you have the full language.

That’s already how it is now, we just don’t usually think of it that way. You can’t compile rust unless you already have a rust compiler. The current version was compiled in a previous version, which was compiled in a previous version, going through a chain of older versions and other languages. Anything along that chain could’ve theoretically had an influence on the current compiler.

It’s not about the code itself being more trustworthy. The point is that when you bootstrap, you don’t have to blindly trust any of the binaries, since it’s source code the whole way down. Someone could bootstrap rustc like this, compare it to the binaries that already exist, and ideally they would be identical.

A lot of this bootstrapping stuff comes back to the ‘trusting trust’ attack. You could write a compiler that adds some malicious code to programs it compiles. But the thing is, it could also insert it’s own malicious code when compiling a compiler. So you look at your code, and the code of your compiler, and everything looks fine, but the exploit is still there. Someone wrote an example in rust.

Theoretically there could also be bugs that propagate this way. So to fully trust your code is doing what you think it is, you’d need a chain of compilers back to hand coded assembly.

Yeah, I wrote the wrong language. I tend to lump those together in my head as ‘big multi-paradigm languages I haven’t bothered to learn yet.’

You can technically do it, but it’s a convoluted path. The article talks about it. Basically to bootstrap that way you need to go through a lot of versions of rust, compile rust 0.7 in ocaml, compile ocaml in scheme, and compile scheme in C using gcc. For gcc you need to compile a chain of versions back to when it was written in C instead of C++, plus the whole TinyCC bootstrapping path.

edit: had listed scala instead of ocaml

The main thing is that TinyCC has already been bootstrapped.

Check out this page on bootstrappable.org. Basically they start with a 200 something byte binary (hex0) that can act as an assembler, then using a bunch of layers of tools and compilers you can bootstrap a whole system. I think they use stage0 to build M2-Planet, use that to build GNU Mes, and use that to build TinyCC.

So a project like this fits neatly into that bootstrapping path. It could be done other ways, but starting from a fairly complete C compiler makes it a lot easier than building an entire path from scratch.

There’s lem.el for Emacs.

There was another one but it doesn’t work anymore. It hasn’t been updated in 3 years.

It usually implies it’s weird in an old-fasioned way though.

Hacker’s Keyboard hasn’t had a real release in about 5 years, so it can be slightly buggy.

Unexpected Keyboard is pretty good. It’s got the complete keyboard layout available including stuff like Control and Function keys, so I think it’s an acceptable replacement. It uses swipes to type other keys, which I’m not sure if I prefer, but it works well enough. I set the swipe distance higher because I would accidentally swipe from time to time.