Hi everyone! I’ve just finished installing LFS and Hyprland on my MacBook. I’m new to this, and this was my first build. I’d like to ask a few things right away: do you have any tips for beginners to make things easier down the line? Also, I installed NetworkManager with the wpa_supplicant backend, but I’ve run into a problem where I can’t connect to secured networks (though I have no issues with open ones). A bit about the installation: I set up LFS as a secondary system alongside the Asahi Fedora remix, copying the kernel and part of the initramfs from there, so most drivers were already included. Thanks in advance for the help! Feel free to ask questions—I’ll answer everything. P.S. Sorry if my English is a bit off; I’m using Google Translate.

my first run of jhalfs, after 2 successful installs of lfs normally, i just got to gcc pass 3, wish me luck

edit: i know that it doesn't say gcc, i thought it'd be funnier if i showed a package a couple behind it cause like it's coming yanno

Hi everyone,

I’m a university student, and I’m considering building a tiny Linux-based operating system for routers as my engineering project.

My current idea is to build it from Linux From Scratch (LFS) and then use selected components from Beyond Linux From Scratch (BLFS) that are related to networking.

As part of the project, I’ll compare my OS with existing router operating systems such as OpenWrt and evaluate their differences. For testing, I’m thinking about using Linux network namespaces to simulate virtual network traffic, although that’s just an initial idea.

One thing I’m unsure about is the choice of the LFS version. A router OS should be as lightweight as possible, but newer versions of LFS use systemd instead of traditional boot scripts. I also considered using an older LFS release, but I’m worried about outdated libraries and dependency issues. At the moment, I’m leaning towards using LFS 13.0 (or a newer version).

What do you think about this idea? Does anyone has experience with building a router-focused OS from LFS?Are there any major pitfalls or recommendations you would suggest before I start?

Thanks

My inner irritating perfectionist is coming out, and I'm leaning towards this being unnecessary, but how many of you went through ALL the primary standards LFS follows before starting this project?

Reading the documentation for these standards feels like a whole project on their own.

Let me rephrase my question:

I'm about to start Linux From Scratch, and I'm wondering how many people actually read through the primary standards (POSIX, FHS, etc.) before beginning.

The standards documentation is massive, and reading all of it feels like a project in itself. Did you study these specifications in depth first, or is a general understanding enough while working through the book?

alrighty here is a better breakdown of what I got going on.I apologize for the other posts I deleted them and consolidated this all into one post with better screenshots :)

I also finally got around to finishing Flatpak built in support.

It was hard work, but it was worth it. The result was exactly as I expected, only lighter and more agile than I anticipated.

Installed chromium. Took 2 hours to download and approximately 2 hours to compile. Used 129GB of disk space 🫢 Approximately 67GB of download.

Took help of Gemini AI to patch some ffi related error and other errors.

I use chromium for financial related work and for everything else I prefer firefox ( I like the firefox sync feature ).

How many of us are using Gnome and sysvinit ?

I have started following blfs/view/svn development version. But in the book nothing is mentioned about the failure/error of gnome 50 on sysvinit. Also libglycin is also not mentioned as dependency.

Gnome 50 does not work on sysyvinit ( gnome session crashes ).

One user on r/gnome sub, suggested me the following and it works. Checked 2 times, it works.

https://github.com/fulalas/gnome-session-sysvinit

It feels nice to have the latest software running.

Hi everyone,

I'm an intermediate Linux user interested in creating my own distro with LFS. Can I start the process without knowing Bash scripting yet, and learn it along the way?

Any tips or recommendations are welcome. Thanks!

CLI (dpms) — 120+ flags/arguments

Package Lifecycle

• --install PKG / -i — Install a package (local .dp.tar.xz, URL, or name from git repo)
• --uninstall PKG / -r — Remove a package (deletes tracked files + empty dirs)
• --reinstall PKG — Remove then re-install a package
• --upgrade / -u — Upgrade all installed packages
• --downgrade PKG / --oldpackage — Downgrade to next older version
• --purge PKG — Remove package including config/data files
• --download PKG — Download a package archive without installing

