Linux

It still uses Proof-of-Work, in which the coal being burned is only to prove that you burned the coal.

The mersenneforums have users solve an obscure (to a non-mathematician) but relatively simple number theory problem.

Yeah, tarpits. Or, even just intentionally fractionally lagging the connection, or putting a delay on the response to some mime types. Delays don't consume nearly as much processing as PoW. Personally, I like tar pits that trickle out content like a really slow server. Hidden URLs that users are not likely to click on. These are about the least energy-demanding solutions that have a chance of fooling bots; a true, no-response tarpit would use less energy, but is easily detected by bots and terminated.

Proof of work is just a terrible idea, once you've accepted that PoW is bad for the environment, which it demonstrably is.

Because it's super common in web scrapers

All normal web browsers have Mozilla in the name so it’s kinda weird to only do it for that. Both chrome safari and FF start with Mozilla 5.0

Of course linting and formatting is not part of the language. Of course you can install extensions in some IDE that will handle it. Conan looks great but I never saw a project using it and when I was asking C devs about dependency management no one mentioned it. I checked dozens of GTK projects looking for some decent template to copy and didn't find anything remotely "modern". All projects I see simply use meson/ninja, install deps on system level, don't provide any code formatting or linting guidelines. Most don't bother with any modules and just dump all source code into 100 files in src. And I'm talking about actively developed tools for Gnome, not some long forgotten ones. For me the big difference between languages like C and Rust is that every Rust project uses the same formatting, linting tools, uses modules and proper dependency management while most C projects don't. Because it's old. Because a lot of C devs learned programming when it wasn't a thing. Because a lot of C project started when those tools didn't exist. You can probably start a new C project in 'modern' way but when I was trying to do it there were no examples, no documentation and when I asked C devs I was told that "you just do it like always". In modern languages the default way is the "modern" way.

This is how you declare a new component in gtk-rs:

glib::wrapper! {
    pub struct MainMenu(ObjectSubclass<imp::MainMenu>)
        @extends gtk::PopoverMenu, gtk::Popover, gtk::Window, gtk::Widget,
        @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Native, gtk::ShortcutManager;
}

impl MainMenu {
    pub fn new() -> Self {
        Object::new(&[]).expect("Failed to create `MainMenu`.")
    }
}

#[glib::object_subclass]
impl ObjectSubclass for MainMenu {
    const NAME: &'static str = "MainMenu";
    type Type = super::MainMenu;
    type ParentType = gtk::PopoverMenu;

    fn class_init(klass: &mut Self::Class) {
        klass.bind_template();
    }

    fn instance_init(obj: &glib::subclass::InitializingObject<Self>) {
        obj.init_template();
    }
}

This is how you declare a new component in Leptos:

#[component]
fn App() -> impl IntoView {

    view! {
   <div>test</div>
    }
}

That's what I mean by "it's not ergonomic".