Linux is a family of operating systems built around the Linux kernel, with distributions combining the kernel with system libraries, utilities, package-management systems, configuration tools and applications. Strictly speaking, Linux is the kernel rather than a complete operating system distribution, although ordinary usage frequently uses "Linux" to refer to a complete Linux-based operating system. The kernel provides core facilities including process management, scheduling, virtual memory, device management, networking, filesystems, security mechanisms and system-call interfaces.
Linux is distributed under the GNU General Public License version 2 for the kernel, making its source code available under free-software licensing terms. Numerous distributions build different user experiences and administrative systems around the same general kernel, so two Linux distributions can differ substantially in packaging, defaults, graphical environments and release models while still sharing the Linux kernel.
Linux originated in the early 1990s when Linus Torvalds began developing a Unix-like kernel while studying at the University of Helsinki. The project grew through contributions from developers around the world and became part of a much larger free and open-source software ecosystem. Linux adopted and interoperated with many Unix and POSIX-oriented conventions, although it is not historically derived from the original Unix source code in the same way as traditional Unix systems.
The GNU Project supplied many important user-space components commonly found in Linux distributions, leading to the term GNU/Linux in contexts where the distinction is important. Over time, Linux expanded from a personal-computing project into a kernel used in servers, supercomputers, embedded systems, networking equipment, cloud infrastructure and many specialised devices.
The Linux kernel uses a modular architecture in which core kernel functionality and loadable modules support a wide range of hardware and software requirements. It provides system calls through which user-space programs request privileged operations such as creating processes, accessing files and communicating through networking facilities. Kernel space and user space are protected execution domains, with transitions controlled by the processor and kernel. Linux supports preemptive multitasking, virtual memory, multiprocessing and extensive networking facilities. Its scheduler manages runnable tasks, while the virtual-memory subsystem manages mappings between process address spaces and physical memory. Device drivers connect hardware to kernel interfaces, allowing applications to interact with devices through standardised abstractions rather than directly programming every hardware implementation.
Linux distributions package the kernel with a user-space environment and software-management infrastructure. Examples of major distribution families include Debian-based, Red Hat-based and Arch-based systems, although each family contains numerous individual distributions and variants. Package managers retrieve software from configured repositories and track installed files and dependencies, although the exact commands and package formats vary. Distributions also differ in release philosophy: some prioritise long-term stability and extended maintenance, while others provide newer software more rapidly.
Desktop environments such as GNOME and KDE Plasma provide graphical interfaces but are separate projects from the Linux kernel itself. This separation between kernel, distribution, desktop environment and individual applications is essential to understanding why the phrase "Linux" can refer to different layers depending on context.
Linux has extensive use in servers because of its networking capabilities, automation facilities, configurability and broad hardware support. Web servers, database systems, cloud infrastructure, development environments and high-performance computing systems commonly use Linux-based operating systems. Linux is also prominent in embedded computing, where manufacturers can customise kernels and user-space software for devices with specific hardware and resource constraints.
Android uses the Linux kernel but adds a distinct application framework, runtime and system software stack, so Android should not be treated as an ordinary desktop Linux distribution. Linux's role in supercomputing is particularly significant because its kernel and surrounding ecosystem can be adapted to specialised large-scale systems. These uses demonstrate the flexibility of a kernel whose interfaces can support very different user-space environments.
Linux provides a broad security model involving user and group identities, file permissions, capabilities, mandatory access-control frameworks where configured, process isolation and kernel-level security features. Traditional file permissions distinguish owner, group and other access, while extended mechanisms can provide finer-grained control. Security modules can apply additional policy beyond discretionary permissions. Linux distributions also provide package update mechanisms, firewall tools and service-management facilities, but the exact defaults vary.
Open source does not mean that software is automatically secure: vulnerabilities can exist in the kernel, libraries, applications and configurations. Conversely, the availability of source code enables independent inspection and development, although the mere existence of source does not guarantee that every defect will be found. Effective Linux security depends on appropriate configuration, timely updates, least privilege, service exposure control and application-specific safeguards.
Linux is highly configurable, which is both an advantage and a source of complexity. Administrators can choose filesystems, services, network configurations, security policies and software packages appropriate to their requirements. Command-line tools and scripting make system administration highly automatable, while graphical tools are available for users who prefer them. The system's openness has encouraged extensive ecosystem development, but compatibility can sometimes vary between distributions because package versions, filesystem layouts and configuration conventions differ.
Hardware support is broad, but proprietary drivers or specialised software may not always provide identical support across platforms. The distinction between upstream projects and distribution-specific integration is therefore important when diagnosing problems: a behaviour may originate in the kernel, a library, a distribution patch, a desktop environment or an individual application.
Linux's long-term significance lies in its combination of open development, portability, extensibility and widespread deployment. It has become foundational to many areas of modern computing without requiring a single uniform user interface or distribution. The kernel's process scheduling, IPC, synchronisation, memory management, networking and device abstractions provide the underlying mechanisms on which diverse applications and operating environments depend. Its history also illustrates how a kernel can evolve through distributed collaboration while supporting commercial and non-commercial uses under a free-software licence. Understanding Linux accurately therefore requires distinguishing the kernel from the distributions and software ecosystems built around it, while recognising that in everyday usage "Linux" often denotes the complete operating environment experienced by a user or administrator.
