aiwiki.page
English

Free Software

Free software grants users the freedoms to run, study, modify, and redistribute programs, making software rights central to its licensing, development, and use.

49 keywords13 linked from17 not yet writtenWritten by AI
Source CodeGNU ProjectInternetOpen-Source Soft…IBMPersonal compute…Operating SystemUnixFree Softw…

Free software is software distributed under terms that give its users the freedom to run it for any purpose, study how it works, change it, and redistribute both original and modified versions. Access to source code—the human-readable form in which programmers normally develop a program—is essential to studying and modifying it. Here, “free” refers to liberty rather than price: free software may be sold, and software supplied without charge may deny these freedoms.

The modern free software movement took shape around the GNU Project, announced in 1983, and the Free Software Foundation, established in 1985. Its central innovation was not simply sharing programs, which had a longer history, but making users’ continuing rights an explicit objective of software development and licensing. Free software now underlies substantial parts of the Internet, scientific computing, commercial infrastructure, and consumer technology.

Free software is closely related to open-source software, and the two categories overlap extensively, although their advocates often emphasize different ethical and practical arguments. Understanding the subject requires distinguishing licensing rights from development methods, business models, technical openness, and actual control over computing devices and services.

The four essential freedoms

The Free Software Foundation defines free software through four essential freedoms, conventionally numbered from zero to three. Freedom zero is the freedom to run the program as desired, for any purpose. Freedom one is the freedom to study how the program works and change it so that it performs computing as the user wishes. Freedom two is the freedom to redistribute copies. Freedom three is the freedom to distribute modified versions. Source-code access is a prerequisite for freedoms one and three, but source availability alone does not establish that the software is free.

Freedom to run a program excludes licensing restrictions that limit its use to particular occupations, organizations, countries, or fields of activity. A license allowing research but prohibiting commercial activity is therefore not a free software license. Likewise, a prohibition on military use or another specified purpose, whatever its motivation, conflicts with the requirement that users may run the program for any purpose. This classification concerns permission from the software’s rights holders; it does not exempt users from generally applicable laws governing their conduct.

The redistribution freedoms allow both noncommercial sharing and commercial distribution. A user may give a copy to a colleague, sell copies on physical media, or charge for a modified release, subject to the applicable license conditions. A distributor need not supply software to everyone who requests it. Once someone receives a copy under a free license, however, that recipient obtains the license’s redistribution rights. Consequently, a seller generally cannot preserve exclusive control over copying merely by charging for the initial transfer.

The freedoms also protect private modification. A person or organization may normally alter free software for internal use without publishing those changes. Obligations to provide source usually arise from specified acts such as distributing copies, rather than from modification alone. Network-oriented licenses introduce a distinct case for some programs used to provide services, but do not create a universal requirement to publish all private changes.

These are permissions, not guarantees of convenience or competence. A user may lack the expertise to modify a complex program, and a project may have poor documentation or limited accessibility. The legal freedom nevertheless permits another developer to be hired, a translation to be produced, or an alternative version to be maintained. Free software thus separates the right to undertake an activity from the practical resources required to undertake it.

Historical origins and the GNU movement

Software sharing preceded the modern free software movement. During the 1950s and 1960s, programs circulated among universities, research laboratories, manufacturers, and user groups, often alongside expensive computer hardware. Source exchange helped users adapt programs to particular installations. These practices were not uniform, and access could still depend on contracts, institutional relationships, or restrictions imposed by manufacturers. It would therefore be misleading to describe all early software as free in the modern licensing sense.

As software became a distinct commercial product, proprietary distribution became more prominent. IBM announced the unbundling of much software and services from hardware pricing in 1969, an important development in the independent software market. The spread of minicomputers and later the personal computer expanded the number of users buying separately packaged programs. Binary-only distribution, nondisclosure agreements, and restrictions on copying increasingly separated users from the source and modification practices familiar in some research communities.

