Linux and Open Source

Linux grew from two separate efforts: one supplied a kernel, and the other supplied much of the software around it. Unix provided the earlier design ideas. Keeping these contributions separate makes the names Linux and GNU/Linux easier to understand.

Unix provides the design

Ken Thompson and Dennis Ritchie developed Unix at AT&T's Bell Labs from 1969. Much of it was rewritten in C in 1973, making it easier to move to different hardware. Unix let several users work and several programs run at once. Its lasting ideas include a single directory tree rooted at /, treating many resources as files, and combining small programs that each do one job.

Unix developed into several branches. Commercial systems included IBM AIX, HP-UX, and Sun Solaris. Berkeley's BSD branch led to FreeBSD, OpenBSD, and NetBSD. Apple's macOS also has BSD roots and has been certified as UNIX. A similar interface does not make all these systems Linux.

GNU supplies much of the system

Richard Stallman announced the GNU Project in 1983 to build a free Unix-like operating system. GNU stands for “GNU's Not Unix.” He founded the Free Software Foundation in 1985. By the early 1990s, GNU had produced the GCC compiler, a C library, Bash, core utilities, and editors. Its intended kernel, GNU Hurd, was not ready for everyday use.

A compiler turns program source into executable code. A shell such as Bash accepts instructions from a user. These tools made GNU useful, but they still needed a kernel to manage the computer's hardware.

Linux fills the kernel gap

In 1991, University of Helsinki student Linus Torvalds began a kernel for his Intel 386 PC. MINIX, Andrew Tanenbaum's Unix-like teaching system, helped inspire the project. Torvalds announced it on August 25, 1991; version 0.01 followed in September. Linux 1.0 arrived in March 1994.

The first license prohibited charging for redistribution, including handling charges. Linux 0.12 moved to the GNU GPL in 1992. That allowed both volunteers and businesses to redistribute it under the GPL's conditions. The kernel remains under GPL version 2.

Distributions assembled the kernel and userspace into installable systems. Slackware and Debian began in 1993; Red Hat Linux followed in 1994–1995. Later milestones include the open source name and the OSI in 1998, Ubuntu in 2004, Git in 2005, the Linux Foundation in 2007, and the first Android phone in 2008. Tux, the penguin mascot, dates from 1996.

Read the names accurately

Strictly, Linux names the kernel. Everyday speech also uses it for a complete operating system. GNU/Linux credits the GNU tools combined with that kernel; Debian uses this name. Android uses a Linux kernel with a different userspace, so GNU/Linux is not its name.

Place the central events in order: Unix in 1969, GNU in 1983, Linux in 1991, and the GPL change in 1992. GNU began before Linux existed. Linux is Unix-like because it follows many Unix ideas and standards, including POSIX; it was independently written, not released as a branch of the original Unix code.

A Linux desktop is a collection of cooperating parts. The kernel manages access to the machine, while programs outside it provide the tools and interfaces you use. A kernel version tells you about one part of the system, not the version of every application.

The kernel manages shared hardware

The boot loader loads the kernel into memory at startup. The kernel stays active until shutdown. It shares processor time and memory among programs, handles networks and file systems, enforces permissions, and communicates with devices through drivers.

The kernel runs in kernel space, with privileged access to hardware. Ordinary applications run in user space, with limited rights. A system call is a request from a program for a kernel service, such as reading a file. A normal application failure usually affects that application; a serious kernel failure can stop the whole machine.

Linux has a monolithic kernel: drivers, networking, and file systems run inside it. Many drivers are loadable modules. The kernel can load a suitable module when hardware appears without rebuilding the entire operating system.

Userspace gives the system its working tools

Userspace includes the system that starts services, libraries, utilities, shells, graphical software, and applications. Common examples include systemd, the glibc C library, GNU coreutils, Bash, Wayland, and desktops such as GNOME or KDE Plasma. Small systems may use musl and BusyBox instead of glibc and GNU utilities.

Suppose you open a saved drawing in an application. First, the application requests the file through a system call. Next, the kernel checks access rights and uses file system code and a storage driver to retrieve its bytes. The application then interprets those bytes and draws the picture. Its menus and editing tools belong to userspace.

Changing from GNOME to KDE Plasma changes your desktop experience without requiring a different kind of kernel. Conversely, updating the kernel need not change the layout of the desktop.

Read version numbers and support correctly

In 7.2.12, 7.2 identifies the kernel release series and 12 is its twelfth stable update. A larger first number does not automatically signal a major redesign: the move from 6.19 to 7.0 in 2026 followed the practice of resetting a growing minor number.

Mainline development starts with a roughly two-week merge window for new features. Weekly release candidates then test and stabilize the work. A release normally arrives every 9–10 weeks. Stable maintainers apply fixes afterward. Selected longterm kernels receive important fixes for years; kernel.org's October 2026 projections list 6.12 and 6.18 through December 2028.

Distributions build their own kernel packages and apply fixes to them. A string such as 6.8.0-45-generic includes Ubuntu's build information after the hyphen. Ubuntu 24.04 originally used the 6.8 kernel; Ubuntu 26.04 uses 7.0. An older base number alone does not show whether a supported distribution kernel is patched. Check its maintenance status and updates.