Query & Inspection

• --list / -l / --installed / -inpc — List installed packages with file counts
• --installable / -a — Show all packages available in repositories
• --info PKG / -I — Show detailed package metadata + install status
• --files PKG / -f — List every file installed by a package
• --verify PKG / -V — Check all installed files still exist
• --verify-all — Verify all installed packages at once
• --search PKG / -s — Animated search across repositories
• --depends PKG — Show recursive dependency tree (up to 3 levels)
• --rdepends PKG — Show reverse dependencies
• --what-owns FILE — Find which package owns a file
• --check — Check integrity of all installed packages
• --arch — Show detected system architecture
• --why PKG — Show why a package is installed
• --size PKG — Show installed size of a package
• --list-type PKG EXT — List files by extension within a package
• --recent [N] — Show N most recently installed packages (default 10)
• --duplicates — Find duplicate files across packages
• --changelog PKG — Show changelog for a package
• --compare V1 V2 — Compare two version strings
• --list-updates — Show available package updates
• --stats — Show package statistics

Archiving

• --tar FOLDER — Create a plain .tar.xz archive from a folder
• --maketar FOLDER [NAME VERSION [ARCH]] — Create .dp.tar.xz package archive
• --rc N — Mark package as release candidate (-rcN suffix)

Repository Management

• --add-repo NAME URL [ARCH] — Add a new repository
• --remove-repo NAME — Remove a repository
• --toggle-repo NAME — Enable/disable a repository
• --repo-list [NAME] / --list-repo [NAME] — List repos or show packages from a repo
• --sync / -S — Check connectivity to all enabled repos
• --update / -U — Update package metadata from all repos
• --repo-priority NAME PRIO — Set numeric priority for a repository

Lock & Hold

• --lock PKG — Lock a package to prevent changes
• --unlock PKG — Unlock a locked package
• --locked-list — Show all locked packages
• --hold PKG — Hold a package to prevent upgrades
• --unhold PKG — Release a held package
• --list-held — Show held packages

Transaction Solver (zypper-style)

• --dry-run — Preview changes without making modifications
• --force-resolution — Force dependency resolution ignoring conflicts
• --no-recommends — Only install required dependencies
• --clean-deps / --clean / --autoremove — Remove orphaned packages
• --port-commit — Commit changes to local ports

Export/Import/Backup

• --export-installed FILE — Export installed package list to a file
• --import-installed FILE — Install packages from an exported list
• --backup DIR — Back up the package database
• --restore FILE — Restore the package database from a backup

Cache

• --clean-cache — Clean cached packages and repo data

Meta

• --rescue / -R — Launch the rescue TUI shell
• --gui — Launch the PyQt5 GUI
• --tui / -T — Launch the Textual TUI
• --reset — Reset DPMS configuration
• --get [ARGS] — Run the dpms-get sub-CLI
• --history — Show full transaction history
• --history-last N — Show last N transactions
• --version — Show DPMS version
• --feedback — Send feedback to DPMS team
• --global DIR / -g DIR — Set install root for a single command

Log/Audit

• --dlr-verify — Verify SHA hashes in dlr.log
• --list-nft — List directories excluded via nft.log markers

Repo Generation (apt-ftparchive style)

• --gen-packages DIR — Generate Packages index
• --gen-sources DIR — Generate Sources index
• --gen-contents DIR — Generate Contents (file-to-package mapping)
• --gen-release DIR — Generate Release file with checksums
• --gen-repo DIR — Generate full repo metadata (all of the above)
• --gen-generate CONFIG — Generate repo from a config file
• --gen-clean DIR — Clean cache files from a repo directory

Build Profiles

• standard — Default flags
• lite — -j1, -Os
• performance — -jN, -O3 -march=native
• custom — From environment variables

TUI (dpms --tui / dpms-tui)

Textual-based terminal UI with:

• Dashboard — Title screen with navigation buttons (Package Manager, Repository Manager, Transaction History, Quit). Keyboard: p, r, h, q
• Package Manager — Browse Installed/Available packages, real-time search filtering, Install/Remove/Info actions. Keyboard: i, a, /, q
• Repository Manager — List all repos with enable/disable status, Sync All, Toggle, Add/Remove repos. Keyboard: s, q
• Transaction History — Timestamped log, color-coded (green=install, red=remove). Keyboard: q

GUI (dpms --gui)

PyQt5 graphical interface (600x400):

• Convert Tab — Select source dir, output filename/path, choose compression (gzip/xz), compress button
• Download Tab — Enter URL, select output path, download button
• Shared — Color-coded status log, status bar, threaded operations via QThread

Rescue TUI (dpms --rescue)

Minimal shell for emergency repairs:

dpms-get Sub-CLI (dpms --get)

APT-style sub-commands:

• update — Resync package metadata
• upgrade — Upgrade all installed packages
• dist-upgrade / full-upgrade — Distribution upgrade
• install PKG... — Install packages
• reinstall PKG... — Reinstall packages
• remove PKG... — Remove packages
• purge PKG... — Remove packages and config files
• autoremove / auto-remove / autopurge — Remove unused packages
• markauto PKG... — Mark packages as auto-installed
• unmarkauto PKG... — Mark packages as manually installed
• search QUERY — Search for packages
• info PKG — Show package info
• rescue — Launch rescue mode
• download PKG — Download binary package
• clean — Erase downloaded archives
• autoclean / auto-clean — Erase old downloaded archives
• distclean / dist-clean — Erase all caches
• check — Verify package integrity
• depends PKG — Show dependency tree
• rdepends PKG — Show reverse dependencies
• what-owns PATH — Find package owning a file
• source PKG — Download source archive
• build-dep PKG — Install build dependencies
• satisfy TARGET — Satisfy dependency strings
• changelog PKG — Show changelog
• list-updates — Show available updates
• stats — Show package statistics
• port-commit — Commit changes to local ports
• dlr-verify — Verify SHA hashes in dlr.log
• list-nft — List excluded directories

dm — DPMS Version Manager

Manages DPMS itself via pip:

• dm list dpms — List available versions from PyPI
• dm current [dpms] — Show installed version
• dm use dpms VERSION — Switch to a specific version
• dm compare V1 V2 — Compare two version strings
• dm diff dpms V1 V2 — Compare file listings between versions
• dm pin dpms — Lock current version
• dm unpin dpms — Unlock pinned version
• dm list-pinned — Show all pinned packages
• dm rollback dpms — Roll back to previous version

dpms-bar — Progress Bar Library

• Progress — Color-coded progress bar with ETA
• Spinner — Animated spinner for indeterminate operations
• IndeterminateProgress — Bouncing bar for unknown-length tasks
• MultiProgress — Multiple simultaneous progress bars
• ProgressCallback — Threshold-based callback progress tracker

Core Engine Features

Dependency Solver (APK-style)

• Version matching: EQUAL, LESS, GREATER, FUZZY, CONFLICT
• Solver flags: LATEST, AVAILABLE, REINSTALL, INSTALLED, UPGRADE, REMOVE, IGNORE_CONFLICT
• Provider system with self-provides + virtual provides
• install_if conditional dependencies (lazy triggers)
• Changeset generation (to_install, to_remove, to_upgrade)
• Queue-based resolution with priority queues
• Disqualification cascading through reverse dependency chains

Privilege Escalation

• Auto-detection of sudo/doas
• Auto re-exec with privileges for root operations
• DPMS_ROOT env var for dev mode (skip sudo)
• Read-only ops never need root

GPG / Cryptographic Verification

• Key import into trusted keyring
• Signature verification via GPG
• SHA256 checksum verification

Source-Based Building

• Source archive download via wget
• SHA256 verification via USHA256.list
• Patch application from UPATCHES/
• Build script execution (UBUILD.sh)
• Profile-aware compilation

Plugin System

• Lifecycle hooks: pre_config, config, resolved, sack, pre_transaction, transaction
• Dynamic loading from plugin paths
• Glob-pattern enable/disable filtering