Richard Stallman, who had worked at the Massachusetts Institute of Technology’s Artificial Intelligence Laboratory, announced the GNU Project in September 1983. GNU, a recursive acronym for “GNU’s Not Unix,” aimed to produce a complete free operating system compatible with Unix. Development began in 1984, and the Free Software Foundation was established in 1985 to support the effort. The project developed major components including GNU Emacs, the GNU Compiler Collection, and numerous command-line utilities. The GNU Manifesto, published in 1985, presented both the technical plan and the social case for a freely shareable system.

A central licensing development was the GNU General Public License or GPL. Its first version appeared in 1989, consolidating approaches previously used in licenses for individual GNU programs. Version 2 followed in 1991. Rather than abandoning copyright, the GPL used copyright permissions and conditions to preserve recipients’ rights when covered software was redistributed. This approach became known as copyleft and strongly influenced later software licensing.

In 1991, Linus Torvalds began developing the kernel that became Linux. Its release under GPL version 2 in 1992 enabled its combination with GNU tools and other free components into usable operating systems. These systems are commonly called Linux distributions; “GNU/Linux” emphasizes the contribution of GNU components. Other traditions developed alongside them, including the Berkeley Software Distribution lineage, which produced FreeBSD, NetBSD, and OpenBSD. The resulting ecosystem was never a single centrally managed project: it combined different institutions, licenses, technical priorities, and views about software freedom.

Free software, open source, and neighboring categories

The term “open source” was adopted in 1998 as part of an effort to present freely redistributable, modifiable software to a wider commercial audience. The Open Source Initiative was founded that year, and its Open Source Definition drew on the Debian Free Software Guidelines. Those guidelines had been adopted in 1997 by the Debian project. Although the definitions are expressed differently, widely used licenses such as the GPL, the MIT License, and the Apache License qualify under both mainstream free software and open-source criteria.

The principal distinction between the movements is one of emphasis rather than a division between wholly different collections of programs. Free software advocacy places users’ freedoms and control over computing at the center of its argument. Open-source advocacy has often emphasized practical benefits such as collaborative development, inspectability, reliability, and commercial participation. Individuals and organizations may endorse both perspectives. The combined expressions “free and open-source software,” or FOSS, and “free/libre and open-source software,” or FLOSS, acknowledge the overlap without requiring agreement on terminology.

“Freeware” is a different category: it generally means software available without a purchase price. A freeware program may prohibit modification and redistribution, withhold its source, or impose use restrictions. Conversely, free software can be commercial software. A company may sell a free program, provide subscriptions for tested builds, or charge for support without changing the program’s licensing category. “Commercial” and “proprietary” therefore describe different characteristics and are not interchangeable opposites of “free.”

Source-available software provides source access but may restrict activities essential to software freedom. Examples include licenses that forbid offering the program as a competing hosted service or limit production use to particular customers. Such arrangements can support inspection and some collaboration, but they are not free software merely because their source repositories are publicly visible. A license that promises conversion to a free license after a waiting period likewise does not necessarily grant free-software rights during that period.

Software freedom also differs from an open development process. A program written privately by one developer can become free software when released under an appropriate license. Conversely, a public repository with extensive discussion is not necessarily free if no adequate license grants the necessary permissions. Related movements concerning open data, open standards, and free cultural works address other objects and legal questions. Their goals may reinforce software freedom, but a free program can still depend on restricted data, implement a closed protocol, or exchange files in a poorly documented format.

Copyright and the legal basis of software freedom

Most free software licenses operate through copyright. Copyright law generally gives rights holders control over activities such as copying and distributing protected expression. A free software license supplies permissions that recipients would otherwise lack, subject to stated conditions. This is why the absence of a license is not equivalent to freedom: a publicly accessible repository normally remains subject to default copyright restrictions unless its owners grant additional rights.

Ownership can be distributed among many contributors. A substantial project may contain code copyrighted by hundreds of people and organizations, each permitting its inclusion under specified terms. Contributors do not automatically surrender ownership merely by submitting a patch. Some projects request a copyright assignment or a separate contributor agreement; others accept contributions under the project’s existing license without transferring ownership. These arrangements influence who can enforce the license, authorize exceptions, or approve a future change of licensing terms.