Kernel development is shared work. Subsystem maintainers review proposed changes for their areas, and Torvalds merges accepted work into mainline. Many contributors are paid by hardware, cloud, and software companies.

Linux often works behind a screen that never displays its name. A desktop, a phone, a router, and a cloud server can all use the Linux kernel while presenting very different interfaces. Identify both the kind of environment and the role it serves.

Clients and servers describe roles

A server provides a service, such as web pages, files, or a database. A client requests that service. These words can describe programs or computers. A Linux web server acts as a database client when it asks a separate database server for information. The same machine can therefore have both roles.

Linux desktops include Ubuntu, Fedora, Debian, and Linux Mint. ChromeOS and SteamOS also use the Linux kernel. Linux is especially common in web hosting, databases, cloud infrastructure, and other internet services, even though Windows and macOS have larger desktop shares.

Virtual machines and containers differ

A hypervisor gives a virtual machine virtual processors, memory, storage, and networking. Each VM runs its own operating system and kernel. KVM adds virtualization capabilities to Linux and is used by many cloud platforms.

A cloud instance is a rented VM started from an operating system image. You select resources and a region, then connect over the network, commonly through SSH. Running instances can incur charges.

A container packages an application with its supporting files and libraries. Containers on the same host share its kernel, so they usually start faster and use fewer resources than full VMs. A Linux container needs a Linux kernel. On Windows or macOS, container software commonly supplies one through a small Linux VM. Having a Linux-looking userspace inside a container does not mean that container owns a separate kernel.

Devices and large computers use Linux too

Embedded systems are computers built into a device for a particular job. Examples include routers, smart TVs, industrial controllers, and vehicle entertainment systems. Many use ARM processors and a small userspace such as BusyBox. A Raspberry Pi can instead run a full distribution, Raspberry Pi OS.

Android combines a modified Linux kernel with its own userspace, including Bionic and the Android Runtime. Android applications are not ordinary Linux desktop applications. In high-performance computing, clusters divide large calculations among many machines. Every system on the TOP500 list has used a Linux-based operating system since November 2017.

Managing many machines

Administrators use configuration management tools such as Ansible, Puppet, Chef, or Salt to describe a desired system state and apply it repeatedly. This helps keep installed software, settings, and services consistent across many machines.

Linux settings often live in text files. nano shows common keyboard shortcuts on screen. vi and Vim separate text entry from command actions through modes. Recognizing these editors helps explain why a server can be managed without a graphical desktop.

Consider a museum kiosk that loads pages from a rented Linux VM. The kiosk is a client; the rented VM is a cloud instance acting as a server. If that server runs several containerized applications, those containers share its Linux kernel. A Linux-powered display controller inside the kiosk is an embedded use, regardless of whether visitors see a desktop.

A distribution turns the Linux kernel into a system you can install and maintain. It brings together tools, libraries, packages, an installer, default settings, and an update service. Some distributions are community projects; others are maintained by companies.

Follow the family relationships

A derivative starts from another distribution and changes it. Ubuntu is based on Debian, and the main Linux Mint edition is based on Ubuntu. Related systems often share package formats and tools. Their relationship helps you recognize suitable software and instructions.

Debian has been a volunteer project since 1993 and follows a written Social Contract. Canonical produces Ubuntu. Raspberry Pi OS is Debian-based and tailored for Raspberry Pi computers. A shared base does not make these distributions identical: defaults, schedules, support, and package versions can differ.

Understand the Enterprise Linux pipeline

Fedora introduces new technology quickly. A future RHEL major release branches from Fedora. CentOS Stream develops changes ahead of the next RHEL minor release. RHEL supplies a commercial subscription-supported platform. AlmaLinux and Rocky Linux provide free community systems designed for RHEL compatibility.

CentOS Stream is different from the ended CentOS Linux rebuild. CentOS Linux 7, its last supported version, reached end of life in June 2024. Choosing a familiar name without checking its current role can lead to the wrong system.

Recognize other choices

SUSE Linux Enterprise is commercial. openSUSE Leap provides a stable community release linked to enterprise sources; Tumbleweed updates continuously. Both use zypper, despite sharing the RPM format with the Enterprise Linux family.

Alpine combines musl and BusyBox to keep its base small. It has numbered stable branches and a development branch, edge. Both have main and community repositories; edge also has testing. Arch is a do-it-yourself rolling distribution often chosen by experienced users.

Use the family clue correctly

Suppose an instruction mentions dnf and an .rpm package. That points toward Fedora or Enterprise Linux. An instruction using apt and a .deb package points toward Debian-based systems. An RPM alone does not distinguish SUSE from Fedora, because both use that format.

Then check the exact distribution, release, and architecture. A package built for one release can depend on library versions missing from another. Many programs are available across Linux families, but one downloaded package is not a universal Linux installer.

Linux software is normally delivered through a package system. It tracks what a program needs, where its files belong, and how it should be updated. This replaces the need to find a separate website installer for every application.

A package carries files and instructions

A software package is an archive containing program files and metadata. Metadata describes its name, version, purpose, required packages, and installation or removal actions. Common formats include .deb, .rpm, and Alpine's .apk. Alpine packages and Android apps use the same extension but are different formats.

