Bootstrapping a custom Debian Linux live boot distribution 13 Jan 2018 GLF ------------------------------------------------------------------------------------------ This documents the production of a custom live bootable and installable Linux OS image using a compatible computer, the Debian support ecosystem including standard repositories, and minimal external resources, without compromising any existing hard drive or file contents on that computer. The primary reference system described is "GLFPE for Linux" (GLF Programming Environment) but applies to other similarly built OS variants. Debian is chosen as the base OS for a number of practical reasons. The author has incrementally developed and proven the described methodology and uses it frequently to support and upgrade an OS image he uses for everyday work and programming development. Why Linux? ----------- Because Linux is cool. Linux is powerful. Linux is free. Linux is the embodiment of the hive mind of millions of cooperating volunteer users and developers who like using their computers the way THEY choose, not the way a commercial vendor tries to SELL them a way to use. And they like to share their work so others can use it. Why a live boot Linux? ----------------------- Live boot images are readily available on the internet for a variety of official Linux variants, such as Ubuntu, Fedora, Arch, Mint, and Debian. Live boot images (ISO files) can be easily copied to make bootable DVDs or USB drives, which in turn can boot up a PC-compatible computer (686-32 or AMD64) so that a user can try out an operating system without making any permanent commitments -- no installation is required. A live boot OS can run on a computer with an incompatible hard drive configuration, a corrupted hard drive, or even a system with no hard drive at all. All OS drive space within the live boot session is run out of the prestored contents of the live boot image, and whatever RAM is avaiable. Because the RAM is used as pseudo-disk space, it is important that enough RAM is available, at least 2 Gb for practical use. Most PC-compatible computers sold in the last 10 years can meet that specification. All these live boot images include installation options to allow a user to commit the same OS to the hard drive of a compatible PC if so desired. The official distributions can run many commonly desired applications from the get go. If a user does not require anything else, these official distributions may be a good fit. many applications are available which work essentially alike on all linux variants, but different OS distributions have different combinations of user interface design, applications, and OS features. The user may try different OS distributions and may find one which fits the user's stylistic and technical preferences. The primary advantage of using a live boot OS is that it is UNCHANGING. Every time you boot the same copy of the OS, you get the same environment. It cannot (easily) be altered by accidents of misconfiguration, malware, or unfortunate incompatibilities due to installation of problematic applications. When such events occur on an installed OS, the user might be confronted with a puzzling debugging session, arcane reconfiguation work, or even unbootable systems. That doesn't happen with a live boot OS. Just shut down, reboot, and problems gone, try again. The author likes to call it "Vegas Rules" for live boot -- whatever happens in Vegas, stays in Vegas. What if a user wants more than the official distributions provide? ------------------------------------------------------------------- Most users want to do more than just what everybody else is doing. They may play games, they may be programmers, they may process videos. They may control telescopes. If users need to add new, specialized, or merely upgraded apllications, Linux is still cool. The combined efforts of millions provide a vast array of freely distributed applications and specialty tools for various flavors of Linux. Every major Linux variant links to large repositories of tested, maintained software. Even commercial software is available in Linux flavors. If a user tries out a few Linux variants and likes one, he can install it to a comuter and upgrade it, extend it, and customize it at will. What if a user want to use a live boot Linux, but wants to add applications? ----------------------------------------------------------------------------- If a user (such as myself) wants to add specific applications or additional functionality to an otherwise acceptable official distribution, that is easily accomplished on an INSTALLED version. The installed OS can be readily kept up-to-date for security patches and upgrades, and can be customized with whatever applications, tools, and "eye candy" are desired by the user. However, customization is not so easy for a live boot image. The live boot startup environment is normally READ ONLY. An "overlay" provision is made to allow some changes to the underlying system by using RAM copies to override earlier "disk" versions of files in the startup system. From the user's viewpoint durting a session, the changes are made to the OS or the disk files temselves. However, on reboot all such cahnges are normally gone. Customizing a live boot system is usually made possible by adding features to the live system to allow "Persistent Storage", usually to a special file or partition recognized for this purpose by the OS. This usually doesn't work for read-only DVD boot disks, but can be enabled on a USB drive live boot system. If parsistence is enabled by the user, then any changes, installations, etc. made during a live boot session can be retained so that those changes are available on the next boot. If the number of additional applications, libraries, and/or custom configurations is large and arcane, however, this becomes cumbersome. Also, many such reconfigurations become repeatedly necessary whenever the official OS vendor releases a new or upgraded version. Persistence has advantages when a user is experimenting with new applications and libraries, but it has drawbacks. in general, one cannot upgrade the OS kernel components on a live boot system by persistence alone. Applications themselves may be upgradeable, but in most cases the underlying OS cannot be patched. Over time this becomes a reliabiility or security problem. Why a custom Linux live boot distribution? ------------------------------------------------ A custom distribution ("distro" or "remix"), is a custom live boot image, distributable as an ISO or other image file, which can be used to create a customized live boot OS disk, which works like an official distribution, but with expanded, extended, and/or customized content. If so many official live boot Linux OS options are immediately available, and all the maintenance work is performed by other people, why go through the effort of creating custom distributions? This is more of a "developer" issue than a "user" problem. If a user is satified with his live or installed Linux variant, fine. However, it is an attractive idea for some of us who have or maintain a large array of customizations to our preferred working environment to share that knowledge and/or effort with other potential users with similar interests. A live boot customized distribution can contain a large variety of specialized tools and applications to meet specific user needs. A programmer may want a programming environment complete with IDEs (individual Development Environments), support libraries, and diagnostic tools such as debuggers anbd file inspection utilities not needed by average users. A video producer might want audio and video manipulation and editing tools. An engineer or hobbyist might want CAD tools and 3D viewing tools. These interest groups may call for a complex set of library package installations and customized integration of toolsets. The official distributions are usually pared down to those applications seen to have broad appeal to keep ISO file sizes down for wider distribution. Custom images tend to grow significantly, so file sizes tend to be considerably larger than official ones. However, if a user finds the custom distribution has more of what he needs, then it may be worth the extra bandwidth to get the extra (hopefully tested) functionality. The author is a programmer and "maker movement" hobbyist, and has often been frustrated by the need to explain the dependencies of a particular source program on the underlying pile of assumed installed libraries, compilers, editors, maintenance tools, and OS necessary to maintain the code and get it to execute. Being able to distribute a working environment to maintain and run the code WITH the source code is an attractive concept. Since proprietary OSes such as Windows don't allow for such free ackaged distribution, Linux live boot is an obvious choice, so long as the code and its dependencies are portable. The author has spent several years trying multiple methods of live boot customization, progressing through Ubuntu, Linux Mint, and finally Debian OS bases. The author has long been interested in sharing this OS customization effort with a wider audience. How to customize a live boot Linux distribution? ------------------------------------------------- There are a number of methods to produce such a distro. The main ways to produce such a custom distribution are (the author has tried all but #1 on this list): 1) Build all the distribution content from "scratch" -- compile all applications and the linux kernel from available open source code, carfully constructing a working installation image, then convert the content into a live bootable ISO image. Advantages: The creator OWNS the OS distribution, it contains exactly what is desired, no more, no less, it is the most traceable and open methodology, it is uniquely satisfying on a pedantic level, no (likely) copyright or trademark issues. Disadvantages: Very hard, very esoteric in skills needed, VERY time consuming, NO official support from (or comparability to) any major OS vendor. Applicability of distribution to other PCs, CPUs, etc. is dependent on skills of creator and picky technical details -- a lot to master. Mostly the domain of the major OS vendors and uber-hackers. 2) Start with an official distribution, install it to a PC, extend it using the normal package maintenance prooducts and/or custom programs, then somehow repackage the installed content into a working live boot image. Advantages: The live boot image produced recreates the version of the operating system and its content as installed on the user's PC -- it can serve as an emergency backup of the installed OS for recovery purposes. Very easy to do if OS is supported. Disadvantages: OS vendor specific tools needed, perhaps unavailable (known to work for Ubuntu), can create live boot for specific CPU used on installed version only, can have vendor-specific trademark or copyright issues for distribution (Ubuntu and Mint in particular). Requires installation to hard drive to work, as well as significant workspace (about 25 Gb) free on the drive. Any configuration errors, driver mismatches, etc. transfer to live boot image. May not work on a different PC, so distribution is of limited value. 3) Start with an official distribution, extend it using persistent storage, then somehow convert the persistent combination to a live boot image. Advantages: The live boot image produced is an extended version of the original distribution, and the installation program (usually) works to install the extended version to a PC. It tends to work on other PCs because hardware support is not tied to the original production PC (as in method 2). The CPU must be compatible, which is less an issue if production is done on a 64-bit system (even if the OS is 32-bit). Distribution is less limited in value than method #2. Disadvantages: Experience shows not all application installs work properly using persistent storage method -- they somehow lose configuration data during live boot preparation. OS vendor specific tools needed, perhaps unavailable. Can have vendor-specific trademark or copyright issues for distribution (Ubuntu and Mint in particular). May (or may not) require auxiliary installation of a compatible version of the OS to an auxiliary computer to drive the production of the new version of live boot. Does not (apparently) support upgrading the underlying OS kernel, so system becomes increasingly obsolescent or unstable over time. Tools largely don't exist in fully working form (anymore -- old projects such as RemasterSys have been discontinued). Custom scripts must be developed and maintained to drive the process. May (or may not) require installation to hard drive to work, as well as significant workspace (about 25 Gb) free on the drive. Hard and wonky to do, with minimal support available via web search for technical problems. Frequently scripts fail to work with newer releases of the OS and need to do research and debugging to fix. 4) Start with an official distribution, extend it WITHOUT using persistent storage, but only by adding them using carefully crafted installation scripts, then somehow convert the combination to a live boot image. Advantages: (Usually) allows full upgrade of Linux kernel elements into the new live image. The live boot image produced is an extended version of the original distribution, and the installation program (usually) works to install the extended version to a PC. It tends to work on other PCs because hardware support is not tied to the original production PC (as in method 2). The CPU must be compatible, which is less an issue if production is done on a 64-bit system (even if the OS is 32-bit). Distribution is less limited in value than method #2. Disadvantages: OS vendor specific tools needed, probably unavailable. Can have vendor-specific trademark or copyright issues for distribution (Ubuntu and Mint in particular). May (or may not) require auxiliary installation of a compatible version of the OS to an auxiliary computer to drive the production of the new version of live boot. Does not (apparently) support upgrading the underlying OS kernel, so system becomes increasingly obsolescent or unstable over time. Tools largely don't exist in fully working form (anymore -- old projects such as RemasterSys have been discontinued). Custom scripts must be developed and maintained to drive the process. Even more custiomization of scripts necessary than method #3 to select components to install. Manual intervention may be required at various steps in the process. May (or may not) require installation to hard drive to work, as well as significant workspace (about 25 Gb) free on the drive. Hard and wonky to do, with minimal support available via web search for technical problems. Frequently scripts fail to work with newer releases of the OS and need to do research and debugging to fix. 5) (Currently recommended by author) Use an OS-supported tool to build a live boot image from scratch, not from source, but from the same precompiled binaries found in the package repositories. This is reportedly the SAME METHOD used by major OS vendors to produce their live boot releases, though the tools used may vary by OS vendor. Because both Ubuntu and Linux Mint are in turn built using underlying Debian components, the Debian "live-build" package methodology SHOULD work with each of those distributions. The author has chosen (since 2016) to use only the Debian distribution as the underlying live boot system for this method, because "live-build" is specifically made for and used by the Debian project, and because redistribution of Debian live boot images does not invoke the potential trademark and copyright issues which encumber redistribution of Ubuntu and Mint. This process (live build) uses unattended build scripts -- the ISO is created in batch mode without user attention once started (2-4 hours). The resulting ISO works JUST LIKE the official Debian release with equivalent specifications (which are actually available if you can find them in the right place). Obscure methodology, with arcane rules which take some time to master, but once correct, they stay correct, at least until the next version of live-build is released. Therefore the configurations are usefully redistributable, such that another user can recreate the rebuilding of an equivalent (or modified) live boot ISO. Most packages are installed by name from a list. Provisions are made to automate installation of nonstandard or custom packages and data. It is even possible to compile and install programs at build time using "hook" scripts. Advantages: Built from a (relatively small) configuration file set which can be freely redistributed and maintained across upgrade versions, allowing upgrade with minimal editing of configuration. ANY supported end user PC and GUI configuration can be specified with the right parameters and file contents (the author prefers and has tested Debian Mate). There are command-line tools for various configuration options which may speed up an initial custom setup, but copy-and-paste from older working configurations is usually sufficient and easier for maintenance. Installation from live boot is optional, and proven workable across multiple versions. Recently the author has worked out a completely "bootstrap" methodology for upgrading a live image, which does not require installation of the OS to a PCX to perform the build. Instead a USB "work drive" formatted to a Linux format (EXT4) is used to hold the build data. Therefore one can start with an official live ISO, and using nothing but a computer and USB work drives, customize and upgrade that official build into a new live ISO. As long as the computer can boot the live image (i.e. get past CPU and "Secure Boot" issues), one can "borrow" a computer to do the job, and leave behind no traces on or harm to the borrowed computer. Disadvantages: Large amount of transfer of data from internet to build packages, so good bandwidth is essential during the build. Errors in configuration tend to stop the script dead, so debugging may be frustrating until configuration is clean. Customization may require experimentation on built or installed systems, and possibly copying data from working systems into special configuration folders. Does the author practice what he preaches? ------------------------------------------- The author currently uses live boot Debian images everyday for almost ALL computer work, and strives to add new applications and tools to personal images often, so that all tools routinely used are available for live boot. The computer most often used by the author is an older desktop system with Windows XP installed, completely obsolescent for connection to the internet. The author daily boots from a current live boot USB stick and does whatever online and offline work he needs, using both internal and external USB drives for data storage and work product. Because of the live boot "Vegas rules", exposure to hackers is limited to The author occasionally wants to get to old XP applications and data without risk of malware from the internet, but without needing to unplug the LAN cable each time. By disabling the network drivers within XP to keep XP boots from "seeing" the internet, apps can't do anything risky and they don't get hacked while in XP mode. The author is a programmer of many years experience and an electronics hobbyist, and has built a custom Linux programming environment. The GLFPE (GLF Programming environment) is both a cross-platform concept (DOS/Windows/Linux) and a custom OS distribution suited to the author's own history of C/C++/Arduino source code. The author strives to maintain a combination of code base and tools which can be shared in working form with anyone interested. The author has recently begun expanding the base live image into subimages which address specific needs, including Windows workalike/emulation (using Wine) and PCB (printed circuit board) design (using KiCad). The author strives to update and upgrade GLFPE versions often, usually once per month or more. The author maintains a Google Drive repository of working configuration filesets and live boot ISO files, and has plans to share them via the internet as sooon as they can be properly documented. Hopefully, a series of Youtube tutorials can provide a link to the files so that interested users can find them once they see what to do with them. The author's intent is to distribute to others a working system for producing customized live boot debian environments. Each distributed ISO of GLFPE for Linux contains within itself the ability to "bootstrap" upgrade to a newer version of all specified applications and OS kernel. What does a bootstrap upgrade of GLFPE mean? -------------------------------------------- The concept of bootstrapping is to bring up a system in stages, using only a basic environment at first, then adding only stuff found within or near that environment, step by step in succeeding stages until a more complex system is up and running. Used in this context, it means we should only require a configuration file set, and an initial working Debian live boot image, which could be either a prior version of GLFPE, or even the original official Debian release disk to start. We boot the initial live boot disk on a suitable computer, the install any tools necessary in that (live) booted environment (those tools are included already in any GLFPE version). We then apply a prebuilt configuration file set to the Debian "live-build" process. GLF maintains .tar.gz archives of several working configuration sets across upgrade versions. All that is needed to replicate (almost) a prior working live boot image as previously configured is to run "sudo lb build" from command line inside a folder containing a copy of the prior configuration files on a large Linux formatted working drive (hence the 32Gb USB stick as EXT4). The replication cannot be guaranteed to be exact, because all packages installed use the latest available versions, and somethng usually changes every day or every week at least. The upgrade process usually calls for a minimal edit of several configuration files, mostly to change the version number written or displayed in various places. If the user wishes to modify other things, such as the list of applications to install, or to modify other elements which require manual intervention, it may take a little longer and perhaps experimentation. GLF ususally changes just the version number and date in ablout 5 files, some with text editing, some graphically (a splash screen). Prerequisites ------------- A working PC-compatible computer capable of booting the live boot ISO imaged disk, either DVD or USB. The computer needs at least 2 Gb of RAM, more can be better. The CPU must be at least x686 compatible, since recent Debian versions no loinger support x586 ir earlier CPUs. The CPU ideally shold be AMD64 compatible, since that CPU can be used to build and run either 32-bit or 64-bit versions of the OS. The computer need not even HAVE a hard drive, because it won't be used by the process. Unless the user of this process actually TRIES to write something to an internal hard drive, it won't be used or needed, nor in the way. The computer needs to support at least two USB 2.0 ports, perhaps using an external hub if necessary. The computer CPU should be 1 or more cores, at least 1.0 Ghz, but faster is better and more cores is MUCH better. A HIGH SPEED internet connection is ESSENTIAL. If you don't get at least 6 Mbps downloads it will take WAY TOO LONG. 60 Mbps is much more tolerable. The process needs to download ALL the packages installed into the distribution, the latest versions available from the repositories at the time of the build. The process to "bootstrap" requires at least one extra USB 2.0 or 3.0 flash drive with at least 32Gb capacity. This will be used for workspace for the build, and must be fomatted to EXT4 (Linux format). This can be done after the initial Debian live boot is running, using available Linux utilities, before the build begins. Pretty much all Linux distributions, live or installed, provide by default a utility which can format the USB stick to EXT4 (gparted, Disk Utility, fdisk, etc.). Specific instructions for bootstrap upgrade of GLFPE ---------------------------------------------------- First, on a suitable computer, locate a bootable disk, either DVD or USB, created using either a prior ISO image for GLFPE Linux or even from the officially downloaded Debian release (GLFPE currently compatible with Debian Mate 9 "stretch"). Boot this drive using whatrever works, either "Legacy" or "UEFI" mode (Secure Boot must NOT be enabled -- Debian does not at this writing support it). It may be necessary to hit F10, F12, F2, or whatever key your particular brand of computer uses to bring up a Boot Order menu, or the BIOS settings menu, whatever works. Assume your boot works (if not figure out why and get it to work). If you boot from DVD you should find one menu layer specifying alternate video options. If you boot from a multiusb-style disk there will be a preliminary menu of image names. Select an appropriate one for your needs and you will see the native menu for that distribution image. Again select a video mode and continue. Assuming a proper boot, you will be presented with an already-logged in desktop with menus on the top left and time settings on the top right. Before continuing, if GLFPE, select the time zone location. Click the time display and a global zone map will display. GLFPE has been preset for Louisville, KY -- select it, or edit for a mot=re suitable location from the global list. If instead you use the official Debian release image, you may need to change the time and/or timezone by other means. You can ignore this step and things will work, but you may create some odd timestamps on files. NOTE: All Linux official distributions default to having the computer store and use UTC (GMT) time for internal clock and convert all times to local using a timezone offset. Windows, on the other hand, defaults to using local time for internal storage and back-converts to alternate timezones. This tends to cause trouble on machines used al;ternately for Windows and live boot Linux. GLFPE has been built to specify LOICAL time in its internal clock to minimize the interaction problems with Windows (a personal issue for GLF and probably more common than not). However, that means the proper timezone must be set each time GLFPE boots, or timestamps wil begin to go awry for any files shared between systems. For personal convenience GLF made Louisville an easy to set location. Once in a while the boot doesn't finish and the user does not automatically log in (GLF doesn't know why, but suspects systemd as the culprit). You can try to log in (the default Debian username is "user" and the default live boot password is "live"). However, this usually fails at this point. If this happens, use the "Shutdown" icon and just shut down and try again. You should now have a functional desktop with the usual GUI tools for manipulating files, folders, and executing applications. GLFPE has a few more options than the base Debian distribution, but they work pretty much the same. If you start up with an official Debian release you will need to install (using apt-get or Synaptic) at LEAST the package live-build. There may be others undocumented here. GLFPE versions already include all the needed ones. You may use the OS as normal at this point if you wish. You can try out other applications you might install from Synaptic, you can browse the web (Chromium or Firefox), you can log out the user and log back in again (again the username is "user", the password is "live"). You can shut down if you wish. Just reboot again as described above. When ready to upgrade to the next version of GLFPE (or any custom distro you might have derived in a similar manner), continue with these instructions. Acquire somehow (perhaps downloaded from GLF's website -- not yet as of this writing) an appropriate configuration file set for a prior version of GLFPE. GLF by SOP starts by decompressing the prior configuration set for a particular CPU type and version (e.g. "glfpe512_amd64.tar.gz") to a folder either on the aforementioned work drive or temporarily in the HOME (~) folder. GLF then edits the folder name, which incorporates a version number, to increment the version. GLF then edits the appropriiate configuration files to specify new versions ad dates, as well as any planned modifications to applications or preloaded data. Once all config files are edited, the entire folder is recompressed under its new name before any build is performed, so that in case of a bug or build crash, it can be retried. To begin the build, decompress the (upgraded) config set onto the Linux work drive. Before actually building from this drive it must be properly mounted with key permissions set WHICH ARE NOT DEFAULT for USB drives. A GLF script has beenb prepared to remount a specified drive in the necessary manner. Use a terminal and "sudo fdisk -l" command to list all the drives available by device name. Make sure you identify the correc USB drive for the Linux work disk, usually the last USB stick inserted. Find and copy to home folder the script (GLF makes this available) "remountforlb.sh". The key line in this script (to set dev and exec permissions) is: sudo mount -t ext4 -o rw,nosuid,dev,exec $1 /home/$USER/livebuild Make sure it has executable flag permission set (the file manager GUI can do this). From a terminal, run the command "./remountforlb.sh /dev/sdd1" (or whatever device name is appropriate. The device should remount as a folder under the home folder named "livebuild". Bring up a terminal and cd to that folder name, and underneath that to the folder containing the decompressed configuration set. This can be done with the GUI file manager under any prior version of GLFPE, but may need to be done manually if done from the original official release. Make sure you have a proper connection to the internet active, preferably on a wired connection (usually faster). Using a terminal, from within the top level of the configuration folder ("ls" command should show folder names auto, config, and local), run the command "sudo lb build". The build process will scroll much information across the terminal as it works. The process goes through several stages, most of which require an active internet connection (at high speed). First the preliminary build folders are built using the base configuration files, a "chroot" folder into which the bootable image will be installed, upgraded, and built, then the specified packages to install are downloaded from repositories and installed into the chroot environment. This usually takes a long time. After the normal repository installations finish, special installation specified in the configuration files (nonstandard or custom program installations) and any post-processing "hook" scripts execute (which also may compile and.or install other things. When all files that belong in the live OS are built, then the process creates a "squashfs" file, a form of compressed read-only filesystem which makes live boot ossible. This step does not download frm the internet, but can take a long time. It takes less time if a faster CPU, MUCH less time if multiple threads execute. This is where a fast computer helps a lot. When the squashfs file is built, the outer layer of files on the live boot disk image are built (the ones which support booting up) and then an ISO file is created. The process eventually ends on a command prompt. The total build process, if successful, should take about 2-4 hours depending on connection and CPU speed. When finished, the top level configuration folder should show several files, including a .iso file (about 2.5 Gb). That file is the built live boot image. The process is not very tolerant of configuration errors and can quit abruptly, sometimes after a lot of work is wasted. This most frequently is caused by a break in the internet connection, but hapopens without remorse if a specification file misspells a package name or a hook script fails at a critical point. Seldom can one recover an interrupted build -- it's better to start over again. Sometimes things don't work even when the configuration is good. Fix what needs fixing and start again from the top. The build process involves root access and permissions, so some files under the build configuration folder are now owned by root, not the user. Using some form of root access, change the owner and group of the newly created ISO file to the normal user (the modified GPLFPE file manager can do this in GUI mode). Once the ISO file is owned by the user instead of root it can be copied to another drive for safekeeping, or otherwise handled without root privileges. Note that deleting the entire folder (very large, it will have grown by about 15 Gb or more) will need root privileges. Be sure to move or copy out the ISO to another folder before you do or you will waste all the effort of building it. To test (or use) the new image, you can copy it either to DVD or USB. The brasero DVD burner included with GLFPE can be used to burn a suitable DVD. To make a ootable USB requires copying the ISO contents to a suitable USB drive. The smallest USB drive you'll be abvle to use is likely to be 8Gb at this time. 8Gb would work, but they're either old now or hard to find. The Hybrid ISO file produced by Debian live build is designed to work by direct copy to either a DVD or a USB drive ("dd" command in Linux -- be careful, it's dangerous!). GLF recommends and supports an alternate method, the "multibootusb" program, which is easier and more flexible, and included in and can be run directly from the GLFPE after building a new version(s) of the ISO file(s), even if running it from DVD). NOTE: This also illustrates the value of using a custom built live boot environment, since the installation of this tool was a custom add-on not found in the official repository, and actually modified from source prior to installation. The version of multibootusb installed by GLF into the GLFPE configuration was modified slightly by GLF from source code published online. The original multiusb program had a slight bug which showed up on certain usually older machines. The workaround was to invert the order in which USB drives would be identified from ascending device name to descending, allowing the program to first consider the LAST USB stick inserted, not the FIRST. That way the program would not mstake an internal drive for an external one, which sometimes caused it to quit early. Had the live boot depended only on available packages in the repositories, the tool would not be available to the GLFPE. Insert and prepare a suitable USB stick at least 8Gb in size into an available USB port. It should be assigned the next available device name in the drive list, which will make it the first choice when running multibootusb. The disk needs to be FAT32 formatted, either previously formatted and wiped of all data or reformatted at this time. GLF has found that the Linux FAT format utilities will successfullky boot on many modern computers, but not all (older ones). GLF has found at least one (eMachines) computer which needs to boot from a FAT32 drive formatted under Windows XP. It is up to the prospective user to experiment and find out what works locally. The disk should have a descriptive (software) label which reflects the new version number. Once you have an empty, formatted FAT32 drive available, bring up multibootusb. The multibootusb program is available under "Applications, System Tools" in the menu. The GUI program should start with the "Select USB disk" item suggesting the correct USB disk. If not, use the menu selector to change to the correct one. The disk mount point listed should confirm the correct disk label. Select the ISO image file (Browse) to write to the empty USB disk. You may need to bounce around a few folders from "Computer" level to find it (usually under "/media/user/[labelname]"). Select the appropriate ISO file, then the "Install distro" button. It will take a few minutes to copy all elements to the new boot disk. When finished ou should see the name of the installed distribution in the list under "Install distro". The forte of multibiit USB is to install MULTI distributions. If you have other ISO files prepared you want to install for alternate booting on this disk, select another one and repeat "Install distro" as needed. When finished installing distros to the USB, quit the GUI multiusb program. If you examine the newly created disk, you will find "EFI" and "MULTIBOOTUSB" folders. Under "MULTIBOOITUSB" you will find a number of subfolders containing undiidual distros, and several configuration/startup files. One of the files, syslinux.cfg, contains the (editable) list of boot menu specifications. GLF prefers to edit this list to alter the default menu item and to eliminate the hard drive boot and diagnostic options, leaving only the menu items installed from ISO files. If you let this file be unedited, it will work fine, but the default will boot to hard drive (if it works) after 30 seconds. If you DO edit it, be careful or it might not work properly later. Be safe and make a backup copy first. When finished, Eject, Safely Remove, or Unmount any addon USB drives and remoive them and shut down the live boot session. Congratulations! ---------------- You should now have produced a bootable DVD or USB stick which can boot the GLFPE as specified n the configuration file. As of this writing, it will be based on the latest available stable packages for Debin 9 "stretch". Enjoy! As described above, GLFPE (GLF Programming Environment) for Linux is a custom Debian distribution containing many add-on libraries and applications beyond the base Debian Mate release. The GLFPE distribution is maintained by Gary L. Flispart (GLF) both for everyday personal use and with an eye for sharing with others for its general utility value. For example, like the official Debian live boot release, GLFPE includes LibreOffice, Firefox, and VLC Media Player, among others. In addition to the base release functionality, GLF has included a variety of other capabilities. The add-on libraries are largely those required to compile and run GLF personal C/C++ source code derived from a long career in progamming. GLF source code has largely been ported from original MS-DOS code, through Windows 32-bit systems, and into Linux systems (both 32 and 64 bit), and most of it is free and open source, and therefore sharable by GLF. Other applications include Audacity for audio processing, Inkscape for vector graphics, OpenScad for 3D modelling, Stellarium as a planetarium program for astronomy, a complete working installation of the Arduino IDE with suport for PJRC Teensy and Atmel ATtiny processors included, various video and photo editing software, and all necessary tools to maintain the live boot image itself.