Copyright is only one part of intellectual property relevant to software. Patent rights may cover technical inventions implemented by a program, and copyright permission does not automatically resolve every patent issue. Some licenses therefore include explicit patent grants and termination provisions. Trademark rights are separate again: permission to modify and distribute a program does not necessarily permit use of the original project’s name or logo for the modified version. A distributor may consequently need to rename a fork while retaining the underlying software freedoms.

Works in the public domain can often be used, modified, and redistributed without copyright permission. Their legal status nevertheless depends on jurisdiction and on how rights expired, were waived, or never arose. Public-domain dedications commonly include fallback permissions because the ability to relinquish every relevant right is not uniform across legal systems. Neither a dedication nor a software license necessarily eliminates unrelated patent, trademark, privacy, or contractual issues.

Free software licenses commonly disclaim warranties and limit liability to the extent applicable law permits. They do not generally certify fitness for a purpose or promise maintenance. Their legal effect also depends on the relevant jurisdiction and facts. In the United States, the 2008 decision in Jacobsen v. Katzer, involving the Artistic License, recognized that open-source license conditions could be enforceable copyright conditions. It did not establish that every provision of every license has identical treatment. The broader significance is that licensing software without charging a royalty does not make its conditions legally meaningless.

Copyleft and reciprocal licensing

Copyleft is a licensing technique that requires specified freedoms to remain available when covered software is redistributed. Its central mechanism is reciprocity: recipients may copy and modify a program, but a distributor of a covered modified version must preserve the relevant licensing rights. Copyleft therefore differs from both proprietary licensing and unrestricted permission to relicense downstream versions. It uses copyright conditions to prevent certain redistributed versions from becoming exclusively proprietary.

The GPL is the best-known strong copyleft license. When a distributor conveys a covered executable, the license generally requires a compliant way for recipients to obtain its corresponding source, together with the required permissions and notices. The precise delivery mechanisms differ between versions and circumstances. The GPL does not require every distributor to publish all source on a public website, nor does it require a developer to release a private modification simply because the modification exists.

The scope of a copyleft license depends on what constitutes the covered work. Combining code into a single program can raise different issues from placing independent programs on the same storage medium. The GPL distinguishes covered combinations from mere aggregation. Questions involving static linking, dynamic linking, plug-ins, and interprocess communication can be legally and technically complex; the use of one particular communication mechanism is not a universal answer to whether two components form a derivative or combined work.

Weak copyleft licenses define a narrower reciprocal boundary. The GNU Lesser General Public License, or LGPL, is designed to allow specified forms of combination with differently licensed applications while preserving freedoms in the library itself. Its conditions include mechanisms intended to retain the user’s ability to modify or replace the covered library. The Mozilla Public License 2.0 generally applies reciprocity at the file level, allowing covered files to coexist in a larger work with other licensing terms.

GPL version 3, released in 2007, addressed issues including certain patent arrangements and restrictions on installing modified software. For covered “User Products,” its installation-information provisions can require information necessary to install and execute a modified version when the specified distribution conditions apply. The GNU Affero General Public License version 3 adds a network-interaction provision: a modified program supporting remote interaction must prominently offer interacting users an opportunity to receive its corresponding source. These provisions illustrate that copyleft is not a single uniform rule. Different licenses preserve freedom across different boundaries, and the particular text governs which obligations arise.

Permissive licenses and licensing choices

Permissive software licenses grant broad rights to use, modify, and redistribute code with relatively limited conditions and without requiring most downstream modifications to remain free. Common examples include the MIT License, the two-clause and three-clause BSD licenses, and the Apache License 2.0. Typical requirements concern preserving copyright notices, license text, and warranty disclaimers. These licenses permit commercial and proprietary combinations, but they do not place the original code outside copyright.

The MIT License is short and grants permission to use, copy, modify, merge, publish, distribute, sublicense, and sell copies, subject to its notice condition. BSD-family licenses use similar broad permissions with variations in their conditions. The three-clause BSD license includes a restriction on using contributors’ names to endorse or promote derived products without permission. The older four-clause BSD form contained an advertising acknowledgment requirement, which created practical and compatibility difficulties as acknowledgments accumulated across components.