A dependency is another package a program needs. A graphics application may require an image library. If several applications share that library, the package system can maintain one shared copy and apply fixes centrally.

A repository is a collection of packages prepared for a distribution and release. The package manager checks cryptographic signatures to verify the trusted package information and content. This helps reject files changed on the way to your machine. Trust still depends on choosing a legitimate repository and its signing key.

Match tools to their jobs

A graphical software center is an interface to package systems, not a separate kind of operating system. Knowing the underlying source remains useful even when you never type a package command.

Imagine installing an audio editor that requires two libraries. A high-level manager checks the dependency list, fetches missing packages, and installs them in the right order. Giving a low-level tool only the editor's package can leave dependencies unresolved.

Compare universal formats

Flatpak, Snap, and AppImage help applications run across distributions by supplying more of their supporting software. Flatpak applications commonly come from Flathub. Snap is associated with Canonical and is used for some Ubuntu software. An AppImage is a single application file that can run without normal package installation.

These formats can deliver newer application versions on a long-supported system. Bundled libraries can also increase download size and duplicate files. An application still has hardware and system requirements; “universal” does not mean every package runs on every possible machine.

Keep the update paths straight

For a beginner, the distribution's repositories are a good starting point: their packages are prepared for the release and checked through its trust system. Random website downloads do not provide the same integrated maintenance.

If one editor came from the distribution and another came through Flatpak, they have different update paths. Updating the distribution's packages covers what that system manages. Check the Flatpak updates as well. A downloaded application is not automatically maintained simply because it runs on Linux.

A release model tells you how a distribution changes. Its support policy tells you how long fixes arrive. Choosing a system means planning both the changes you want now and the maintenance you will need later.

Fixed and rolling releases

A fixed release publishes numbered versions. Updates within a release emphasize security and bug fixes; selected components can still gain features. Broader changes arrive with a release upgrade. Debian stable, Ubuntu, RHEL, openSUSE Leap, and Alpine stable branches follow this model.

A rolling release continuously updates packages to new upstream versions, without major release upgrades. Arch and openSUSE Tumbleweed use this approach. Regular updates keep the system current but can require more attention when behavior changes. Debian unstable and Alpine edge also change continuously, but they are development branches.

Read the support promise

Long-Term Support (LTS) means several years of maintenance. Ubuntu releases LTS versions every two years in April of even years. Standard security maintenance lasts five years; Ubuntu Pro extends coverage to ten, and its Legacy add-on to fifteen. Coverage depends on the applicable service and packages. Interim releases have nine months of support.

Ubuntu's 26.04 means April 2026. Version 26.10 means October 2026. Ubuntu 24.04 is Noble Numbat, and 26.04 is Resolute Raccoon. As of October 2026, 24.04 standard security maintenance ends in May 2029; 26.04 is supported through April 2031.

Debian stable is the well-tested current release. Testing gathers packages for the next stable release. Unstable, always named sid, receives new packages first. Debian 13, trixie, was released August 9, 2025; full support runs to August 9, 2028, followed by LTS to June 30, 2030. LTS can cover fewer architectures and packages.

RHEL major releases have a ten-year life cycle with full and maintenance phases. Fedora releases about every six months and supports each release for about 13 months. A free download and a long support period are different properties.

Distinguish test stages from maintenance

An alpha is an early, possibly incomplete build. A beta invites wider testing with the main features in place. A release candidate can become final if no serious issue is found. These labels describe progress toward release, not a long-term support promise.

End of life (EOL) ends a release's security updates. A machine can still boot after that date, but newly found flaws will remain unfixed by that support service.

For a planning example, Ubuntu 26.10 starts in October 2026 and has nine months of support. Counting forward gives July 2027. Installing it in June 2027 does not restart that clock. Plan the upgrade from the release's published EOL date. Debian's word “stable” likewise means a deliberately consistent, tested platform, not a promise that software never crashes.

Start a system choice with the work that must get done. A familiar interface, a zero download price, or a high version number cannot tell you whether the required application and hardware will work. List the requirements before selecting a distribution.

Compare the operating systems

Most Linux distributions are free to download. Enterprise subscriptions pay for services such as tested builds, support, certification, and long maintenance. The freedom to study and share software does not require every service around it to have zero cost.

Notice the everyday differences

Linux organizes files in one tree beginning at /, without Windows drive letters. A Linux path can look like /home/ana/report.odt. Linux filenames are normally case-sensitive: Report.txt and report.txt can name different files. Software normally comes from repositories.

A graphical desktop is a replaceable part of a Linux system. GNOME, KDE Plasma, Cinnamon, Xfce, and LXQt provide different interfaces. Lightweight desktops can help on machines with little memory. Servers often omit a desktop and are managed through a terminal.

Check application compatibility first

A Windows .exe is not a native Linux application. Wine runs many Windows applications through a compatibility layer; Proton, based on Wine, supports many Windows games through Steam. Compatibility depends on the application, so these tools do not guarantee that every required program works.

Some vendors offer native Linux editions. Many open-source applications run on Linux, Windows, and macOS. Browser applications can also make a workflow portable. Desktop Microsoft Office and Adobe Photoshop do not have native Linux editions. WSL runs Linux distributions alongside Windows, and a VM can run Linux on a Windows or macOS host.

