Nheko Alternatives

nheko reviews and mentions

• This Year in Matrix
  6 projects | news.ycombinator.com | 25 Dec 2022

  Nheko has been around for a number of years. Never used it myself though.

  https://github.com/Nheko-Reborn/nheko

• Matrix was worth the effort to self host.
  8 projects | reddit.com/r/selfhosted | 18 Sep 2022

  Matrix clients hit different than pretty much any other chat client I've use before. Theres multiple clients I've found like nheko, moments, element that are a pleasure to look at and smooth as hell. Even better you can have users use web services like Element Web to sign-up and chat. Its sick.

• What flatpaks are "official" (i.e., directly from the application's developer)?
  5 projects | reddit.com/r/linux | 3 May 2022

  The Nheko flatpak is official. Just compare the source to the nightlies we build and upload to our nightly repo.

• GTK4 Matrix Client
  6 projects | news.ycombinator.com | 10 Apr 2022

  Like almost every client out there it has no support for e2ee. I was happy to find https://nheko-reborn.github.io (I'm a KDE user so Qt apps are preferred).

• Mozilla Thunderbird Beta now supports Matrix chat
  5 projects | news.ycombinator.com | 8 Apr 2022
• Using Files with Browsers, in Reality
  3 projects | news.ycombinator.com | 21 Mar 2022

  I probably wouldn't have guessed that `e.dataTransfer.items` gets cleared at the first await (since I'm not a proficient web developer), but I would've been extremely wary of this code in general. Additionally (not tied to async-await but race conditions in general), is `item.getAsFileSystemHandle()` a TOCTTOU vulnerability where the type of an item can change between folders and files and symlinks etc., while this code is running?

  Rust's & vs. &mut system largely eliminates shared state hazards in both threading and asynchronity (&mut is exclusive/unaliased and can't be mutated by other threads or event loop jobs, and & is difficult and unidiomatic to mutate), though it doesn't solve async cancellation errors (https://carllerche.com/2021/06/17/six-ways-to-make-async-rus..., discussed at https://news.ycombinator.com/item?id=27542504), or filesystem TOCTTOU (https://blog.rust-lang.org/2022/01/20/cve-2022-21658.html as well as user code).

  Qt event loop reentrancy is fun(tm) as well. It looks like a blocking call, but spawns a nested event loop which can do anything (but rarely enough to lull you into a false sense of complacency), resulting in segfaults like https://github.com/Nheko-Reborn/nheko/issues/656 (workaround at https://github.com/Nheko-Reborn/nheko/commit/570d00b000bd558..., I didn't look into it). And Qt lacks "easy" await syntax and a framework based on calling red functions (though I didn't look into C++20 coroutines yet, perhaps https://www.qt.io/blog/asynchronous-apis-in-qt-6 or https://github.com/mhogomchungu/tasks or https://blog.blackquill.cc/asynchronous-qtquick-uis-and-thei...?).

• Introducing Native Matrix VoIP with Element Call!
  5 projects | reddit.com/r/linux | 5 Mar 2022
• How a Single Line of Code Made a 24-Core Server Slower Than a Laptop
  4 projects | news.ycombinator.com | 31 Dec 2021

  > So forcing everyone to think about ownership because maybe they are writing concurrent code (then again maybe they aren't) so that "congrats your memory management problems are solved" seems like a Pyrrhic victory--you've already blown their brain cells on the wrong problem.

  https://manishearth.github.io/blog/2015/05/17/the-problem-wi... argues that "[a]liasing with mutability in a sufficiently complex, single-threaded program is effectively the same thing as accessing data shared across multiple threads without a lock". This is especially true in Qt apps which launch nested event loops, which can do anything and mutate data behind your back, and C++ turns it into use-after-free UB and crashing (https://github.com/Nheko-Reborn/nheko/issues/656, https://github.com/Nheko-Reborn/nheko/commit/570d00b000bd558...). I find Rust code easier to reason about than C++, since I know that unrelated function calls will never modify the target of a &mut T, and can only change the target of a &T if T has interior mutability.

  Nonetheless the increased complexity of Rust is a definite downside for simple/CRUD application code.

  On the other hand, when a programmer does write concurrent code with shared mutability (in any language), in my experience, the only way they'll write correct and understandable code is if they've either learned Rust, or were tutored by someone at the skill level of a Solaris kernel architect. And learning Rust is infinitely more scalable.

  Rust taught me to make concurrency tractable in C++. In Rust, it's standard practice to designate each piece of data as single-threaded, shared but immutable, atomic, or protected by a mutex, and separate single-threaded data and shared data into separate structs. The average C++ programmer who hasn't studied Rust (eg. the developers behind FamiTracker, BambooTracker, RtAudio, and RSS Guard) will write wrong and incomprehensible threading code which mixes atomic fields, data-raced fields, and accessing fields while holding a mutex, sometimes only holding a mutex on the writer but not reader, sometimes switching back and forth between these modes ad-hoc. Sometimes it only races on integer/flag fields and works most of the time on x86 (FamiTracker, BambooTracker, RtAudio), and sometimes it crashes due to a data race on collections (https://github.com/martinrotter/rssguard/issues/362).

• Update on beta testing payments in Signal
  8 projects | news.ycombinator.com | 13 Apr 2021
• First Look: ‘Spot’ is a Native Spotify App for Linux, Built in GTK & Rust
  5 projects | reddit.com/r/linux | 22 Feb 2021

  I'm keeping an eye on Nheko in part because Electron is so bad.

• A note from our sponsor - InfluxDB
  www.influxdata.com | 29 Jan 2023

  InfluxDB is the Time Series Platform where developers build real-time applications for analytics, IoT and cloud-native services. Easy to start, it is available in the cloud or on-premises. Learn more →