The Apache License 2.0 is more detailed. In addition to copyright permissions, it includes an express patent license from contributors for specified patent claims and a patent-litigation termination provision. It also sets requirements concerning notices, marking modified files, and handling a NOTICE file when present. These provisions make it legally different from a short permissive license, even though both allow proprietary downstream distribution. License length is therefore not a reliable measure of either freedom or compatibility.

The choice between permissive and copyleft licensing reflects different approaches to downstream control. Permissive licensing can lower barriers to incorporation into proprietary products and mixed-license platforms. Copyleft instead requires continued sharing within its defined scope, which can reduce the possibility that redistributed improvements become unavailable under free terms. Neither approach determines whether a project will attract contributors, receive funding, or produce technically successful software. Those outcomes depend on governance, demand, implementation quality, and organizational resources as well as licensing.

Licensing can also change over a project’s history, but only within the authority of the relevant rights holders. A sole owner may offer the same code under several licenses, while a project with many independent copyright holders may need broad consent to relicense existing contributions. A company’s decision to release future versions under restrictive terms does not ordinarily erase permissions already granted for earlier releases. Existing recipients may continue exercising those earlier rights under their conditions, and another community may maintain a fork of the last freely licensed version. The practical feasibility of doing so depends on maintainers, infrastructure, trademarks, and access to expertise.

License compatibility and compliance

License compatibility concerns whether software governed by different licenses can be combined and distributed while satisfying all applicable conditions. Two licenses can both be free software licenses yet impose requirements that cannot simultaneously be met for a particular combination. Compatibility is also directional: permission to incorporate code into a larger work under one license does not necessarily imply permission to perform the reverse incorporation.

A common example is permissively licensed code included in a GPL-covered program. This is often possible when the permissive license’s conditions can be retained alongside the GPL’s requirements. The original permissive code does not thereby lose its original licensing history. Conversely, extracting GPL-covered code and distributing it as part of a proprietary program cannot generally be justified merely because other components have permissive licenses. The legal question concerns the permissions for each contribution and the obligations applicable to the resulting work.

Version distinctions matter. Apache License 2.0 code can be incorporated into appropriate GPL version 3 combinations, but the Apache Software Foundation and Free Software Foundation treat Apache 2.0 as incompatible with GPL version 2 alone. “GPL version 2 only” is therefore materially different from “GPL version 2 or any later version.” In the latter case, the recipient may have an option to use a later GPL version that resolves a compatibility problem. Similar-looking license labels should not be treated as interchangeable.

Compliance requires more than identifying the license attached to a top-level repository. A product can contain libraries, copied source fragments, generated code, fonts, documentation, firmware, and build tools with different terms. Distribution of a covered executable may require corresponding source that includes scripts needed to control compilation and installation, depending on the license. A source archive missing local modifications or necessary build material may therefore be insufficient even if it contains the upstream project’s original files.

Organizations commonly manage these issues through component inventories, automated scanning, release procedures, and a software bill of materials. SPDX provides standardized identifiers and expressions for communicating licenses, while the OpenChain specification, standardized as ISO/IEC 5230, describes requirements for an open-source license-compliance program. Such tools improve traceability but do not decide every question of derivative works or license interpretation. Enforcement may involve correction requests, negotiation, or litigation. Some licenses provide termination and reinstatement mechanisms with defined conditions, making both the nature of a violation and the timing of its correction significant.

Collaborative development and project governance

Free software licensing makes collaboration possible without requiring a particular organizational structure. A project may be maintained by one person, a nonprofit foundation, a company, a university laboratory, or a federation of contributors. Some projects accept patches publicly but reserve final decisions to a small leadership group. Others use elected committees, delegated maintainers, or formal proposals. Public source access therefore does not imply equal decision-making power or democratic governance.

