I top linked the most recently published video mostly for the introductory breakdown in ternary logic equivalence, but the interview with the ternary researcher, Dr Bos, also linked in the description above includes a number of corrections and accurate description of the subject.

Yeah, definitely not a lost art or anything, as physical ternary signals already have applications in communication like high data rate interfaces. Still, would be interesting to see ternary expand into logic domains with emerging developments in TCMOS research.

Appreciate the heads up. Looks like they use merge bots to auto update the package version JSON files for git packages, making for a very large/frequent commit history. Was that what made bisecting imposable?

I also see they pin the nixpkgs input, but do others normally modify that nixpkgs input to follow their global nixpkgs from their own system flake, or does that invalidate the use of Nyx community cache?

Compiling the Linux kernel from scratch takes over an hour on this laptop. Given I’m tracking the unstable channel on a rolling distro means doing that several times a week. Ain’t nobody got time for that. Or at least I don’t…

I don’t have resources to locally build an optimized kennel for every update for each of my systems, thus my interests in keeping with a community cache.

I didn’t do much here, just swapped the kernel via config and ran some benchmarks. I posted as I was more curious to hear of what engineering trade offs may be at play, and what experience folks have had in daily driving CatchyOS’s kernel patch sets.

I wasn’t sure if these results were specific to my older hardware, or more generalizable to newer systems.

Appreciate the detailed context, and thank you for your work!

It’s a great video, and I hope the author is able to publish more nix content like this again soon. We’ll just have to watch their blog’s RSS feed in the meantime.

• https://surma.dev/things/nix-explained/

Whoops, I misread scheme as schema. That’s really powerful. One thing I wish I could reliably do with a Nix LSP is navigate to a definition of a symbol.

I haven’t dug into Guix yet, so is the config more of a markup and less of Turing complete language? That sounds like it’d be easier to grock or optimize an LSP for.

I have heard that Guix takes a stronger stance with respect to unfree software. I don’t think any of the official nix Hydra infrastructures build for unfree packages, but they are packaged and indexed into nixpkgs. Has Guix been difficult at all in that regard, i.e. using proprietary drivers or closed libraries for work or personal hardware?

Well let me at least leave why I think Nix is not it at the moment:

• Software Center - browsing search.nixos.org isn’t quite the same in terms low friction and discoverability
  • You already have to know what you’re looking for, and it can’t make system config on your behalf
  • Debian or conventional package managers usually offer a native GUI for package selection and deployment
• System Defaults - the minimality of a basic default install can cause a lot of papercuts
  • the default boot partition is rather small given the OS’s prepecity to add new kernels with new generations
  • and without any garbage collection service enabled by default, user first encounter switch failures due to this
• External Binaries Compatibility - Linux also suffers from this in general as compared to MacOS or Windows
  • in addition to being much more niche, reuse of existing binaries from more prevalent distros becomes complicated
  • the desktop ISO could suggest a nix-ld config with default libs most binary distributes expect, easing in new users
• The Nix language - much more complex than conventional cong markup langs, being more of a turing complete DSL
  • partial working LSP impare introspection while writing, and the runtime error messages are poorly formatted
  • most desktop users (in debian or fedora) have little need to learn their OS’s packaging schemas, but NixOS users do

What are we doing here? This isn’t even an argument.

Correct, this isn’t an argument, or at least I’m not trying to argue.
All I wanted to learn what exact properties you though makes for a better desktop OS.

I’m in agreement that NixOS isn’t the best for mainstream desktop user base, but like any decent inquiry or survey, if I just preemptively bias someone’s responses with my own observations on NixOS defecenties, then there wouldn’t be as much of a case to before ask what they think other Linux Distro do better in the first place.

Not everyone who strikes up a convo online for a debate, and not all (but quite a few) who ask questions are trolls.

It’s a slippery slope, to be sure.

It doesn’t matter, because Nix isn’t built for it. That’s not it’s purpose or what it’s best at.

I was asking more about linux distros other than NixOS.

They all offer a better desktop experience because they are tuned with their packages and experience.

• Would you say it’s a front end aspect? If user driven system changes were as simple as using a Software Center UI?
• A similar [desktop] experience sounds relative, what the comparison? Windows, MacOS, <Not Fedora> linux?

Not great for an uncontrolled user experience.

• Interesting. What linux distros are optimal for that use case?
  • Specifically what properties of those distros make them ideal?

Some poignant questions for these new platform requirements:

• How do you anticipate this being used against journalists and advocacy groups?
• What research and statistical quantification will be done to evaluate the amount of harm these restrictions can inflict?
• What precautions or safeguards will users have against malicious state actors or capitulating corporations?
• How can developers protect themselves from liable damages due to service interruptions caused by third party verification?
• Do you foresee legal restrictions in rollout due to national security concerns from differing nation states?