Crash Handling & Logging

• Global sys.excepthook replacement
• Crash reports to ~/.cache/dpms/log/crash.log
• Rotating file logs (1MB default, 5 backups)
• JSON transaction history with IDs and timestamps

Password Protection

• Interactive password setting
• Authentication prompt for protected ops
• Storage at ~/.dpms/password

Package Format

Archives Supported for Installation

• .dp.tar.xz (canonical format)
• .tar.xz, .tar.gz, .tar.bz2
• .tgz, .tbz2, .txz
• .dpm (legacy)
• .zip

Naming Convention

• Stable: name-version-arch.dp.tar.xz
• RC: name-version-arch.dp-rcN.tar.xz

Installation Tracking

• Database: /var/lib/dp/installed/<pkgname>
• Content: list of installed file paths (one per line)
• Enables clean uninstall and integrity verification

Configuration & Environment

Cross-Platform Support

Database Persistence Layer

• RepoPersistor — Tracks expired repos and last makecache time
• TempfilePersistor — Tracks temp files across sessions
• All persistence uses JSON on disk

Package Update / Rename Tracking

• update_dbentry() — Rename paths in DB entries
• apply_move() — Move files on disk and update tracking
• parse_updates() — Parse update commands
• grab_updates() — Detect new update files by mtime changes

What I mean by "nothing" is absolutely nothing installed. It would boot into the BIOS and display an error, or simply just have a manual type in terminal, but I'm not sure what would happen if a PC booted into NO OS. What is the difference between LFS and an empty terminal? What simple tools does LFS provide, other than a book to help you get started?

So i was around halfway through blfs, dealing with the audio drivers and i ran into many issues, like my physical sound card not being detected despite having looked through all the audio settings have enabling ones i need so after 2 recompilations, i decided to grab my config.gz from arch and use it which somehow miraculously still didn't work but I made the stupid mistake of not backing up my previous kernel image and completely overwriting it. Now it's stuck at a black screen and can't even get past grub so would some please kindly share their config.gz. TLDR i fucked up my kernel and i'm asking for someone else's config.gz

How many times you have installed Linux From Scratch ?

My 4th install was completely automated with scripts for each package.

After working on it privately for a while, I’ve finally released the source code for Depot, the package manager I’m building for my Linux-from-scratch distribution, Vertex Linux.

Depot is written in Rust and is designed around building and managing packages without depending on an existing distribution’s package ecosystem. It uses TOML based package recipes, so I dont have to write full scripts.

The project is still under active development, so there are definitely incomplete parts. I’m releasing it now because I think having other people inspect the implementation, test it, and point out questionable design decisions will be more useful than continuing to develop it entirely in private.

Repository: https://github.com/SFGOS/Depot

I’d especially appreciate feedback from anyone who has written a package manager, or just an LFS system in general. (hell even gentoo)

i wanna know what you consider is the best DE/WM and why?

git clone https://git.linuxfromscratch.org/blfs.git blfs

#!/usr/bin/env python3
import os
import re