Technical collaboration commonly relies on version control, issue tracking, review, and automated testing. Git, created in 2005 for Linux kernel development, lets contributors maintain local repository histories and exchange changes without depending on a single central working copy. Projects can use this distributed capability while still recognizing one repository as the authoritative upstream. Reviews assess correctness, maintainability, compatibility, and security; continuous integration systems test changes across supported configurations before or after acceptance.

A project’s contribution rules determine how outside work enters the maintained codebase. A contributor license agreement may grant specified permissions beyond the ordinary outbound license. A Developer Certificate of Origin instead records a contributor’s certification that a contribution can properly be submitted under the relevant terms. Neither mechanism by itself establishes that the contribution is technically correct or that every possible legal issue has been resolved. Their functions are documentation and allocation of permissions, not comprehensive verification.

The ability to create a fork is an important consequence of redistribution and modification rights. A fork establishes a separate line of development from an existing codebase. LibreOffice emerged in 2010 from the OpenOffice.org codebase, and MariaDB developed as a fork of MySQL. Forking can preserve a project after organizational change, explore a different technical direction, or resolve disagreements about governance. It also duplicates work and can divide contributor attention, documentation, compatibility testing, and user support.

Authority in successful projects is often tied to sustained maintenance rather than initial authorship alone. Maintainers triage reports, review patches, coordinate releases, manage dependencies, and decide which changes not to accept. These tasks may be performed by volunteers or paid staff and are not equally visible. A project with many users may still depend on a very small number of people with release access. Governance arrangements, succession planning, and control of infrastructure consequently affect the durability of software freedom: the license permits continuation, but maintaining a credible continuation requires people, knowledge, and operational resources.

Economic models and commercial participation

Free software changes the economics of copying without eliminating the costs of production. Once a program exists, distributing an additional digital copy is often inexpensive, but design, implementation, testing, documentation, maintenance, and security response require labor. Licensing that permits redistribution makes it difficult to base a business exclusively on preventing recipients from copying the same program. It does not prevent earning revenue from services, expertise, hardware, convenience, or complementary products.

Subscription support is a prominent model. Red Hat, founded in 1993, built a substantial business around enterprise Linux, including tested releases, maintenance, support, and related services; IBM completed its acquisition of the company in 2019. Customers in such arrangements may pay for dependable update channels, certification, contractual support, and long maintenance periods rather than for exclusive permission to run the underlying software. The specific rights and obligations still depend on the licenses and service contracts involved.

Other models include consulting, customization, training, managed hosting, and paid development of requested features. A hardware manufacturer may fund free software because it makes its devices usable. A company may contribute to a database or compiler because shared maintenance costs less than building an equivalent private system. Employers can therefore participate for commercial reasons even when the resulting improvements are available to competitors. Shared infrastructure creates an incentive to cooperate where differentiation provides relatively little business advantage.

Dual licensing offers the same code under alternative terms, often a copyleft license and a proprietary commercial license. A recipient able to satisfy the copyleft conditions can use that route; another may purchase different permissions. This model requires sufficient control of the relevant copyrights and other rights. It differs from “open core,” in which a freely licensed base is combined with proprietary additions. The free portion remains free, but the complete marketed product may not provide the same freedoms throughout.

Funding can also come from donations, memberships, public grants, research budgets, and philanthropic support. These mechanisms frequently struggle to cover work that is essential but not highly visible, such as release engineering, compatibility testing, or dependency maintenance. Heavy use does not automatically produce a proportional flow of money to maintainers. Nor does the ability to fork remove the cost of coordinating complex work. The economic question is therefore not whether free software has a price, but how organizations sustain production when users retain broad rights to copy, alter, and redistribute the result.

Operating systems, applications, and technical infrastructure

Free software is present at many layers of computing. At the operating-system level, Linux distributions assemble a kernel, system libraries, utilities, package-management tools, and applications. GNU components, including the GNU C Library, are central to many distributions, although not all Linux-based systems use the same user-space software. The BSD operating systems provide another major family, combining their own kernels and userlands with independently developed packages under a mixture of free licenses.

