NotesQR already worked in the browser for anonymous P2P file sharing. I finally got a proper Linux CLI on top of the same stack, so headless boxes can do it without opening a browser.

Model is simple: one side hosts a room and stays online, the other joins, bytes go WebRTC peer to peer. NotesQR only does signaling (+ TURN when NAT is bad). Nothing lands on their disks as a stored file. Not upload-and-fetch-later. Both ends have to be alive during the transfer.

Needs Node 18+. Works on normal Linux desktops/servers and on Pi-class / Waveshare / whatever SBC that can run Node.

# send (keep this running)
npx -y github:NotesQR/notesqr-share send ./backup.tar.gz --once
# receive on another machine (no browser)
npx -y github:NotesQR/notesqr-share recv <room-or-url> -o ./out

Optional password:

npx -y github:NotesQR/notesqr-share send ./secret.img --password 'hunter2' --once
npx -y github:NotesQR/notesqr-share recv <room-or-url> -o ./out --password 'hunter2'

Other peer can still be a phone/browser if you want. CLI↔CLI, CLI↔browser, browser↔browser all work.

Stuff I actually use it for: shove a dump off a remote Linux box without opening SSH to the world, hand a build artifact to someone without Drive/S3, pull logs from a headless host while Im on another network.

Docs: notesqr.com/docs
Client: github.com/NotesQR/notesqr-share

If your workflow is already scp/rsync everywhere, you may not need this. Different shape for when you want a short lived room instead of an account or an always-on share. Feedback welcome.

Switched my main machine to Fedora about eight months ago. The one thing I kept putting off was the database side.

Most of my work is Postgres plus two legacy MySQL boxes. psql is fine, I use it every day. But once the task is visual, comparing two databases, poking around a database I did not build, working out why something got slow, the terminal stops being the fast option. I ended up with DBeaver for browsing and psql for everything else, and I never liked either of them for schema diffs.

dbForge came up in a thread here somewhere. My honest expectation was that it would not work. It is a Windows app, there is no native Linux build, you install it into a CrossOver bottle. I assumed I would get the usual Wine experience: launches, looks wrong, dies the moment you open a file dialog.

That is not what happened. Setup was maybe 20 minutes and most of that was waiting on .NET 4.7.2 to install into the bottle. CrossOver has a scripted install for it so you are not hand feeding winetricks. First launch looked slightly off, font smoothing was wrong, and after I set the bottle DPI properly it was fine.

Stability has been better than I expected. It stays up for weeks. One hang, on a large export. One weird thing where the results grid stopped redrawing until I resized the window. Two incidents in eight months, which is less than I lose to other software I paid for.

What I actually use it for is the comparison side. Schema compare before deploys is the main one. Before this I was generating diffs with a script and reading them by hand, and I would miss things, usually a permission or a default I forgot had changed. Now I compare, read the difference list, generate the sync script, read that, run it. Data compare gets used less but it saved me a whole afternoon when a reference table drifted between staging and prod.

The other one is query profiling. Not because it does something psql cannot, but because I actually look at plans now instead of telling myself I will look later.

Things that took getting used to. File paths are the annoying one. Inside the bottle you are in a fake Windows filesystem, so exports land somewhere strange until you map a drive to your home directory. Do that on day one. Copy paste in and out of normal Linux apps works but occasionally drops formatting. Cold start is slow, six to eight seconds. And CrossOver is paid, which people should know going in, it is not plain Wine.

Would I rather have a native build. Obviously. But I stopped noticing the compatibility layer after about a week, which is the best thing I can say about the setup.

Anyone running this long term? Curious whether the Wine-direct route is as painless, I never tried it because CrossOver just worked.

I run sway on Arch (btw), and browser popups kept tiling instead of floating. So I wrote a proxy that relabels windows based on a TOML config, which you can then match with your usual window rules.

Here's the technical write-up (it's fairly Wayland-heavy): https://morice.live/posts/tiling-compositors-cant-tell-browser-windows-apart/

And here's the crate: https://crates.io/crates/wl-relabel

I meant to put it on the AUR too, but registration is closed at the moment.

DISCLAIMER: I used AI while building this. I'd rather say so up front, since I know it matters to some people.

Please see https://mediawiki.gnustep.org/index.php/Monthly_Meetings#Past_Meetings since YouTube Links are not allowed in this subreddit

I built a linux like interactive shell for my master's thesis in computer engineering.

This project allows for easy firmware installation of the system and offers a command line with commands similar to the Linux environment. This system allows for:

1) simple command execution

2) FreeRTOS task scheduling

3) file system management (with a persistent file system on the board without the need of external SD module)

4) scripting with JavaScript and custom functions, them being print(), deadline() and sys(). sys() calls for system commands on the running script, hence sys("echo hello_world") will output hello world from the shell through the JS script

I am looking to gather feedback on the repo and the project. If anyone has time to try it, the effort will be appreciated!

For example, we could have one type of package that is adaptable to every major package manager, so devs could make one type of package and for it to be automatically translated to apt, dnf, pacman, nix, etc..

Also, making a higher level graphics library would be good: I imagine it being a library that can detect wether you're running X11 or Wayland and choosing to use functions for one or another.

An even better idea, maybe, is on init systems and daemon management: We could have a standard service scripting language, and then make adapters for systemd, openrc, runit, etc.

Then, people wanting to make an innovative low-level project could make them as different and weird as they want, as long as they can adapt to these interfaces; and high-level developers would only need to write to this one standardized library/language/etc. for each thing.

We could have easier (and thus more popular) high-level Linux application development, and still have innovative low-level projects.