Work through a choice

A photographer needs the desktop Photoshop application, a browser, and shared files. First, the Photoshop requirement points toward Windows or macOS for the working desktop. Next, Linux learning can happen in a VM, or in WSL on Windows. Replacing the working system before checking the required application would interrupt the job.

For a small server, the priorities change. Check architecture, required server software, support duration, and whether a vendor must answer support requests. An enterprise or LTS server release can fit that need. For an older laptop, compare memory requirements and lighter desktop options; for a Raspberry Pi, choose a matching image such as Raspberry Pi OS.

A useful shortlist records purpose, processor architecture, available memory and storage, must-have applications, support dates, commercial support needs, and documentation. Then compare the distributions against those requirements.

The price of a download tells you little about your rights. A program can cost nothing and forbid changes, or be sold while giving users permission to study, modify, and share it. The license determines those freedoms.

Source code and software categories

Source code is the human-readable form programmers write. A compiled binary is a form a computer can execute. Access to source helps users inspect and change a program, but seeing it does not itself grant permission to reuse it.

Proprietary source can be private or visible under restrictions. A public repository without a license also does not grant a general right to copy, modify, and redistribute the code. Check for a license before reuse.

The four freedoms

The Free Software Foundation numbers the freedoms from zero:

• 0: run the program for any purpose.
• 1: study how it works and change it.
• 2: redistribute copies.
• 3: distribute modified versions.

Freedoms 1 and 3 need access to source. “Free” here concerns freedom. A business can sell free software, and a customer can pay for support while retaining these rights.

The Open Source Initiative, founded in 1998, applies a ten-part definition derived from Debian's Free Software Guidelines. It requires source access, redistribution, and modified works. Licenses cannot discriminate against people, groups, or fields such as business. Rights must reach recipients without a separate agreement and cannot be tied to one product, restrict unrelated bundled software, or require a specific technology.

The free software movement emphasizes users' rights and control; the open source movement emphasizes shared development and practical benefits. Their approved licenses overlap greatly. FOSS and FLOSS are umbrella terms for these closely related ideas.

Apply the distinction

A free-to-download drawing app has visible source but forbids business use. First, ignore its price. Next, inspect the permission: the business restriction fails the open-source rule against discrimination by field of use. The app is source-available, not open source in the OSI sense. BSL and SSPL are examples of source-available license approaches.

By contrast, an MIT-licensed editor can be sold and still be free and open-source software. Its price does not remove its license permissions.

Control over devices and data

Digital autonomy concerns an individual's control over devices, data, and software. Digital sovereignty concerns an organization or country's control over infrastructure and data. Open source supports these aims because another provider can inspect, maintain, or adapt the code. This reduces vendor lock-in, where changing suppliers becomes difficult. The ability to maintain a system independently is distinct from whether a team has the staff and resources to do so.

An open-source license grants rights while keeping conditions attached to the code. To apply it, identify the license and version, decide what action you plan, and check which part of the software the conditions cover.

Permissive licenses preserve notices

MIT and the 2-clause and 3-clause BSD licenses permit reuse, changes, and distribution in proprietary products. Keep the required copyright notice and license text. The 3-clause BSD license also prevents using contributors' names to endorse a derived product without permission.

Apache 2.0 is permissive too. It adds an explicit contributor patent license, requires marking changed files, and passing on relevant NOTICE information.

Copyleft keeps covered code open

GPL software can be sold. Running or modifying it privately does not itself require public release of the changes. Distributing copies, including in devices, triggers obligations to recipients. The permitted source-delivery method depends on the GPL version and the form of distribution; a written offer is allowed in specified cases, not every case.

GPLv3 adds patent protections and installation-information rules for covered consumer products. The Linux kernel uses GPL-2.0-only. An SPDX identifier ending in -or-later gives a choice of that version or a later one; -only does not.

Check the action and the covered part

A business modifies a GPL tool and runs it only on its own computers. It has not distributed copies, so that private modification does not create a source-publication duty. If it ships the modified tool to customers, it must comply with distribution terms, including corresponding source access.

Now a business modifies an AGPL web application and lets customers use it online. Network interaction with that modified version requires offering its source to those users. GPL and AGPL therefore differ even when customers receive no program download.

A router vendor that ships a modified Linux kernel must provide the corresponding kernel source under GPLv2 through a valid method. Separate userspace programs using ordinary system calls do not become GPL-covered merely for that reason. Documents and pictures created with a GPL application also do not acquire the application's license.

Combine code carefully

MIT code can usually be incorporated into a GPL program while preserving MIT notices. The resulting combined program must satisfy the GPL. GPL code cannot simply be relabeled MIT to remove copyleft conditions. Apache 2.0 is compatible with GPLv3, but not with GPLv2-only.

Open licenses also apply to work such as images, text, music, and teaching materials. Creative Commons supplies tools for this content. Read the license elements before deciding whether a particular use is allowed.

Read the four elements

The six licenses are CC BY, CC BY-SA, CC BY-ND, CC BY-NC, CC BY-NC-SA, and CC BY-NC-ND. All six require attribution. These restrictions do not form a single simple ranking: ND restricts adaptations, while NC restricts a different dimension, commercial use.

