osbmk/README

Documentation can be found on https://osboot.org/

osboot is free / open source *boot firmware* that initializes the hardware in
your computer and loads an operating system. It replaces the proprietary
BIOS/UEFI firmware commonly loaded onto a computer. osboot is compatible with
specific computer models that use the x86 architecture. User support is
available at #osboot on Freenode IRC.

osboot can boot all of the most popular operating systems such GNU+Linux,
BSD and even *Windows*. We recommend *free* operating systems (e.g. GNU+Linux)
that comply with GNU Free System Distribution:
https://gnu.org/distros/free-system-distribution-guidelines.html

*Boot firmware* is low-level software that executes when a computer is turned
on. It brings the components (CPU, memory controller, peripherals etc) to a
useful state enabling easy software development and/or usage. Boot firmware
usually loads an *operating system* which provides a unified interface for
application software.

osboot uses coreboot for hardware initialization.

*coreboot* is notoriously difficult to compile and install for most
non-technical users. There are many complicated configuration steps required,
and coreboot by itself is useless; coreboot only handles hardware
initialization, and then jumps to a separate *payload* program. The payload
program can be anything, for example a Linux kernel, bootloader (such as
GNU GRUB), UEFI implementation (such as Tianocore) or BIOS implementation
(such as SeaBIOS). While not quite as complicated as building a GNU+Linux
distribution from scratch, it may aswell be as far as most non-technical users
are concerned. In short, most people will not want to use coreboot for this
reason. The coreboot project is geared towards developers and therefore it
assumes that the user is highly technical, with deep knowledge of the hardware
and how computers work in general.

In other words, you can't simply download and install *coreboot*, just as you
can't simply download and install the *Linux kernel*, becasue it simply won't
work the way the user wants. osboot solves this problem in a novel way:
osboot is a *coreboot distribution* much like Debian is a *GNU+Linux
distribution*.

osboot integrates coreboot and several *payloads* such as GNU GRUB, SeaBIOS
and Tianocore. It provides an *automated* build system that downloads, patches
(where necessary) and compiles coreboot, GNU GRUB, SeaBIOS, Tianocore and all
the other software components needed to build a complete, working *ROM image*
that you can install, replacing your current BIOS/UEFI firmware, much like a
GNU+Linux distribution (e.g. Debian) provides an ISO image that you can use to
replace your current operating system (e.g. Windows).

osboot provides these payload choices:

* GNU GRUB (bootloader). This is the default on x86 (Intel/AMD) computers,
  capable of booting the majority of GNU+Linux and BSD operating systems. It
  has many advantages such as ability to load from encrypted partitions, verify
  GPG signatures of your Linux kernel and more. GRUB can additionally load and
  execute *any other coreboot payload*.
* SeaBIOS. This implements traditional x86 BIOS interrupts and services,
  allowing most legacy operating systems (e.g. older Windows versions or DOS)
  to be used.
* Tianocore. This implements UEFI services, allowing most modern operating
  systems to be used (e.g. Windows 10). Tianocore is less useful for free
  software users, because GNU GRUB boots GNU+Linux and BSD on its own, but it
  provides a familiar interface that a lot of people are already used to.

For each machine supported in osboot, separate ROM images are provided:
with GRUB payload (and Tianocore+SeaBIOS both selectable in the boot menu),
SeaBIOS on its own and other ROMs with Tianocore on its own. For most users,
we recommend using GNU GRUB.

Additionally, osboot provides utilities to install osboot (such as
flashrom), to configure it (e.g. cbfstool, ifdtool, me_cleaner) and user
friendly documentation aimed purely at non-technical users. If you simply want
to use the firmware, without getting too in-depth, osboot is for you!

osboot tries to provide updated releases on a regular basis, with tested ROM
images per machine supported.

Why use osboot?
------------------

Because you have rights. The right to privacy, freedom of thought, freedom
of speech and the right to read. In the context of computing, that means anyone
can use free software.

Simply speaking, free software is software that is under the direct sovereignty
of the user and, more importantly, the collective that is the *community*. osboot
is dedicated to the Free Software community, with the aim of making free software
at a *low level* more accessible to non-technical people.

Many people use proprietary boot firmware, even if they use GNU+Linux. Non-free
boot firmware often contains backdoors , can be slow and have severe
bugs. Development and support can be abandoned at any time. By contrast,
osboot is a free software project, where anyone can contribute or inspect
its code.

osboot is faster, more secure and more reliable than most non-free
firmware. osboot provides many advanced features, like encrypted
/boot/, GPG signature checking before booting a Linux kernel and more!
osboot gives *you* control over *your* computing.

How is osboot different versus Libreboot?
--------------------------------------------

osboot development started on December 11th, 2020, forked from the Libreboot
20160907 build system. osboot is similar philosophically
to Libreboot, but with one difference: Libreboot only allows support for boards
where the firmware can be 100% Free Software as per what is installed to the
boot flash. Libreboot complies fully with FSF/GNU criteria defining what *free
software* is.

osboot merely *prefers* this, but allows binary blobs. osboot will accept
any board that coreboot supports. The coreboot software supports literally
hundreds of computers, but on most of them it is not entirely free software,
but instead relies on added *binary blobs* typically provided by the hardware
manufacturers. E.g. `mrc.bin` for raminit (initialization of memory controller)
 and other initialization tasks.

It was started in response to a growing trend in the community: lots of people
are interested in Libreboot, but wish to use newer/faster hardware. Porting
Libreboot to newer Intel/AMD hardware is very difficult. Meanwhile, there
existed no user-friendly solution like Libreboot. osboot provides an easy,
automated build system and installation process, with user-friendly
documentation and professional user support backed up by years of experience
dealing with coreboot systems.

The entire motivation behind this *permissive* policy (in osboot) is that
it will lead to many more coreboot users, on all coreboot systems, especially
when more people join the osboot project as maintainers for various boards.
By increasing the ease of use and accessibility for a given coreboot system,
for *non-technical users*, it increases the amount *of* technical users because
more people learn about coreboot. This increases the number of people that can
provide *testing* for coreboot, and will very likely:

* Increase the number of coreboot developers, because some of those new users
  will become truly inspired
* More ability for coreboot developers to find individual testers for a given
  board (osboot makes it easy to maintain boards, on any given coreboot
  revision, with any collection of custom patches on top of that coreboot
  revision, for that board).

License can be found in COPYING and through parts of the source tree.

This readme is forked from the osboot home page on 11 March 2021