I thought I understood Linux until now...
Posted by Fragrant_Pianist_647@reddit | linux | View on Reddit | 106 comments
For the longest time, I thought Linux was the back-end, and the distro was the front-end, but now I hear of several different desktop environments.
I also noticed that Arch boots into the tty instead of a user interface, and you have to install a desktop environment to have that interface.
So my question is, what's the difference?
AppropriateOven5470@reddit
I guess it should be mentioned that in addition to what others have said, the kernel is also the one providing users, groups, security and permissions.
PraetorRU@reddit
Linux is a kernel, the piece of software that talks to hardware directly and creates an abstraction for any other software to work.
Distro is an opinionated collection of software projects (apps) added to a linux kernel to form an operating system.
Desktop environment is a collection of software that usually provides a graphical user interface and some number of utilities like file manager, picture viewer etc.
Unknown_Lifeform1104@reddit
This is literally the most concise, efficient and concise explanation of Linux I have ever seen, thank you very much!
metal-eater@reddit
That is kind of just the explanation of what an operating system is in general. That describes Windows and MacOS as much as it does Linux, it's just that those two have everything much more locked down by design.
TheWorldIsNotOkay@reddit
The difference is that with Windows and MacOS, there's only one "distro" for each, and basically only the one desktop environment provided by that distro.
So someone coming from either of those world might reasonably have some difficulty understanding idea that an operating system might be offered from multiple different sources and be bundled with multiple different desktop environments. For the vast majority of Windows and MacOS users, the OS is only available from one source, and the desktop environment is part of the OS.
aj9393@reddit
There's something kind of funny and ironic about you using the word "concise" twice.
Time_Transition_421@reddit
That memo came right from the Department of Redundancy Department
Unknown_Lifeform1104@reddit
English trad lol
Fragrant_Pianist_647@reddit (OP)
Ahh, so:
Linux Kernel = Back-end
Distro = Package of a bunch of stuff (some don't come pre-installed with a desktop environment, e.g., Arch)
and among the things the distro comes with are:
Desktop Environment
Software
Drivers
etc.
jerrydberry@reddit
Try to think out of web dev box...
Web dev has so many things wrong, not a good stencil to see other things through.
Intelligent_Dinner66@reddit
What? Don't you like frameworks and major libraries being released every year? 😂
jerrydberry@reddit
One thing that is enough for me to hate web dev is that when web dev needed a scripting language they chose/created that abomination called JS. It is the absolute evil and it looks like there is no way to change it to anything reasonable since it is everywhere now.
Fragrant_Pianist_647@reddit (OP)
And...how is it an abomination? Im not saying its great or anything, you just didnt provide a reason.
jerrydberry@reddit
Equality with implicit type conversions on its own just does not make sense
DazzlingAd4254@reddit
I wonder if that is enough reason to call JS an 'abomination'. If I understand correctly--- I might not--- doesn't python, php, and others, also perfom implicit type conversion?
jerrydberry@reddit
I do not know about php (was sure it was not used by anybody already), but python never converted strings to numbers implicitly.
The existence of questions like this immediately indicated for me that I'll do my best to minimize my professional exposure to this language. It is just awful.
DazzlingAd4254@reddit
You are right. However, I wonder what anyone's expectation was when they did '2'+'2'-'2'. Subtraction must have some rules in JS, and if the rule is understood to be that operants are coerced to arithmetic types, then that's what we get, and we learn to work around such quirks. Baby and bathwater...
Fragrant_Pianist_647@reddit (OP)
I mean...if that's your only reason for hating it, then that's just ridiculous.
I dont even encounter too many situations where that becomes an issue.
jerrydberry@reddit
That was one of examples where language is not logical and error prone. I do not hate it, I just think it is bad. And I see that that web dev as industry picked up a really bad language to use everywhere. Many people do not even understand how bad it is because they did not program in other languages.
Fragrant_Pianist_647@reddit (OP)
I use it, along with lower-level, and other higher-level languages and its fine.
I also know a few people who started in other languages, then did JS and it was fine, although I understand some of the hate behind it.
Irverter@reddit
JS wasn't created because web dev needed a scripting language. JS was created because someone at netscape figured they could add a scripting engine to thh browser in less than a week and then it was shipped just to say "our browser has a scripting language and the competition doesnt!"
Fragrant_Pianist_647@reddit (OP)
Gotta love Netscape. Wish there was a way to try the browser in 2025 (just for fun).
belzaroth@reddit
There all here if you want to try.
https://archive.org/details/netscape-browser-collection
ukezi@reddit
Or supply chain attack because you just deploy a bit of software form some somewhere on the internet to all users.
ek00992@reddit
That’s what keeps us employed 😂
Fragrant_Pianist_647@reddit (OP)
Yeah, I apologize. When I say back-end, I mostly just mean the code that makes stuff work, and then front-end is an interface for the user to peek into, although i guess that's technically wrong in this case.
ventfulspirit@reddit
For linux the right wording will be kernel-space & user-space.
The kernel is the program that directly interacts with hardware and any process that needs this privilege to view kernel space is compiled with or loaded (kernel modules) everything on-top of that is userspace. Userspace programs mostly communicate with kernel via system calls.
As far as the kernel is concerned there isn’t much distinction between the desktop environment and your basic “Hello World” program.
Linux kernel simply has a predefined executable it runs when it ‘starts’ userspace. This is the ‘init’ program. You can make your own, but most linux distros use systemd init, which also launches a bunch of userspace services including the GUI. You could make that init a simple “Hello World” program and the kernel would still run it but thats not very useful lol.
GUI can be implemented in anyway, there are no standards per se some DE’s are basically embedded web applications Gnome & SteamOS gamescope running in a native webengine implemented in C++ while others are straight native programs using Qt(C++) like KDE plasma. At the end of the day they all need to make syscalls to tell the OS to do something, whether it’s using the gpu to draw something or writing to a file.
hi65435@reddit
Yes it's so to say the backend for the syscalls. But yeah, you deal with a lot of backends-for-frontends in that picture
The whole thing is composable and in some perspectives there's surely layering. Although the ultimate lego building block is the Unix philosophy, having the system consist of components where each is orthogonal to the others and does exactly one thing really well. However that's the ideal world anyway
daveysprockett@reddit
From a networking perspective, pretty much the first thing a packet will hit as it emerges from the ethernet device is the kernel (the kernel contains device drivers for a range of different bits of hardware). It only gets to what you might think of as the back end from a Web dev perspective after being processed to a greater or lesser extent by the kernel (ie the web server code, apache or whatever).
vyashole@reddit
Forget the back-end front-end analogy. That's for web apps.
In an OS, think of it as concentric rings. As in Kernel is the innermost ring, and your app is the outermost ring. A distro is a bundle that takes care of a few (or several) rings for you. The desktop environment ring may or may not be included in the distro rings.
vyashole@reddit
Calling Kernel the back end is not exactly appropriate.
Usually, when you move your mouse or hit a key on the keyboard, kernel is the very first thing that knows about it. So the web dev analogy of backend and frontend doesn't really apply here.
Kernel is almost always in charge of everything, not just the back end.
bob4apples@reddit
Perhaps you can think of the kernel as being like an engine. Most of the time the average person wants a car with a full dashboard, cabin and all the bells and whistles. Sometimes, you want a tractor with a minimal dashboard and sometimes you just need the motor to drive a generator so youhardly need any controls at all.
cgoldberg@reddit
Stop using the terms "back end" and "front end"... you are just going to confuse yourself (those are terms for software that runs with a user interface and also some server processes, which is not what you are talking about). If you want to make a distinction, use "kernel" and "userspace". Linux is a kernel. Distros include the kernel and a bunch of userspace programs that make up a useable operating system.
matorin57@reddit
Back-end isnt that useful of a term in this case. There isn’t a front-end back end split. The kernel is a special process that actually has control of the hardware. All other software (except notably drivers) interact with the kernel not the hardware.
Kriss3d@reddit
Not quite. The drivers are in the kernel.
The distro is all the programs you use. Network managers. Package managers. Desktop environment. Office programs. Browser.
Etc.
However if you want say mint but likes the xfce then nothing is stopping you from installing ans using that. You want a different network manager? Knock yourself out. Don't like the Libre office? Remove it and install something else.
With archinstaller its a small image you download and put on an USB and connect to the internet. From there it let's you install various DEs and browsers etc. It'll just install those from the internt as you select them.
TheOneTrueTrench@reddit
The kernel runs at the "highest" level of privilege, and talks directly to the hardware, this is called "Ring 0".
Everything else runs at a lower "normal" level of privilege called "user space", "userland", etc., and can only talk to other things in userland and to the kernel though what are called "system calls". This is all "Ring 3"
From your perspective, you've (almost certainly) never actually dealt with the kernel, you've never talked to the kernel, it's invisible to you. You probably only interacted with userland programs, which themselves may or may not interact with the kernel. (Most of them do, in some way, like opening/reading from/writing to files, opening network connections, that sort of thing)
You are likely aware of the root user, and think of it as having full access to the computer, but even that's not true, it just has the highest level of permissions in userspace. Compared to kernel-level permissions, that's nothing. A program running as root still doesn't have kernel-level access to things.
Caveats: There are actually even more "privileged rings" often referred to Ring -1, -2, -3, etc., but these are things like your VT-x and SVM hardware virtualization (-1), SMM (-2), and platform security (-3), but you are basically guaranteed to never care or deal with these even if you're a kernel developer, except in the most extreme of circumstances.
doc_willis@reddit
The term "backend" has specific meaning with computer software..
Calling the kernel the "foundation" of the "house" that is the OS , may be a slightly better analogy.
Drivers are often packages, but can also be included in the kernel .
vrsatillx@reddit
You now understand Linux
Astro_Avatar@reddit
yeah, intuitively that's right.
PraetorRU@reddit
Yes, that's pretty much it.
phylter99@reddit
Linux can be generically used as a term for the entire thing, but that can cause confusion.
SuAlfons@reddit
very good brief!
genius_retard@reddit
Linux = drivers
GNU = applications
Therefore GNU/Linux.
MaliciousProgrammer2@reddit
Linux is a monolithic kernel and is a hell of a lot more than just drivers.
thinking-rock@reddit
nah it's mostly just drivers. device drivers, filesystem drivers, network drivers, etc. other than that, it has process scheduling, some network stack stuff, filesystem models. but my lines of code it's mostly just drivers
MaliciousProgrammer2@reddit
I can’t tell if you’re joking, but you didn’t even mention Memory management. linux/mm directory has a ton of code, and Memory Management is a huge part of Linux.
Network stack and process scheduling are not small components. What about IRQ, eBPF, tracing? The network stack may seem like a small component (out of sight, out of mind), but I challenge you to implement some new protocol in Linux, you’re going to be writing a lot more than drivers.
The process scheduler is a pretty major component of a concurrent OS.
What about v facilities for working with hardware-enforced protection to provide isolation?
I’m not saying drivers aren’t a huge part of Linux, especially from a users prospective (like sys dev user), you will mostly crest drivers. But the Kernel itself is more than drivers. Drivers are provide the facilities for hardware and Kernel to communicate with each other. Commonly used drivers are included in the upstream Linux repo (along with a lot of other stuff), but the kernel, the Linux Kernel, is not drivers. They are separate.
thinking-rock@reddit
try writing a program using linux syscalls, e.g. a shell interpreter. thats a really good way of understanding what linux does for you
Sentreen@reddit
Compare it with buying a car: a car is a collection of a bunch of components (engine, dashboard, infotainment system, wheels, pedals, transmission, ...) all of which have to work together for you to be able to get in and drive.
abcpea1@reddit
Linux is the back end of the back end init is the front end of the back end coreutils is the back end of the front end shell is the front end of the front end display server is the bottom end of the top end desktop environment is the one end to rule them all distro is an n-dimensional object encompassing all ends
SouthEastSmith@reddit
Calling it the back-end is not correct and will conflict with more appropriate uses of that term.
You should think of it in terms of layers:
techsuppr0t@reddit
It should be noted that actions performed on a desktop environment are often just Shell commands hidden behind a more approachable mask the desktop. So when OP notices there's is a TTY below the desktop environment, that is also a false layer above what Linux real is.
SouthEastSmith@reddit
Shell commands do not require a tty. I think I get what you are saying, but tty is a specific thing: a device driver intended to maintain and "cook" a stream of text from a terminal or modem.
A tty is not a false layer, but rather an entry-point into the kernel.
To see the level of complexity available in a tty, go to a terminal window and type: stty -a (note: if you are using a graphical terminal, then its actually a pseudo-tty you are using)
Cold_Acanthaceae_436@reddit
Linux - kernel Gnu - userland, means your cd, ls, man everything is gnu userland, gcc compiler, glibc everything is gnu. Desktop environment - Gui on top of linux kernel+gnu userland.
If you want to compare it to ther is
Macos - XNU kernel + bsd userland + their own de
Bsd - full os, kernel + userland both bsd. Add open-source desktop environment you want.
Now in windows if you understand it any better, it's like NT kernel + System32 userland (can't compare it to linux due to diff architecture)
So distro is just clever packaging of this software, like assembling them together, some offer some exclusive stuff, some inhouse built stuff along with it.
SilentLennie@reddit
It's important to remember: with Linux you might have more choice so it's useful to know these things, but Mac and Windows have the same thing.
Older Windows had a win.ini setting for shell=some-program.exe for the computer and now it's a registry setting per account/user.
vyashole@reddit
Linux is the kernel. Colloquially, any whole operating system based on linux is also called Linux.
A distro is a bundle of software. It bundles the linux kernel, shell, package manager, and other packages you might need to operate your computer. Arch, Ubuntu, Fedora, RHEL, Debian, etc. are distros. Some distros may be based on others. E.g. Ubuntu is based on Debian, Manjaro is based on Arch, but you seldom need to worry about that as a beginner.
A distro may or may not come with a GUI. The server distros and minimal distros like Arch are often shipped without a GUI, and you're free to install any desktop or none at all.
A desktop environment is a collection of packages that gives you a GUI with a window manager and a set of default apps like text editors, terminal emulators, web browsers, etc.
You dont always NEED a desktop environment. A small number of advanced users use their own independent Window managers and their favourite apps without a desktop environment.
Gnome and KDE plasma are examples of desktop environment. For example both Ubuntu and fedora can come with different desktop environments and they let you download ISOs depending on what you want. On Arch, you may install any DE after the fact.
Finally, you dont need to worry about any of this as long as you choose a distro and DE, and it works for you. However, if you think playing around with these systems is fun, you're more than welcome to do so.
Particular_Wear_6960@reddit
Back in the day, you'd pick up a book and learn about this stuff. It was pretty neat! This is cool, but subject to a bunch of missinfo (and is REALLY superficial).
nix-solves-that-2317@reddit
have you tried nixos
baubleglue@reddit
There is much more under "desktop environment". You have services manager, all kind of other "managers" (desktop, network, etc), display server.
Dont_tase_me_bruh694@reddit
I'm surprised this hasnt veme removed. Questions are usually banned on this sub.
Glad to see wit survive.
Master-Rub-3404@reddit
Arch doesn’t boot into a TYY, it boots into whatever login manager/desktop environment you install and enable on boot. There’s no default. If there’s nothing graphical installed, it’ll boot into nothing graphical (ie. the TTY).
SmeltedFury@reddit
I'd just like to interject for a moment. What you're refering to as Linux, is in fact, GNU/Linux, or as I've recently taken to calling it, GNU plus Linux. Linux is not an operating system unto itself, but rather another free component of a fully functioning GNU system made useful by the GNU corelibs, shell utilities and vital system components comprising a full OS as defined by POSIX.
Many computer users run a modified version of the GNU system every day, without realizing it. Through a peculiar turn of events, the version of GNU which is widely used today is often called Linux, and many of its users are not aware that it is basically the GNU system, developed by the GNU Project.
There really is a Linux, and these people are using it, but it is just a part of the system they use. Linux is the kernel: the program in the system that allocates the machine's resources to the other programs that you run. The kernel is an essential part of an operating system, but useless by itself; it can only function in the context of a complete operating system. Linux is normally used in combination with the GNU operating system: the whole system is basically GNU with Linux added, or GNU/Linux. All the so-called Linux distributions are really distributions of GNU/Linux!
throwaway490215@reddit
For some more advanced trivia.
When Linux starts, it does so with a single program. PID 1. Everything else is indirectly started from there.
What does it mean to spawn? Nowadays, we think of executing programs, but it used to be you had to have a pretty deep understanding to correctly 'fork' a process. All a fork does is start a new process that has everything exactly the same as the old, except for 1 bit.
It's all rather hard to use correctly nowadays, being PID 1 requires you handle a bunch of edge cases of process management normal programs dont have to think about.
But you can see where they were coming from when it got designed: What is the simplest, most trivial API we can design that could be used to implement more complex things.
Starting 1 program that can fork itself gets you very far into "multi-process" land.
bruschghorn@reddit
Yep, you had it wrong. And to be honest, the vocabulary is a bit misleading.
Linux is the kernel. But one may also mean the whole OS when saying Linux. Some prefer to call it GNU/Linux, that is Linux kernel and GNU utilities and libraries. But not all distributions use GNU. And not all distributions use the Linux kernel (there was Debian/kFreeBSD, and there is now Debian/Hurd, I leave it to another discussion to decide if they qualify as "Linux").
That said, Linux, or GNU/Linux, is everything that allows you to start the system and run your programs. Including the graphical user interface.
Distributions differ in the init system (systemd on many distributions but not all), package management system (apt, dnf, pacman...), the set of packages and versions available, the version of the kernel, the way they are installed, licensing terms, etc. And the graphical interface as well, though you may usually choose among several GUI, for the same distribution.
For GUI, you have the base graphics subsystem, X11 (legacy) or Wayland, then a display manager, (DM) a window manager (WM), and possibly a desktop environment (DE). Some WM are design to run standalone, without a desktop (example: IceWM, which is almost a mini desktop). Among DE, you will find mainly Gnome, KDE, MATE, Xfce, Cinnamon, LXQt. Each comes with a set of default apps dor file management, text editing and others, but you can switch.
Gugalcrom123@reddit
Note: it is Control+Alt+F1-F8 when switching from a graphical TTY. Also, Wayland is not a software, so it is not a distro package, but an implementation of it is provided.
So either you provide X11 and a window manager for it, or you provide a compositor for Wayland which merges these two jobs.
atomic1fire@reddit
From what I could gather by eyeballing it.
The linux kernel serves as a layer between the hardware and software, but it's also responsible for launching the first program in the system, usually init or sh.
From there, a bunch of other subsystems can be set up to launch giving a full desktop or terminal enviroment, though you can also launch sh by itself on top of the kernel with a few basic programs.
Jolly-Warthog-1427@reddit
Think of it like an onion.
At the bottom you have hardware.
Next up is firmware living on this hardware (bios/uefi for your motherboard, the cpu and gpu and disk drives also all have firmware directly on them).
Now we have the bootloader. This is a mini program that configures the hardware, finds/loads the kernel into ram and hands access over to the kernel.
Next up is the kernel itself (Linux).
On top of the kernel you have user space (all applications running on top of the kernel again.
Notice how software gets more specialized but also get more direct access the further down the stack you go.
At the top you have some application that by itself has exactly zero access. Every io operation (disk, internet, hardware) goes through the kernel. The application asks the kernel to do this thing and the kernel does it with its elevated access.
At the bottom you have hardware that actually does the thing along with its firmware that has full unrestricted access.
So, Linux is the kernel. A distro is a pre packaged bundle of applications, configurations, files and applications.
Leucippus1@reddit
Kernel is just a general term for the parts of an operating system (whatever operating system) that provide the bare necessities to run the computer. Things like input and output. Windows has a kernel, UNIX has a kernel, Linux has a kernel, VAX has a kernel, etc etc.
So, in a sense, you are right; Linux is like the back end if you interpret the backend to be where applications interface with the operating system. OS's typically give you an API to interact with system services, like there are graphics APIs and what not, these have been around a lot longer than http connections which are now called APIs. We use 'back end' to describe something different if you are an application developer, the kernel is more like the chassis of a car or whatever other thing that - without - the entire thing will fall apart.
The distro is kind of like what you say; you get package managers and things of the like that might be specific to that distro or family of distros (say like DNF or apt-get) and then you have GUIs that you can run on basically everything - between gnome and kde. In fact, there are apps like GREP that will be in every linux distro regardless.
Everything is a little bit more granular than in Windows and Mac, but those OS' interact in a fundamentally similar way they are just more abstracted away from you.
jgo3@reddit
OMG I am so ancient. I am going to go crawl into a hole now.
CreativeGPX@reddit
The Linux kernel has two main roles:
Drivers describe how a particular piece of hardware fits with the OS abstraction.
Programs that run on Linux communicate with the kernel in order to access the hardware and actually do stuff. But which programs a person wants varies a lot. Some people don't need any graphics at all (even text graphics). Some people don't need any networking at all. Some people have no disk. Etc. For example, imagine an embedded Linux system running in an appliance, car or robot. Others consider graphics, mouse support, audio, etc. to be essential. For example, gamers. A Linux distro is simply a bundle of software and configuration with a Linux kernel of one of these use cases. It can be front end or back end or something in between. For example, a distro might use compilation options on the Linux kernel and ship with certain drivers, thus impacting the kernel and back end. Or it might include some software you might consider the back end like systemd, cron, a package manager and update service, etc. It also might include clearly front end things like a desktop environment, terminal styling, etc.
A desktop environment is a particular program that allows a user to interact with a GUI, desktop and mouse. Some people don't need a desktop environment and only stick with the terminal (for example, my servers at work). Others might interact completely different ways, like my car's infotainment system might just be a touch screen tailored to the car's options, rather than having mouse or terminal interfaces.
z3r0n3gr0@reddit
Linux = Monolitic kernel GNU = Open source applications X11 = Graphical server Gnome = Desktop environment
So you can just mount the puzzle. Have fun.....
Sternritter8636@reddit
There are lots of individual independent boxes in the , what you call, "linux". You can replace one with other most easily.
pseeec@reddit
What about GNU ?
nhaines@reddit
Not much. What's GNU with you?
Comfortable_Relief62@reddit
The purpose of Linux (or a kernel) is so that you can run multiple applications at a time on a single set of hardware. Historically, a kernel didn’t exist. You just plugged in a rom and executed code from that rom. That single program had access to all of the hardware directly.
Linux is a bunch of code that more-or-less emulates a whole computer for every program you want to execute. Of course, Linux has no clue what you actually do want to execute so you have to tell it what initial program to run. On most distros, this is the init process (System D). That initial program (and all future programs) can interact with the hardware through an interface that Linux provides called “system calls”. Linux provides the concept of a process. From one process, you can create more processes (fork). All of the software above this is part of an operating system and a distro. Typically, everyone uses GNU software in the Linux community (the C standard library implementation provided by GNU). This lets you write some nice “userland” C programs. From there, you have all of the applications that you’re used to using/seeing/running. Even things like ls, cd, pwd. But especially things like your desktop environment.
minneyar@reddit
Dividing things up into a "back-end" and "front-end" isn't really a useful distinction if you're not talking about web apps.
"Linux", strictly speaking, is the kernel. It is the piece of software that communicates directly with your hardware and provides a common interface that other software can use to access your hardware.
A Linux distrubtion, aka distro, is a pre-packaged collection of software that all works together. That includes the kernel, plus all of the user interfaces you'd use to interact with it--including terminals and desktop environments--plus other libraries and utilities. It includes everything you need to actually use your computer.
Fragrant_Pianist_647@reddit (OP)
okay, thanks for the explanation, but where does the BIOS come in in this case?
From what I know, the kernel has to communicate with the BIOS, which communicates with the hardware, so what is the kernel providing in this case?
LetReasonRing@reddit
The BIOS or UEFI are not provided by the OS, they are part of your motherboard. You can think of it sort of like an adapter that creates a standard interface the OS uses to talk to the hardware.
stormdelta@reddit
Modern systems use UEFI not BIOS, but basically the same thing. It's more of an initializer for booting the system than something that is actually called into during operation.
TheOneTrueTrench@reddit
You technically don't actually have a BIOS, that was the Basic Input Output System, replaced by UEFI roughly... 15-20 years ago?
Since UEFI (virtually always) has a "Compatibility Support Mode" that allows it to load legacy firmware from devices and boot operating systems in "BIOS" mode", everyone tends to still call it a "BIOS", and it operates as a pure drop-in replacement, so the difference isn't all the meaningful.
But, in the "technically correct, the best kind of correct" sense, you don't have a Basic Input Output System, you have a Unified Extensible Firmware Interface.
Unless your computer is like REALLY old, that is.
minneyar@reddit
The BIOS is a firmware on your motherboard that provides methods for initializing hardware and then booting into an operating system. After the OS has loaded, it doesn't communicate with the BIOS any more. (also, technically, nearly all computed produced since 2020 use UEFI, not BIOS)
bmwiedemann@reddit
IIRC There is probably some BIOS / ACPI involvement when you press the power button or close the lid of a laptop. And the kernel might call into BIOS routines for entering shutdown or sleep mode.
wafflingzebra@reddit
The BIOS is firmware that lives in the motherboard and does things like resets and configuration during initial boot. Being firmware it is hard to modify and probably you can’t at all, aside from using whatever bios releases are available from the manufacturer. Kernel is software, you can modify and switch as you please. BIOS is generally pretty specific to the platform, while kernel is more general.
PraetorRU@reddit
BIOS is a program that lives in your motherboard with the goal to preconfigure your hardware and make everything ready for a kernel of an operating system to take control and load an operating system.
UEFI is now largely replaced BIOS, as original BIOS was very limited in allowed size and functions.
MountfordDr@reddit
Put it simply, the desktop environment is just another application. You can install as many DEs as you like and choose to be in any of them when you log in.
BigHeadTonyT@reddit
Desktop Environments are the whole enchilada. Settings, Window Manager, Apps, Utilities.
For example, KDE comes with Kwin, its Window Manager. KDE also has tons of apps: https://apps.kde.org/en-gb/ Which ones the distro come with is up to the distro. I prefer Manjaros set. Some other distros can ship a more minimal set and/or they replace things like Filemanager and Terminal.
Personal things:
If I can't enlarge text in terminal with Ctrl++ or Ctrl+MouseWheel...I am mad. Treating me like a common hobo. I am installing Konsole, don't care what the depencies are. On KDE I can resize windows with Super/Windows-key and holding down mouse right-click button...I hate hunting those tiny corners. And I gotta have a dualpane filemanager. I am often working in 2 different directories. Dolphin does that. Other options are Krusader, Double Commander, Midnight Commander (for Terminal) etc.
WMs:
https://wiki.archlinux.org/title/Window_manager
Window managers are light. A distro can choose what to ship with it. For example, Antix comes with IceWM. That distro at desktop consumes less than 200 megs of RAM. The whole thing. It still looks nice, has the basic apps I need. I like the Conky setup. Among WMs, Enlightenment might be an excepton. It comes with a few apps. Those are very lightweight and fast tho. https://wiki.archlinux.org/title/Enlightenment
I think their Imageviewer is under 10 megs. No proper Wayland support last I tried though. You operate with left-clicks on Desktop. Similar to Litestep on old Windows. I liked that too.
Real-Abrocoma-2823@reddit
There is no front and back end. There is user and kernelspace instead. Userspace is what talks to kernelspace and kernelspace manages resources and decides whether to do things the user requested.
Zer0CoolXI@reddit
To add to what others have explained about kernel and other software its important to understand that in Linux OS’s, many of the modular components that make up what we think of as an OS are either not required (like a Desktop Environment/DE) and/or can have many alternative options to do the same thing. There are many possible DE’s for example, you can even have multiple ones installed on the same Linux OS at the same time and switch between them.
It’s entirely possible and common to have no DE for example. Just a CLI/Shell/tty. Servers don’t really need the DE/GUI and not having one saves resources and reduces attack surface of the OS (less things, less vulnerabilities)
Distro’s you can think of as different philosophical and practical approaches to what the devs envision as their OS. Some distro’s for example only include free open source software (FOSS) while others target a specific use case.
It’s entirely possible to customize, pick and choose if you will, what packages you want personally. You can take a base OS or even build Linux from scratch and then install only what you want.
As an example, I used to install the minimal install of Fedora, then install the DE, WiFi drivers and select other software I personally wanted to use instead of using a full pre-done distribution/spin of Fedora or something else. Here is the guide I created a while back for this. Note it’s likely out dated but the concept may be of interest to you. https://github.com/Zer0CoolX/Fedora-KDE-Minimal-Install-Guide
computer-machine@reddit
The distro is a mix of their choice of Linux kernel, various tools and utilities, package manager, their maintained repo of (generally compiled) software, and their selection of DE(s).
Fragrant_Pianist_647@reddit (OP)
Oh, so the distro is like a big package of everything you need, and some (like Arch) don't come with a pre-installed desktop environment.
toothpaste0@reddit
More or less. Distro maintainers can also choose which parts of the kernel gets included and/or optimize sane defaults for the average user.
CachyOs for example tweak their kernels and compile for certain CPUs. They give you a selection of possible schedulers for you to try without having to compile kernel yourself. Not everyone does this though.
Kahless_2K@reddit
nearly any distro can be installed without a desktop environment.
FormerSlacker@reddit
Linux is a house, the Linux kernel is the foundation of the house and the distribution provides the layout of the house.
JumpyJuu@reddit
Took me a while to realize that the login screen is not part of the desktop environment. It's a separate entity called greeter and there are many to choose from. The whole operating system is one big mosaic.
jr735@reddit
That will also happen in Debian if you don't select a GUI (which is selected by default, but is an explicit question). I'm certain Arch and Debian aren't the only two examples out there.
pikecat@reddit
TTY is a user interface. For many years it was the only one we had.
It was definitely a step up from flipping switches to enter binary into memory or punch cards.
TheSodesa@reddit
A Linux distribution might come packaged entirely without a desktop environment.
tahaan@reddit
Indeed there are layers between you and the Linux kernel, just like with a server/client architecture there are layers between you and the "back-end" server. So the Desktop Environment and applications sit between you and the Linux kernel.
So you can call it the back-end, but in this case it is normal to just call Linux it the Kernel of the operating system.
In fact there are some more layers.
The GUI environment (here I include GUI applications, the D.E, and the GUI server in one layer, an gross oversimplification) talks to the kernel through a series of libraries. These are layered too - There are libraries that create developer friendly APIs and these talk to lower level APIs presented by lower level libraries. These eventually make system calls (Talk to the kernel), which uses device drivers to talk to hardware (And these are layered too - in fact device drivers can be many layers deep). Eventually you get to the firmware - code that runs on the devices, and that eventually talks to the hardware.
When you think about all these layers, and you realise that user processes actually runs directly on the CPU, and does not work through an emulation layer, even in the case of a hypervisor, it becomes pretty amazing to think how those layers just manage to get out of the way when they need to!
wayofaway@reddit
People have mentioned Linux is the kernel, I want to make sure GNU gets some credit... They are the utilities that flesh out the operating system... GNU Core Utilities , and a lot of software that is ubiquitous in the Linux world.
DiskWorldly4402@reddit
tty is a user interface and the frontend/backend separation doesn't really map as cleanly when it comes to operating systems and even if it did your understating wouldn't hold because linux(kernel) is a part of a distro, I think you'd have much better luck understanding how linux and distros worked if you read a bit about specific operating system components rather than trying to remap them to concepts that emerged from web dev
Brave_Confidence_278@reddit
A distro is mostly just the package manager in combination with it's package repository. Often distros supply some other extras such as pre-installed packages as well as installation iso's. Some distributions apply patches for e.g. bugfixes, because they want to provide a complete operating system that supports all software installable from the package manager. But otherwise they all run more or less the same software.
BranchLatter4294@reddit
You are all sorts of wrong with the terminology and understanding. What you are calling the "back-end" is the kernel. The kernel interacts with the hardware and provides memory management and other services to applications (this is very simplified). There is a lot of other software required to make a usable operating system besides just the kernel. Different distros have different sets of packages that they include. The desktop environment (Gnome, KDE, etc.) provide the general user interface (again, very simplified).
Angelsomething@reddit
You understood correctly. The front end extends to the terminal and tools used.
Fragrant_Pianist_647@reddit (OP)
Yes, but there's also the desktop environment.
Angelsomething@reddit
That's akin to which infotainment you prefer.
x0wl@reddit
What's the difference between what?
Linux is a kernel, you have to combine it with user mode software to create a usable system.
A desktop environment is one such piece of software (or, rather, a collection, but they're all designed to work together).
People take the Linux kernel, the software they want (including the desktop environment, but also the browser, office programs etc) and combine them into a distribution. A lot of distributions offer a choice of DE. Fedora has GNOME and KDE editions (and a lot more spins), Ubuntu has different flavors etc.
In case of arch you boot into a TTY and install your DE of choice manually
txturesplunky@reddit
uhmm ...
linux is the kernel, then theres the display server, the package manager, the desktop environment, the window manager etc etc. All are separate things that interact to provide you with the experience you will have.