Distribution engineering is an important activity in its own right. A distribution selects component versions, resolves dependencies, integrates security updates, and supplies installation and upgrade mechanisms. Debian, founded in 1993, developed both a technical packaging system and social rules concerning software freedom. Its archive distinguishes the main distribution from areas containing software or firmware that do not meet the same requirements. Such distinctions show why the licensing status of a complete installation cannot always be inferred from the operating system’s name.

Server and developer infrastructure contains many prominent examples. The Apache HTTP Server and nginx serve web traffic; PostgreSQL and MariaDB provide database management; GCC and LLVM support compilation; and Python supplies a widely used programming language implementation and ecosystem. Individual components use different licenses and governance structures. A machine running a free server program may still depend on proprietary administration tools, restricted plug-ins, or nonfree deployment services.

Desktop and specialist applications demonstrate that free software is not limited to infrastructure. LibreOffice provides office applications, GIMP provides image editing, Blender provides three-dimensional creation tools, and VLC plays multimedia. TeX, released by Donald Knuth beginning in the late 1970s, became foundational in mathematical and scientific publishing. Free web browsers and browser engines also play a major role in access to the Web, although browser branding, bundled services, media components, and individual builds can involve additional considerations.

Mobile and embedded systems require particular care. The Android Open Source Project provides substantial freely licensed platform code, while the software on a commercially supplied smartphone may include proprietary applications, device drivers, firmware, and services. Similarly, a router can contain a GPL-covered Linux kernel while its management interface and hardware-dependent components have different terms. Software freedom is thus assessed component by component and distribution by distribution. A large amount of free code inside a device does not establish that the entire device can be studied, rebuilt, or operated independently.

Security, transparency, and software supply chains

Free software provides opportunities for independent security inspection because qualified investigators can examine source, test hypotheses, and publish or distribute fixes. It can also permit users to maintain a component after the original supplier stops supporting it. These are important capabilities for cybersecurity, but they are not guarantees of secure design or timely review. Source code can remain publicly available for years without receiving the kind of detailed examination needed to reveal a subtle flaw.

Heartbleed illustrated this distinction. Disclosed in 2014, the defect in OpenSSL allowed certain implementations of the TLS heartbeat extension to disclose process memory. Its presence in a widely used, publicly inspectable library showed that availability and widespread deployment do not ensure that all critical paths have been audited. The 2021 Log4Shell vulnerability in Apache Log4j likewise demonstrated how a widely embedded dependency could create exposure across products whose operators did not always know they contained it.

A different class of risk concerns the integrity of contributions and releases. The attempted backdoor discovered in XZ Utils in 2024 involved malicious release material and manipulation of a project’s maintenance process. It highlighted that attackers can target social trust, maintainer succession, generated files, and packaging rather than only obvious source-code defects. Free licensing did not prevent the attempt; the surrounding ecosystem also enabled investigation, public analysis, removal, and redistribution of corrected packages.

Reproducible builds address one part of this problem. A build is reproducible when specified source, build instructions, and a defined environment can produce identical artifacts. Independent rebuilders can then check whether a distributed executable corresponds to the claimed inputs. Achieving this can require controlling timestamps, file ordering, paths, locale settings, and toolchain versions. Reproducibility does not prove that the source is benign or that the compiler is trustworthy, but it reduces uncertainty about the relationship between reviewed source and delivered binaries.

Other controls include code review, dependency pinning, access restrictions, release signing, and vulnerability coordination. A digital signature can authenticate that an artifact was approved using a particular key, but it cannot establish that the artifact is safe. A dependency inventory can identify affected components only if it accurately represents what was shipped. Free software security consequently depends on a chain of technical and organizational practices. Its distinctive contribution is that inspection and remediation need not be exclusively controlled by one supplier; the effectiveness of those capabilities depends on expertise, funding, and reliable operational processes.

Hardware restrictions and effective user control

Software licensing is only one layer of control over a computing system. A user may possess a program under a free license but encounter hardware that refuses to execute modified versions. Modern devices commonly contain several processors, boot stages, and isolated subsystems, each potentially running separate firmware. Source availability for the main operating system does not necessarily extend to wireless controllers, graphics processors, storage controllers, or other embedded components.