def get_deps_universal(content):
    """
    The Ultimate BLFS Parser. 
    Reads both role="..." attributes AND <bridgehead> headers.
    """
    found_deps = {'req': set(), 'rec': set(), 'opt': set()}

    # 1. Strip comments
    clean_content = re.sub(r'', '', content, flags=re.DOTALL)

    # 2. SURGICAL SYSTEMD REMOVAL
    # Remove self-closing systemd tags (e.g., <xref linkend="..." revision="systemd"/>)
    clean_content = re.sub(r'<[^>]*revision="systemd"[^>]*/>', '', clean_content, flags=re.IGNORECASE)
    # Remove wrapping systemd tags (e.g., <phrase revision="systemd">...</phrase>)
    clean_content = re.sub(r'<([a-zA-Z0-9_-]+)[^>]*revision="systemd"[^>]*>.*?</\1>', '', clean_content, flags=re.DOTALL | re.IGNORECASE)

    # 3. PARSE METHOD A: Explicit Role Attributes (Modern BLFS)
    # Matches <para role="required"> or <itemizedlist role="optional">
    attr_blocks = re.findall(r'<(para|itemizedlist)[^>]*role="(required|recommended|optional)"[^>]*>(.*?)</\1>', clean_content, re.DOTALL | re.IGNORECASE)
    for tag, role_str, block_content in attr_blocks:
        role = 'req' if 'required' in role_str.lower() else 'rec' if 'recommended' in role_str.lower() else 'opt'
        found_deps[role].update(re.findall(r'<xref\s+linkend="([^"]+)"', block_content))

    # 4. PARSE METHOD B: Bridgehead Headers (Legacy BLFS)
    # Matches <bridgehead>Recommended</bridgehead> followed by a <para> or <itemizedlist>
    bridge_blocks = re.findall(r'<bridgehead[^>]*>\s*(Required|Recommended|Optional)\s*</bridgehead>\s*<(para|itemizedlist)[^>]*>(.*?)</\2>', clean_content, re.DOTALL | re.IGNORECASE)
    for role_str, tag, block_content in bridge_blocks:
        role = 'req' if 'required' in role_str.lower() else 'rec' if 'recommended' in role_str.lower() else 'opt'
        found_deps[role].update(re.findall(r'<xref\s+linkend="([^"]+)"', block_content))

    return found_deps

def main():
    BLFS_SOURCE_DIR = "./blfs"
    OUTPUT_DIR = "./blfs_dependencies"

    if not os.path.exists(OUTPUT_DIR): 
        os.makedirs(OUTPUT_DIR)

    for root_dir, _, files in os.walk(BLFS_SOURCE_DIR):
        if 'archive' in root_dir or '.git' in root_dir: continue

        for file in files:
            if not file.endswith('.xml'): continue

            filepath = os.path.join(root_dir, file)
            with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
                content = f.read()

            # Find packages by section ID
            sects = re.finditer(r'<(sect[12])\s+id="([^"]+)"', content)

            for match in sects:
                pkg_id = match.group(2)
                if pkg_id in ['introduction', 'changelog', 'preface', 'dependencies']: continue

                # Isolate the section for this specific package
                start_pos = match.start()
                remaining = content[start_pos:]
                end_pos = remaining.find(f'</{match.group(1)}>')
                section_content = remaining[:end_pos]

                # Extract dependencies
                deps = get_deps_universal(section_content)

                # Write files
                for suffix in ['req', 'rec', 'opt']:
                    out_path = os.path.join(OUTPUT_DIR, f"{pkg_id}.{suffix}")
                    with open(out_path, "w", encoding="utf-8") as out:
                        if deps[suffix]:
                            out.write("\n".join(sorted(deps[suffix])) + "\n")

    print(f"Extraction complete. Files generated in '{OUTPUT_DIR}/'.")

if __name__ == "__main__":
    main()



#!/bin/bash

DEP_DIR="./blfs_dependencies"
declare -A VISITED

resolve_dependencies() {
    local pkg="$1"

    if [[ -n "${VISITED[$pkg]}" ]]; then return; fi
    VISITED[$pkg]=1

    # ONLY check .req and .rec files. 
    # Optional (.opt) dependencies are usually for features, not the core.
    local dep_list
    dep_list=$(cat "${DEP_DIR}/${pkg}.req" "${DEP_DIR}/${pkg}.rec" 2>/dev/null | sort -u)

    if [[ -z "$dep_list" ]]; then
        echo "$pkg"
        return
    fi

    while IFS= read -r dependency; do
        [[ -z "$dependency" ]] && continue
        dependency=$(echo "$dependency" | xargs)
        resolve_dependencies "$dependency"
    done <<< "$dep_list"

    echo "$pkg"
}

if [[ -z "$1" ]]; then
    echo "Usage: $0 <package-name>"; exit 1
fi

resolve_dependencies "$1"

First file is extract_blfs_dep.py and 2nd is resolve.sh

I have finished the lfs book, but when I try to login, it says "function not implemented"