linux VS winapps

What is the source of “Firefox Moves to GitHub”? It could just be a mirror, just like Linux also has an official mirror on GitHub.

https://github.com/torvalds/linux

It's basically the same in the x86 world : your bios is customised to the board

The sad part is that on ARM the kernel is usually also custom compiled for the board.

If you go and look in https://github.com/torvalds/linux/tree/master/arch/arm you see a zillion "mach-xxx" directories for different SoC architectures, even if they all use Arm.

Device-tree is a partial solution, but no-one seems to have an incentive to finish the job and let a single image run on any (sufficiently recent) arm board. It's difficult for the community to fix because most people have only their own board. Someone would need to pay for a CI rig with every board, and some kernel devs to do the work of building a single kernel to run across everything.

Linux is a open source OS Kernel Unix based created by Linus Torvals in 1997 and released on GitHub and this OS turn so popular because is 100% free to download, make your own OS called Distro(Distribution or Linux Distribution) and every Distro are ruled to be Free and a lot of Linux based Distros was make, the most popular is :

This is even reflected in the ELF format itself. There's this really arcane dichotomy between sections and segments.

Sections are very detailed metadata that all sorts of things use for all sorts of purposes. Compilers use them. Debuggers use them. Static and dynamic linkers use them. Anyone can use them for any purpose whatsoever. You can easily add your own custom sections to any executable using tools like objcopy. It's completely arbitrary, held together by convention.

Segments, on the other hand, don't even have names. They are just a list of file extents required for the program to actually execute and their address space locations. The program header table is essentially a sorted list of arguments for the mmap system call.

This is Linux kernel's ELF loader:

https://github.com/torvalds/linux/blob/master/fs/binfmt_elf....

It basically just mmaps in all of the PT_LOAD segments of the ELF file, copies stuff like arguments and environment and then starts a thread at the entry point specified in the ELF header.

It's just that when loading dynamic ELFs it jumps into the dynamic linker, not the actual program. It's as though every single program had a #!/lib64/ld-linux-x86-64.so.2 shebang line. The absolute path is even hardcoded into the executable itself.

  readelf -a $(which cat) | grep -i interpreter

Yeah same, we maintain some eBPF probes spanning 4.11 to latest kernel, and holy hell, it's really bad. The worst offender being some old RedHat kernels with half-baked backports of the eBPF features containing a bunch of weird bugs or features that aren't perfectly in line with what's used in mainline...

Here's a fun bug we recently had: we had to ban substractions in our program (replacing them with an __asm__ macro) because of a bug in linux kernel 5.7.0 to 5.10.10, which had the (indirect) impact of not properly tracking the valid min/max values in the verifier[0]. The worst part is, it didn't cause the verifier to reject our program outright - instead, it used that information to optimize out some branches it thought were never reachable, making for some really wonky to debug situation where the program was running an impossible control-flow[1], resulting in it returning garbage to user-space.

All this to say, CORE is really only half the problem. Supporting every kernel in existance is still a huge effort. Still worth it compared to the alternative of writing a linux kernel driver though!

[0]: https://github.com/torvalds/linux/commit/bc895e8b2a64e502fbb...

[1]: https://github.com/torvalds/linux/blob/bc895e8b2a64e502fbba7...

I built a fast tree builder for any public GitHub repo via the linux shell.

`gitterbugs` (gbgs) clones, analyzes and renders a beautiful, readable and size-annotated tree of any GitHub repository in seconds.

For example, `gbgs https://github.com/torvalds/linux` produces:

```

> Anyone has seen his position on this topic?

Well, he's not a fan of GitHub pull request as per the last decade.

https://github.com/torvalds/linux/pull/17#issuecomment-56546...

Might not.

Rust has a state of the art sort implementation. There’s nothing faster, in any language - https://github.com/rust-lang/rust/pull/124032.

And sure, it’s possible that someone could write a C program that compares in speed to all the Rust programs I’ve mentioned. C is a Turing complete language after all. I’m only pointing out that it hasn’t happened in practice.

Also check the Android Binder code before (C https://github.com/torvalds/linux/blob/master/drivers/androi...) and after (Rust - https://android.googlesource.com/platform/frameworks/native/...). Same speed but the quality difference, it’s incomparable.

> I wonder if Linux is re-written i(n) (sic) rust will it too remove GPL as a factor ?

No reason it must? AFAIK all Rust for Linux code is GPL2. For example see: https://github.com/torvalds/linux/blob/master/rust/kernel/al...

If some was or were to be licensed as MIT code, there is also plenty of dual licensed code in the Linux kernel.

> Where is the reverse WSL on Linux, where Windows is deeply embedded and you have all the Windows features in your hands?

https://github.com/Fmstrat/winapps

Enjoy.

This one might be controversial, but Winapps for Linux, app that lets run apps from within a Windows KVM as if it were native on your Linux system (https://github.com/Fmstrat/winapps)

Yes but you have to run visual studios in a windows virtual machine qemu/kvm/virtmanager Then pass virtual studio window to your desktop so it runs like it is native https://github.com/Fmstrat/winapps optional Then use winapps to make a desktop and application launcher menu entry/icon

There's something called winapps which works over RDP, but you better have good specs so you get good performance. I recommend using parsec with a VM if you can passthrough a seperate GPU otherwise. https://github.com/Fmstrat/winapps

The aim of this exercise was to test run WinApps (https://github.com/Fmstrat/winapps).