CC0 is a separate public-domain dedication. It waives copyright as far as possible and provides a fallback permission where needed. Credit is good practice but is not a CC0 condition. Among these tools, CC BY, CC BY-SA, and CC0 permit both commercial reuse and adaptations and match the idea of fully open reuse.

Decide whether the planned use fits

Imagine a trainer finding a CC BY-NC photo for a paid advertisement. The advertisement is commercial, so the NC license does not authorize that use. Giving credit does not remove the restriction; the trainer needs separate permission or a different image.

For a CC BY-ND diagram, sharing the original with credit is permitted. Recoloring it into an adaptation and sharing that adaptation is not authorized by ND. ND's relevant restriction is sharing the adaptation; it does not prohibit making a private adaptation.

A CC BY-SA text may be adapted, including for commercial use, with credit and the required license for the adapted material. This does not mean unrelated material placed alongside it automatically has the same license. Wikipedia text is a familiar BY-SA example.

Give useful attribution

TASL is a practical reminder: Title, Author, Source, License. Include links to the original and the license where possible, and describe changes. An example credit is: “'Morning Harbor' by Lee Park, from the creator's portfolio, CC BY 4.0; cropped.” Link the title to the original and the license name to its terms. Use the actual creator, source, and license in your own credits.

A link to a search result alone does not identify the creator or the license. Keep the credit information when downloading content.

Keep content and code licenses separate

Creative Commons recommends software-specific licenses for program code because the BY-family licenses do not address source delivery and software patent issues in the same way. A project can put its code under MIT and its manual under CC BY-SA.

Version 4.0 licenses cannot simply be revoked for compliant users who already received the work. Removing the download later does not erase their existing permissions. Finding an image online, however, supplies no open license by itself.

An open-source project needs more than code. Users identify problems, contributors propose improvements, and maintainers decide what enters the official project. The license gives you rights to the software; project governance decides how the shared version develops.

Understand the roles and decisions

Contributors can write documentation, translate interfaces, test releases, improve design, answer questions, or report bugs. Maintainers review work for a project or subsystem. Larger projects also have security teams and release managers.

Governance varies. Linus Torvalds has the final decision on the mainline Linux kernel. Debian elects a Project Leader and follows a constitution. A company can lead a project, as Canonical leads Ubuntu. Foundations such as the Apache Software Foundation or Python Software Foundation provide an organizational home, handling matters such as funds and trademarks. Foundation involvement does not mean all projects use the same decision process.

Anyone can propose a change or make a fork. Only authorized maintainers can accept it into the official project. A fork develops a copy independently; examples include LibreOffice from OpenOffice.org, Nextcloud from ownCloud, and MariaDB from MySQL.

Know upstream and downstream

The original project that develops a program is its upstream. Distributions that package and sometimes patch it are downstream. A fix sent upstream can benefit many distributions and reduce the need to maintain separate patches.

Report a distribution-specific packaging issue through that distribution's route. A general application bug can belong upstream. Read the reporting guidance because projects may ask you to confirm the issue or gather particular information first.

Follow the contribution workflow

Git records project history. GitHub, GitLab, and Codeberg host repositories and collaboration tools. An issue tracker records problems and feature requests. A pull request or merge request proposes changes for review; automated tests can check them. The kernel commonly reviews emailed patches.

Read the README, contribution guide, and code of conduct. A CLA grants specified contribution rights to the project owner. A DCO sign-off certifies that the contributor has the right to submit the work. These are different mechanisms. Keep a proposed change focused and respond to review patiently.

Build a bug report someone can use

Suppose an application closes unexpectedly when a chart is exported. Search the tracker first. If the problem is new, write a report such as:

1. Title: “Chart export closes the application.”
2. Environment: exact application version, distribution, and distribution version.
3. Steps: open a new sheet, insert a chart, choose the export format, and save.
4. Expected result: an exported image and an open application.
5. Actual result: the application closes; include the exact error text if available.

Provide a small sample that reproduces the problem when appropriate. Remove personal data and credentials from attachments. A specific report lets another person reproduce and investigate the failure. “It is broken” describes frustration but gives no repeatable route to the problem.

Free redistribution changes how software businesses earn money, but it does not prevent income. Customers often pay for the work needed to run software reliably. Projects can also share costs through donations, grants, foundations, and paid contributors.

Match the model to what is sold

Red Hat, SUSE, and Canonical sell support and maintenance services. A managed database service sells operation and convenience. A router maker sells a physical device and benefits from a shared operating system. Search partnerships can fund browser development; Mozilla receives substantial income through such agreements.

Separate open core from dual licensing

In open core, the extra paid component has features that the open core does not include. A company might offer an open monitoring tool and a proprietary add-on for managing thousands of machines.

In dual licensing, the same code is offered under different licenses. A customer can follow the copyleft license or buy a commercial alternative that permits a different use. MySQL and Qt use forms of this model. The copyright holder needs the rights required to offer the alternative; a user cannot simply relicense somebody else's code.

Understand shared funding

Companies pay developers to improve infrastructure they depend on. Sharing the cost of a kernel, library, or tool can be cheaper than building it separately. Foundation membership fees, individual donations, sponsorship, and grants also support work. Open source includes paid professionals as well as volunteers.

