Hey, just wanted to share my libnode build repository [https://github.com/I-A-S/libnode-builds\](https://github.com/I-A-S/libnode-builds)

If anyone else here is working with libnode and want prebuilt binary+header archives, this repo builds and publishes the following targets.

1) win-x64 (debug and release variants)
2) win-arm64 (debug and release variants)
3) linux-x64 (debug and release variants)
4) linux-arm64 (debug and release variants)
5) darwin-x64 (debug and release variants)
6) darwin-arm64 (debug and release variants)

and a separate zip file containing headers.

Cheers!

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!

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?

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"

I’m so very very happy with the build I have gotten done so far building it on VBox, but it boots on bare-metal already too

How can I find which is the latest gnome version i.e which website and what packages should I install. The current version is 50.3 but my desktop has 48.

In the svn link of the book it is mentioned gnome shell 50.3 requires mutter 50.3, how to find these dependencies.

And how editors of the book check for updates because there are more than 1000 packages in the book , how do they manage checking for new versions. Do editors manually check for new versions ?

Now I understand many things about large distros. It's much harder to get rid of systemd in Gnome; it was a lot of work and a headache. Some Gnome functions are already directly using systemd libraries. Honestly, I almost gave up when one last attempt worked and I was encouraged to finish/polish it, but the result was incredibly satisfactory. I can't believe it; I couldn't use Gnome in large distros because of limited memory, only 5GB. Gnome in large distros already started with more than 1GB.And I don't know if the fact that sysvinit also helped, I'll do the same polishing on KDE Plasma later to see what I can achieve in terms of lightness and performance.

Ive been wanting to try Linux from scratch lately but not having a stable package manager always pulls me back, and I want to know if are there any "universal" package managers or even dedicated to LFS directly.

Hi, I was tryna make MikuOS from Arch but I decide to switch it to LFS instead, and i dunno how do I make it and what do I need, can anyone had a sort of road map or suggestion for me so I can work on it?

Thanks

Hey everyone!

A few months ago I started building my own Linux distribution from scratch using LFS/BLFS. After manually compiling everything (GCC, glibc, systemd, XFCE, etc.), I realized something:

LFS doesn't really give you a package manager. You're expected to keep building and installing everything manually.

Now, I know that's kind of the whole point of LFS. It's meant to teach you how Linux actually works by making you do everything yourself, and I think that's exactly how it should be. Chiral isn't meant to replace that learning experience. It's aimed more at people who have already finished LFS/BLFS (or projects like GLFS/GLinux From Scratch) and want something to manage packages afterward instead of compiling everything forever.

So... I decided to build one.

It's called Chiral, and it's a cross-distro package manager written in Rust. The long-term goal is to make it work across as many Linux distributions as possible. I know that's a huge challenge, and I'm sure there are going to be edge cases, but I'm learning as I go.

Right now it can:

- Install packages with dependency resolution

- Remove packages while tracking installed files

- Search packages

- Show package information

- Update packages and self-update

- Work on custom LFS systems and other Linux distributions

It currently falls back through:

1. My own GitHub package repository

2. Debian repositories

3. Arch Linux repositories

The dependency resolver walks the full dependency tree and installs packages in the correct order. It also tries to detect software that's already installed using package managers, "pkg-config", "ldconfig", "PATH", and filesystem checks so it doesn't reinstall things unnecessarily.

It's far from finished. I'm still working on:

- Orphan package detection ("autoremove")

- Better conflict detection

- Improving dependency handling

- Supporting more distributions (or at least as many as I can)

This is honestly my first time writing something this large in Rust or building low-level Linux tooling, so I'm sure there are plenty of things that can be improved. I'd really appreciate feedback, bug reports, suggestions, or anyone willing to test it on different distros.

GitHub:

https://github.com/Amaterus1125/Chiral-CrossDistro-Package-Manager

I'd love to hear what you think, especially from people who have experience with package managers, Linux distributions, or LFS. Any feedback is welcome!

Greetings, ive made a small linux distro called Static Linux.

https://staticlinux.org
https://codeberg.org/staticlinux
https://discord.gg/hfgdDvRehr

we are a source-based distro that follows the UNIX philosophy,

and we are peak (trust)

our tooling is simple, and auditable, we have many cool stuff like

• a custom init system wrote in rust
• a custom package manager wrote in C named ace (ace compiles everything)

and more but i forgor.

contribute, come, speak, whatever! i just want YOU to come and, maybe, try it?

After a month of patience, sweat, and manual compilation, I finally moved past the basic LFS prompt and built a fully functional daily driver environment!

The last screenshot shows the absolute madness of downloading, unpacking, and configuring every single dependency (`libdrm`, `xcb`, `xfce4-*` packages) by hand. No package manager, just raw terminal power.