Skip Navigation
InitialsDiceBearhttps://github.com/dicebear/dicebearhttps://creativecommons.org/publicdomain/zero/1.0/„Initials” (https://github.com/dicebear/dicebear) by „DiceBear”, licensed under „CC0 1.0” (https://creativecommons.org/publicdomain/zero/1.0/)GI
Giooschi @lemmy.world
Posts 0
Comments 62
ThemeChanger 0.12.0 - now it can set the theme of libadwaita apps
  • Does GNOME really need an app to change the theme?

    You can also do what this app does manually. The point is that "themes" are an hack and not officially supported, as such it doesn't make sense to provide an official interface to set them.

    KDE plasma has this natively...

    Do you mean for global themes, application styles or plasma styles? All application styles I can find either use Kvantum or require you to compile them manually...

  • CachyOS Introduces New Repository Optimized for AMD Zen 4 and Zen 5 CPUs
  • Software implementations of those features is often slower, and runtime checking can often be too expensive compared to the gains.

    since it seems like nobody but cachy or custom kernel runs anything but V1

    Gentoo offers x86_64-v4 binary builds too.

    There was a proposal for Fedora too, though it was ultimately rejected.


    Ultimately the gains right now seem to be only 1-3%, though that might also be because there's not much demand for these kind of optimizations. If more distros enable them they might become more widespread and the benefits might increase too. It's a chicken-egg problem though.

  • Drew DeVault on the biggest threats to FOSS and some proposed solutions
  • Emails are nowhere near being competitive with discord. Sure, they're technically more accessible, but in practice they are much less usable by random people which in turn will just avoid interacting or contributing with your project.

  • The borrow checker within
  • It's mentioned in footnote 6:

    As an example, to make this work I’m assuming some kind of “true deref” trait that indicates that Deref yields a reference that remains valid even as the value being deref’d moves from place to place. We need a trait much like this for other reasons too.

    It would only work for references that are stable after the value they reference is moved. Think for example of a &str you get from a String.

  • Linux Mint looks to fork more GNOME Apps because of libAdwaita
  • GNOME devs never said that theming is incompatible (just "not supported"), and you're still not explaining whay you mean with "incompatible" either. Managing window controls also doesn't seem a requirement to be "compatible", as the app still runs fine even with client side decorations (again, it just won't fit visually with the rest of the system).

    And by the way, the problem is not theming per-se, but the fact that apps get themed by default, they inevitably break by default, and app developers are left to deal with that. Nobody ever tried to improve the situation so the solution they came up with is to have their apps always look the same.

  • Linux Mint looks to fork more GNOME Apps because of libAdwaita
  • How about when the theming is baked in and impossible to change?

    It can still be changed, it's just a harder to do so.

    It's about doing things that go against the interests of the user.

    This conveniently ignores that app developers are also users of ui frameworks, and they would like a well defined platform to test for, rather than an endless stream of distros each with its own theme that could break their app.

  • Linux Mint looks to fork more GNOME Apps because of libAdwaita
  • Libadwaita is only compatible with gnome and only works with gnome. Other DE's can try to make it work in their DE, but the experience for them is hostile.

    Not sure what you mean with "compatible", as libadwaita apps are supposed to work on other DEs as well. It might not fit visually with them, but that's not being incompatible.

  • Inline const expressions have been stabilised
  • They tested the same strings on that implementation

    The code they were looking at was used for writing the table, but they were testing the one that read it (which is instead correct).

    though judging by the recent comments someone’s found something.

    Yeah that's me :)The translation using an associated const also works when the const block uses generic parameters. For example:

    fn require_zst<T>() {
        const { assert!(std::mem::size_of::<T>() == 0) }
    }
    

    This can be written as:

    fn require_zst<T>() {
        struct Foo<T>(PhantomData<T>);
        impl<T> Foo<T> {
            const FOO: () = assert!(std::mem::size_of::<T>() == 0);
        }
        Foo::<T>::FOO
    }
    

    However it cannot be written as:

    fn require_zst<T>() {
        const FOO: () = assert!(std::mem::size_of::<T>() == 0);
        FOO
    }
    

    Because const FOO: () is an item, thus it is only lexically scoped (i.e. visible) inside require_zst, but does not inherit its generics (thus it cannot use T).

  • Pretty critical PR for rust-msi is getting held up because the maintainer understands the intent but not why this works
  • They tested the same strings on that implementation

    The strings were the same, but not the implementation. They were testing the decoding of the strings, but the C function they were looking at was the one for encoding them. The decoding function was correct but what it read didn't match the encoding one.

    though judging by the recent comments someone’s found something.

    Yeah, that's me :)

  • Critical 'BatBadBut' Rust Vulnerability Exposes Windows Systems to Attacks
  • Because Rust is not the only language that made this faulty assumption. It is an issue that affects Rust's stdlib, just like it is an issue that affects Python's stdlib and other libraries. In fact this was first reported as a vulnerability to yt-dlp (where it was actually exploitable) and then discovered it applied to many other libraries (where the exploitability is highly dependent on how the feature is used).

    Rust here is only used as clickbait because of its aim to be "safe", but its position is no different from other languages.

    If you read the article from the researcher that discovered the vulnerability you'll see they never call out Rust in particular, only as part of a list of languages that are affected. https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/