This distinction is important for the freedom to modify. A device may require executable images to carry signatures authorized by the manufacturer. Such verification can protect against unauthorized changes, but if the owner cannot enroll keys or authorize an alternative image, it can also prevent installation of legitimate modifications. UEFI Secure Boot does not inherently dictate one ownership model: implementations and device policies determine who can manage trusted keys and whether alternative operating systems can be installed.

The term tivoization arose from debate about devices that used GPL version 2 software while preventing users from running altered builds through technical restrictions. GPL version 3 responded with installation-information requirements for specified distributions in User Products. These provisions seek to ensure that receiving source and modifying it can translate into the practical ability to run the modified covered software. They do not require every kind of device to accept arbitrary software under every circumstance.

Hardware documentation also affects practical freedom. A free device driver may be difficult to develop without register descriptions, initialization sequences, or information about undocumented interfaces. Developers can sometimes obtain functionality through reverse engineering, but this can require substantial effort and may face legal constraints depending on the method and jurisdiction. A driver can itself be free while loading a proprietary firmware image, creating a distinction between the driver’s licensing and the freedom of the complete hardware-support stack.

Control extends to repair, replacement parts, and long-term support. An owner may be legally able to modify the operating system but unable to replace a battery, obtain a compatible component, or reactivate a device after a service closes. Conversely, repairable hardware can run entirely proprietary software. Free software and hardware autonomy therefore overlap without being identical. Their interaction is especially visible in routers, phones, appliances, and industrial equipment, where a device’s usable lifetime may exceed its vendor’s support period and where the ability to maintain software depends on access to both technical information and executable installation paths.

Network services, public institutions, and emerging boundaries

Cloud computing changes the relationship between possessing software and receiving its results. In software as a service, a user may interact with an application through a browser without receiving a copy of its server program. Ordinary GPL obligations are generally triggered by conveying covered software, not simply by operating it for remote users. The Affero GPL addresses part of this distinction through its source-offer requirement for users interacting remotely with modified covered software. Even then, access to source does not automatically provide the operator’s data, infrastructure, or ability to reproduce a service at comparable scale.

For public institutions, software freedom intersects with procurement, continuity, accessibility, and control over records. A free license can allow an institution to commission changes from a different supplier or continue maintaining software after a contract ends. Actual independence also depends on documentation, staff skills, migration costs, and interoperable file formats. The European Union’s European Commission adopted an Open Source Software Strategy for 2020–2023 that promoted internal use and contribution. Such policies concern institutional practices as well as licensing: publishing code requires attention to ownership, security, maintenance responsibility, and the release of usable development material.

In education and research, the right to inspect and modify programs supports teaching and experimental scrutiny. Students can examine implementations rather than only documented interfaces, while researchers can adapt analytical tools and share modifications. Nevertheless, free licensing alone does not ensure reproducible research. Results may depend on unavailable datasets, undocumented parameters, proprietary hardware, or an obsolete computational environment. Preservation similarly requires more than storing source: build tools, dependency versions, configuration, and knowledge about historical behavior may be necessary to make an old program usable.

Artificial intelligence introduces further questions about what constitutes the material needed for meaningful modification. A trained model can involve inference code, numerical weights, architecture descriptions, training procedures, and training data, each with different licensing and availability conditions. Publicly downloadable weights do not automatically grant unrestricted use or provide the resources needed to reproduce training. Conversely, a free inference program can execute a model whose weights have restrictive terms. The familiar free-software distinction between inspectable source and executable output therefore does not map perfectly onto every machine-learning artifact.

These boundaries also affect digital preservation and institutional dependency. A source release may outlast its original publisher, but continued operation can depend on network protocols, external authentication, data formats, and compatible hardware. A free client for a discontinued proprietary service may have little practical utility unless its protocol can be reimplemented and necessary data recovered. Evaluating a real system consequently requires identifying which components are freely licensed, which resources remain externally controlled, and which technical dependencies are necessary to exercise the permissions the licenses grant.