Follow license changes and forks

Some vendors moved new releases to source-available terms to control competing hosted services. MongoDB adopted SSPL in 2018. Terraform moved to BSL in 2023; Redis adopted RSAL and SSPL in 2024. Earlier releases remain available under the licenses already granted.

Communities can continue from an earlier open release. OpenSearch continued from Elasticsearch, OpenTofu from Terraform, and Valkey from Redis. Later changes can add open options again: Elastic added an AGPL option in 2024, and Redis 8 added AGPL in 2025. Check the exact release and license when comparing products.

Consider a team funding a scheduling application. Selling a hosted service pays for servers and operation. Selling support pays for help and maintenance. Selling an extra proprietary management module is open core. These choices affect what customers buy without making the open code disappear.

Open-source applications cover office work, browsing, graphics, media, programming, and data analysis. Many also run on Windows and macOS. Learn what kind of work each application handles so you can choose by task.

Office and internet work

LibreOffice includes Writer for documents, Calc for spreadsheets, Impress for presentations, Draw for diagrams, Base for databases, and Math for formulas. Its default OpenDocument formats include .odt, .ods, and .odp. It also reads and writes Microsoft formats such as .docx and .xlsx.

LibreOffice began as a fork of OpenOffice.org in 2010 and is developed under The Document Foundation. Apache OpenOffice remains a separate project. Firefox is Mozilla's browser; Thunderbird handles email, calendars, and contacts. Chromium is Google's open-source browser project. Google Chrome builds on it with proprietary additions and its own distribution terms.

Choose the right kind of graphics tool

A raster picture stores pixels. Enlarging it far beyond its original size reveals that grid. A vector picture stores shapes defined mathematically, so its edges remain sharp when scaled.

For a community event, use Inkscape for the logo that must appear on both a small badge and a large sign. Use GIMP to adjust the accompanying photograph. The two files can appear in one design, but their editing needs are different.

Media and recording

VLC plays a wide range of audio and video formats and streams. Kodi organizes a media library for use on a TV or media-center system. Audacity records and edits sound. OBS Studio records and live-streams video. An audio-editing task calls for Audacity; capturing and streaming a lesson calls for OBS Studio.

Editing code, signing files, and analyzing data

Microsoft's Visual Studio Code builds are distributed under proprietary terms. The underlying Code - OSS source is MIT-licensed. VSCodium provides community builds from that source without Microsoft's branding and telemetry additions. The license of the source project and the license of a vendor's distributed build can differ.

GPG, GNU Privacy Guard, implements OpenPGP encryption and digital signatures. Encryption protects content from reading; a verified digital signature helps establish who signed data and whether it changed. Distributions use signatures in package and image verification workflows.

R is a language and environment for statistics, data analysis, and charts. Calc is useful for spreadsheet work, while R supports analysis expressed as programs. Choosing a familiar brand alone can hide these differences: a browser is not an email client, a video recorder is not an audio editor, and public source does not automatically make every branded build open source.

A web application runs on a server and presents its interface through a browser. Open-source web applications can often be self-hosted, giving an organization a choice of operator and more control over its data. That choice also brings maintenance work.

Match platforms to everyday needs

Nextcloud began as an ownCloud fork in 2016. It also offers functions such as calendars, contacts, office collaboration, and chat. Moodle is a learning management system, or LMS, written in PHP. It is often paired with BigBlueButton for live classes.

A course platform and a conferencing system solve different problems. Moodle can store assignments and grades between lessons; BigBlueButton provides the live lesson environment. One is not a substitute for every function of the other.

Follow a self-hosting choice

A training cooperative wants its course work and files on servers it controls. First, it selects Moodle for course activities, a meeting system for live sessions, and Nextcloud for shared files. Next, it decides who will run the Linux servers. Finally, it assigns responsibility for updates, backups, account access, and security.

Open source allows self-hosting, but does not perform that ongoing work automatically. A local service provider can operate the software for the cooperative if it lacks its own staff.

Separate Git from a forge

Git is a distributed version control system created by Torvalds in 2005. A commit records a change in project history. A branch allows a line of work to develop separately before merging. An ordinary full clone keeps the repository history on another computer.

A forge adds hosted repositories, issue tracking, code review, and automation around Git. GitLab Community Edition, Gitea, and Forgejo are open-source options. Codeberg is a hosting service powered by Forgejo. GitHub is a proprietary service owned by Microsoft, even though it hosts many open-source projects.

A team can use Git without GitHub. It can keep local repositories, use another forge, or move its Git history between hosts. The host's extra features, such as its issue database, are separate from Git history.

Choose control and responsibility together

If a team wants to retain its version history when switching providers, Git's distributed history helps. If it also wants to run the review platform itself, it needs a self-hostable forge. Compare the license, required features, and who will maintain it. A public repository, an open-source application, and an open-source hosting platform are three different things.

A server application usually works with other programs. A web server handles requests, an application supplies behavior, and a database stores data. Recognizing each role helps you understand a working stack without needing to write the programs yet.

Match the server to the service

Apache HTTP Server delivers web content and supports modules. NGINX also serves web content and commonly acts as a reverse proxy, forwarding requests to application servers, or a load balancer, spreading requests across them. Apache HTTP Server is one project; the Apache Software Foundation hosts many others.