I’ve really enjoyed using Kokoro for generating audiobooks:

• https://github.com/hexgrad/kokoro
• https://huggingface.co/spaces/webml-community/kokoro-webgpu

Be sure to first try using this convenient API wrapper:

• https://github.com/remsky/Kokoro-FastAPI

Note that not all the modelled voices in Kokoro-82M are of equal quality, given disparities in limited training data from reference speakers. However, what’s cool is that you can prescribe polynomial weights to multiple voices tags, enabling you to synthesize different variants weighted more heavily from the highest quality voices.

• https://huggingface.co/hexgrad/Kokoro-82M
• https://huggingface.co/hexgrad/Kokoro-82M/blob/main/VOICES.md#american-english

One current limitation for Kokoro is that there’s no way to prescribe emotion or intonation procedurally using markup tags like SSML in the source text, unlike other models like Orpheus. But Orpheus sometimes generate weird hallucinations like repeating sentences, injecting new phrases, appending radio silence or filter words, and generally increasing the tempo of words per minute as a sentence progresses. Still, this may be of interest if you want to add emotion like fear or urgency to your generated dispatches, and manage to tune the input temperature you want for the model.

• https://github.com/canopyai/Orpheus-TTS
• https://github.com/hexgrad/kokoro/issues/36

However, Kokoro is a lot more compute efficient and audibly consistent, requiring less scrutiny or manual supervision. The author behind Kokoro now also looks to be working towards an emotional variant as well:

• https://huggingface.co/posts/hexgrad/182254197987426

Reference project I’ve been following for audiobook generation:

• https://github.com/prakharsr/audiobook-creator

Ah, that’s a shame. Thanks for the context though.

I did feel a little bit of that slight dismissal or elitism from the thread I linked above about the graphical installer ISO. Although I think the relative surge of new users after graphical ISO’s implementation did end up changing some minds on the merit of its continual development.

It seems like some tools just never fully realize their potential market demand until they’re finally implemented and consequently adopted. Quite the catch 22.

I also wonder if it’s a bit of a motivational aspect for individual contributors, as in demand with mostly originate from novice users who’ve yet to master the Nix language, yet by the time one’s gained enough experience to contribute to Snowflake OS, you’ve kind of grown out of outgrow the need for it. That kind of reflects my personal interests around graphical programming, as I became more familiar with various languages, my inkling for a graphical representation of control flow gradually waned.

Still, I think lowering the barrier to adoption is in the long run best serves the community and in sustaining new contributors. Sort of like the conventional Greek proverb:

A society grows great when old men plant trees whose shade they know they shall never sit in.

Nix can create attribute sets from JSON, so there isn’t a need to generate nix code.

Is there a good way of mixing and mashing JSON attribute sets with conventional nix config files? Perhaps relegating some config to machine-generated JSON, and some hand crafted configs?

Oh, I see. Looks like one can use this method to create custom forks of downstream images such as Bazzite:

https://docs.bazzite.gg/Advanced/creating_custom_image/

As a prior proponent of graphical programming interfaces, I’ve been thinking there’d be a good use case for a GUI based control panel for NixOS, something that could transcompile standard user selected options down to a nix config that could be abstract of the way from most users, like any sort of game save file.

Given all options and packages in nixpkgs are already machine readable and indexed, supplying a GUI based tool to procedurally generate nix codes doesn’t at first seem initially daunting, but given the past discussions around this idea perhaps proves it to be on the contrary:

• https://discourse.nixos.org/t/is-anyone-working-on-a-gui-tool-to-manage-packages/5540
• https://discourse.nixos.org/t/wondering-about-nix/32919/5
• https://github.com/nix-gui/nix-gui
• https://discourse.nixos.org/t/negativity-around-the-graphical-installer/67646/12

Although SnowflakeOS in particular looks promising:

SnowflakeOS Simple, Immutable, Reproducible SnowflakeOS is a NixOS based Linux distribution focused on beginner friendliness and ease of use.

https://snowflakeos.org/

Oh, neat! Is this the project you’re referring to?

• https://universal-blue.org/

Looks like Bazzite is listed as an example derivative image. I’ve heard good things about that OS from newer Linux users’ perspectives. But is ublue something an individual user could personally customize, or more like something a development team or community project would build up from?

The landing page referencing layers and the Open Container Initiative, so is this more like a bootable container using overlay file system drivers?

One attraction I appreciate with Nix is the ability to overlay or overload default software options from base packages, without having to repeat/redefine everything else upstream, e.g. enabling Nvidia support for btop to visualize GPU utilization via a simple cuda flag. Replicating lazy-level-evaluation with something buildkit ARGs would be hectic, so do they have their own Dockerfile/Containerfile DSL?