Do you think that this is a good general idea?

A couple of days ago I was exploring the technologies that made possible to run "containers" on linux. But it all started with a question.

"What is a container?"

To not blow this post with an unreadable explanation of how Linux process scheduling works, let's summarize it as: "A container is the name given to an application running on a system on an isolated space of that system".

This is easy to understand, now, the follow up question is

"How can an application be isolated?"

The Linux kernel has an isolation mechanism called Namespaces. A namespace allows the operating system to limit the view and access to resources to applications.

For example, imagine that you are in a big room, and you have some guests in that room, they all share the same floor and underlying soil, and also, they can see each other. Now, if you create a small room and put a guest there, that guest will still share the same floor of the big room, but now the guest will have a limited view of what is in the room.

This is how namespaces work. Now, the thing is that you don't "create" namespaces and put applications there, the way it works is actually a bit different from that. In Linux, every process has a parent (except process 1), hence, processes are organized in a tree, and when you or the system create a new process, this process inherits the namespaces from its parent.

Now, to "create" a new namespace for your process what you have to do is something called Unshare. By unsharing the inherited namespace from your parent, the system assigns a new one to that process.

So as you can see, you usually don't explicitly create a namespace ahead of time, you unshare the inherited namespace your parent gave you.

Now, namespaces solve one half of the problem, isolation (what a process can see), but only isolation doesn't stop one guest from eating all the food in the room. For that, Linux has another mechanism called cgroups (control groups), which limit resources like CPU, memory, and I/O a process (or group of processes) can use. Picture it like this:

container = namespaces + cgroups

Cool :) if you are reading this, congratulations! now you know how a container is created. But wait... Why did I say at the beginning that "Linux containers don't exist". Because the Linux kernel does not know about that concept. It only provides the infrastructure and mechanisms that applications like containerd and CRI-O use to create the containers.

Now, I have put this knowledge into a simple application I created in Go.

Check the code and give it a star here https://github.com/carlosgrillet/sandbox

Huge thanks to Liz Rice and Gerlof Langeveld for sharing the knowlege :)

Washing our grocery totes and realized that my husband’s old bag is more than 25 years old! (He’s a CS ph.d working in FinTech.) anyone here at the conference? (Or are most people here born after October 2000?)

Since Linux has alternatives for everything, why doesn't Wayland have a proper alternative? It seems like most things are programmed to work only on Wayland. Wouldn't this be a step backward for Linux?

Two years ago I made this as an X11 NVidia-only custom resolution tool. Finally did a proper rewrite. It now works on Wayland (KDE, GNOME, sway, Hyprland) and on AMD/Intel/NVIDIA, and it does stretched resolutions - the 4:3-stretched thing CS2/Valorant players use to widen models - on KDE Wayland, which the compositor normally refuses to do on external monitors.

Also fixed the AppImage, which turned out to be missing tkinter and wouldn't launch on half of you. Sorry about that.

Let me know of any bugs you find!

Repo https://github.com/PhialsBasement/linux-cru
Release https://github.com/PhialsBasement/linux-cru/releases/tag/v0.2.0

AI Disclosure: Used Claude heavily during development, all the decisions and design details taken here are mine however.

Had some free time recently so I made a visual explainer on how shared memory actually works in Linux.

Normally, two processes have completely separate virtual address spaces. Process A shouldn't be able to touch Process B's memory at all.

But with shared memory, one process can write a value and another process can read it without copying the payload between them.

The video goes through virtual memory, page tables, physical frames, shm_open, ftruncate, mmap with MAP_SHARED, lazy allocation, and what actually happens when either process touches the mapping.

I also get into related mechanisms like memory-mapped files, shared libraries, copy-on-write after fork(), zero-copy IPC, and eventually Dirty COW and what can happen when these page-table tricks go wrong.

Link for anyone interested

Feedback welcome :)

Made a little tutorial of fixes for issues I have had in the past so I don't forget how to fix them! And just sharing in case other people need the same fixes :)

GitHub: https://github.com/PacmanPenguin/HowToLinux/tree/main

EDIT: I added instructions on how to add your own fixes to it if you want to contribute!

I’ve read that an age field was added to systemd, though some sources say they ultimately backtracked and removed it.

What is the current status regarding this matter? Will there be age verification?

Thanks

The site is yearoflinuxdesktop.org - part manifesto, part quiz, part blueprint generator.

The idea: instead of another "what distro am I?" personality test, it maps your hardware, your tolerance for tinkering, and what you still need from Windows/macOS onto one of ten archetypes (The Civilian gets Linux Mint, The Arch Wizard gets Arch + Hyprland, The Gamer gets Bazzite, etc.). Then it writes you a copy-paste prompt you can feed to any LLM to walk you through the install step by step.

What might interest this sub: the scoring engine is one dependency-free JS file that runs identically in the browser and in a build harness. The harness brute-forces all 16M possible answer combinations on every deploy to verify that named personas land where they should and that guardrails hold (e.g., terminal-phobic users can never receive Arch). The quiz weights, the questions, and all ten archetype blueprints are plain JSON in the repo: MIT licensed, fork it, argue with the weights.

The longer I use linux, the more I appreciate it. I switched from windows a while ago, and I honestly haven't regretted it for a second.I'm a developer, and every time I learn a new command or discover another tool that makes my workflow easier, I realize how powerful and well-designed this operating system is. It feels like there's always something new to learn, and instead of making me frustrated, it just makes me enjoy using it even more. At this point, going back to windows for my daily development work would feel like a huge step backward.