MySQL, MariaDB, and PostgreSQL are relational database servers. MySQL has GPL and commercial licensing options. MariaDB began as a MySQL fork in 2009. PostgreSQL is a separate project known for extensibility and its permissive license. Related database products can still develop differences; shared history does not make their versions interchangeable forever.

For file sharing, NFS is traditional between Unix-like systems. Samba implements SMB for sharing files and printers with Windows and other clients. It can also provide Windows-style domain services.

Trace a LAMP request

LAMP commonly means Linux, Apache, MySQL or MariaDB, and PHP. Some uses substitute Perl or Python for PHP. Consider a visitor opening a stock-check page:

1. The browser requests the page from Apache on Linux.
2. Apache passes the request into the application's PHP code.
3. The code asks MariaDB for stock records.
4. The application builds the response, and Apache sends it to the browser.

The database does not replace the web server, and the browser does not directly run the server's PHP code. Each component handles a different part of the request.

Understand how programs run

A compiler can turn source into machine code for a particular architecture. An x86-64 executable does not run directly as ARM64 machine code. An interpreter runs code at runtime; the required interpreter, libraries, and system features must all be available for a script to move successfully between systems.

Java commonly compiles to bytecode executed by a Java Virtual Machine. OpenJDK is an open-source Java implementation. Real language systems can combine compilation and interpretation; these labels explain the main route, not a rule that every implementation works identically.

C remains the kernel's main language. Java and JavaScript have similar names but are different languages. Choosing JavaScript for a browser's interactive controls does not imply using Java or a JVM. Choosing Python for automation still requires checking the libraries and operating-system features that the script uses.

You can learn Linux while keeping your current operating system. Choose the setup by what you need to practice, how much memory is available, and whether you need to see a full installation and boot process.

Compare the options

A VM runs as a guest alongside a host operating system. Desktop tools include VirtualBox, VMware Workstation Pro, VMware Fusion, UTM, and GNOME Boxes. Desktop-hosted virtualization is commonly called type 2; type 1 platforms such as Hyper-V, ESXi, Xen, and KVM provide virtualization at the hardware level. A desktop management interface does not alone tell you the architecture of its hypervisor.

VirtualBox's base package is GPLv3. VMware Workstation Pro is proprietary even though it has been free for all uses since November 2024. As with other software, price and license freedoms differ.

Match the image to the processor

Intel and AMD 64-bit PCs normally use x86-64, commonly labeled amd64. That label includes Intel processors. Apple silicon Macs and ARM-based Windows laptops use ARM64, labeled arm64 or aarch64.

For normal hardware virtualization, match guest and host architecture. An ARM64 host does not directly execute an x86-64 guest image. Emulation can translate a different architecture but is slower. Intel VT-x or AMD-V must be enabled in PC firmware for hardware virtualization used by VMs and WSL 2.

Work through a choice

A learner has an Apple silicon Mac and wants to practice the Linux installer, rebooting, and a desktop. First, those tasks require a complete guest system, so a VM fits. Next, the processor requires an ARM64 image. Then choose a hypervisor with ARM Linux support, such as UTM or a suitable current VirtualBox release, and leave enough memory for macOS.

A Windows learner who mainly wants shell practice can start with WSL. A person checking a laptop's Wi-Fi and graphics before installation can use a live USB. A container supplies Linux userspace but shares a kernel and normally omits a full boot process, so it does not cover the same practice as a VM.

Know the boundaries

VM changes normally stay on virtual disks, but writable shared folders expose host files to the guest. A snapshot can undo a practice mistake within the VM. Cloud resources need separate attention: deleting a VM may leave billable disks or other resources, so check the provider's resource list afterward. Back up important data before any dual-boot partition changes.

A VM lets you install a complete Linux system on a virtual disk. Work through the image, resources, installer, and first updates in order. Each stage answers a different question: is the image trustworthy, will it fit, and is the installed system ready?

Download and verify the image

Download an ISO from the distribution's official website. Match the desktop or server edition and the architecture to your plan. An ISO represents installation media; a cloud image is usually a prepared system disk for automated setup.

Calculate your download's SHA-256 checksum and compare the entire value with the published checksum. Example commands for an image named file.iso are:

• Linux: sha256sum file.iso
• macOS: shasum -a 256 file.iso
• Windows PowerShell: Get-FileHash file.iso

A mismatch means the copy is damaged or altered: discard it and download again. A match establishes equality with the file described by that checksum. It does not prove that a checksum copied from an untrusted website is genuine. Verify the distribution's signature on the checksum file using its authentic published key. GPG performs this signature check.

Create a VM that fits

Select the ISO in the VM tool and allocate processors, memory, and a virtual disk. For Ubuntu Desktop 26.04, the published comfortable minimum is a dual-core processor, 6 GB RAM, and 25 GB storage. Server editions and lighter desktops need less. Leave enough memory and storage for the host as well.

For example, a 16 GB host allocating 6 GB to a guest leaves 10 GB for the host. A dynamically allocated 40 GB virtual disk does not reserve 40 GB immediately; it grows as data is written, up to that maximum. It still needs real free disk space as it grows.

Start with NAT networking for ordinary practice. The guest can reach the internet through the host, while unsolicited direct access from the local network is not normally provided. Bridged mode puts the VM on the local network with its own address when other machines need to reach it.

Run the installer

Choose language, keyboard, and time zone. Check that the selected target is the VM's new virtual disk before choosing an erase-disk installation. Create a user and a strong password; enable disk encryption if appropriate. Finish installation, reboot, and detach the ISO so the next boot uses the installed system.

An installer appearing again after reboot often means the ISO is still attached and selected for startup. A failure on an ARM64 computer with an amd64 image calls for the correct image, not more guest memory.

Prepare a clean starting point

Install available updates. Add the hypervisor's guest tools, such as VirtualBox Guest Additions or VMware's open-vm-tools, for features such as screen resizing. Shared clipboards and folders may be enabled through these tools; enable access only for the files you need.

Take a snapshot of the updated system before experiments. It saves a state to return to, but remains tied to the VM's storage. Keep a separate backup of important work. If the host disk fails, a snapshot stored on that disk fails with it.

WSL runs Linux distributions alongside Windows applications. WSL 2 uses a real Linux kernel in a lightweight VM managed by Windows. You get a Linux environment without manually creating virtual hardware or following a normal Linux installer.

Install and create a Linux account

The simple install route requires Windows 10 version 2004, build 19041 or later, or Windows 11, with hardware virtualization enabled. Use a supported Windows release for ongoing security updates. Open PowerShell as administrator and run:

wsl --install

Restart when asked. This enables the required features and normally installs Ubuntu. When Ubuntu first starts, create its Linux username and password. These belong to that distribution and do not have to match your Windows account.

In Ubuntu, the initial package update is:

sudo apt update
sudo apt upgrade

The first command refreshes package information; the second installs available package upgrades. If sudo asks for a password, use the Linux account password.

Recognize the management commands

Suppose the list shows * Debian Stopped 2. Debian is the default distribution because of the asterisk. It is currently stopped, and it uses WSL 2. The number is not the Debian release number. Setting a default WSL version does not convert every existing distribution.

Keep file locations clear

Inside Linux, Windows drive C: appears at /mnt/c. A Windows file at C:\Users\Ana\notes.txt is reachable as /mnt/c/Users/Ana/notes.txt. File Explorer can reach Ubuntu's Linux files through \\wsl.localhost\Ubuntu.

For work performed by Linux tools in WSL 2, store project files in the Linux file system, such as the Linux home directory. Frequent access across the Windows/Linux file-system boundary can be much slower. WSL installation stores the distribution in a virtual disk file, but tools with access to mounted Windows files can still change those files.

Know what WSL does and does not expose

WSL 1 translated Linux calls and did not provide a real Linux kernel. WSL 2 does. Current WSL supports systemd and graphical Linux applications in Windows windows. Microsoft maintains the kernel used by this environment, and WSL itself was open-sourced under MIT in May 2025.

WSL does not provide normal practice with a Linux installer, boot loader, or a full desktop installation. Direct hardware access also differs. Use it for tools, scripting, and many services; choose a full VM when the learning task is installation and booting.

A practice system is still connected to real accounts, files, and networks. Build protection into the setup: use strong credentials, limited rights, current software, and the right protection for stored and moving data.

Make credentials hard to reuse or steal

Use a long, random, unique password for each account. A password manager such as KeePassXC or Bitwarden generates and stores these in an encrypted vault. Protect the vault with a strong master password that is not reused elsewhere.

Random selection matters. Four words chosen independently from a list of 7,776 give about 3.7 quadrillion possibilities; six give about 2.2 × 10²³. A familiar quotation does not have the same strength because it is not a random selection. Adding one bit of uncertainty doubles the search space.

Multi-factor authentication (MFA) combines different kinds of evidence, such as a password and a hardware key or authenticator. Two passwords are still the same kind of factor. Enable MFA for important accounts, particularly email and cloud accounts.

A passkey uses a cryptographic key pair instead of a shared password. The service has the public key; the private key stays with your device or credential manager. A fingerprint, face, or PIN unlocks its use. Passkeys are bound to the service, which protects against entering a reusable secret into a fake website.

Limit rights and maintain the system

Work in a regular user account and use sudo only for tasks that need administrator rights. Working permanently as root gives every program and mistake broad control. Keep the distribution updated and move to a supported release before EOL.

Use trusted software sources and verify installation images. An open-source license allows inspection but does not mean every copy from any website is safe.

Match encryption to the risk

Linux commonly uses LUKS for disk encryption; Windows uses BitLocker and macOS FileVault. Encryption at rest protects stored data from someone without the key. It does not replace backups or secure an account already unlocked for an attacker. If recovery keys and passwords are lost, encrypted data can become unrecoverable.

Handle devices and secrets deliberately

Do not connect USB devices of unknown origin. Some carry malware; others can pretend to be keyboards. Encrypt portable drives holding sensitive files because they are easily lost.

Keep passwords, API keys, and SSH private keys out of public code, shared screenshots, and forum posts. An SSH public key can be shared with a server; its private partner must remain secret. For a cloud practice server, use SSH keys, expose only needed network ports, and remove resources after use. Protect host files shared with a VM or reachable from WSL with the same care as other files.