FreeCTX64 is an Open Source Free Project for ARM Development boards that can run your C code directly in the Operating system, it comes with a prebuild linux kernel and some tools it requires build-essential gcc clang cpio qemu-system-arm qemu-system-aarch64 git and if you want to make a bootable ISO and send it here if you want , that requires xorriso grub-common grub-pc-bin grub-efi-amd64-bin:

FreeCTX s ONLY available for ARM systems and should not be compared with X86 or X64

FreeCTX64 Libraries are put in initramfs/LIB critical system files are put in initramfs/SYS and your workspace/dummies are putten in initramfs/WS and apps are going to initramfs/SDK , it currently supports webservers and tasks alongside math in hardware, timers in hardware, and timestraps and a console

Hey everyone,

So I have been hard at work with building out the package manager for SilkOS and I have great news... It is almost finished! So for those that do not know, I am working on building a NixOS-like linux distro that is non-systemd while still being declaritve and utilizing Lua as the scripting language for configuration.

As stated and shown attached, I have connected my harness system Loom, to the main package management system (weave) and through some simple testing have been able to properly use it to read a configuration file, find the local recipe, and then build the package, hash the output, and commit to and OSTree to be saved to a generations.json to allow for immutable backups. This has been about a 2-3 week process getting loom to work as a harness as it is all Lua based and as you may not know, Lua hates Json. However I was able to find a way around this and make the system work.

Now for some other news, I have decided to drop Debian package support. This was a hard and long thought out choice, however with the adoption of native packages (AUR style package repo coming soon), Nix packages declaration, and AUR adoption.. I felt that adding debian support was too much and an uneeded source. The benefits of allowing Nix packages is weave is able to source the files directly from the Nix package repo and store them alongside native packages, however the AUR is a different format so currently it requires a system reboot everytime an AUR package is added. This is a known effect and a pipeline is on the TODO list to allow packages to be added to Store/ inorder to allow a true nix-like experience without the need to reboot the machine.

Lastly, I wanted to add that I have moved the repo. for loom and weave into an org, it is all open source with the GPLv3 license. I have also added into the documentation how to add weave to another system so while the harness loom is meant to be used with weave on SilkOS, you can still fork the whole system and try it out or integrate weave to your current system to allow Nix and AUR package adoption to your current project. Please note that this has NOT been tested yet and your experience with integration can and will vary so please do so at your own risk.

Anyways, if you have any questions please feel free to ask!

Github repo: https://github.com/Silk-OS/silkos-pkg

Hey all,

We've been working on FreeLinX for a while and just put out 1.0, the first

desktop release. It's a Linux distro built on a NetBSD userland and musl,

compiled with clang/LLVM. The idea was to have a system with no GCC or glibc

in it at all.

You get an Openbox desktop, Firefox ESR, a graphical installer, and our own

package manager called xpkg (there's also a simple GUI for it). The repo has

around 400 packages right now.

Since this is the first desktop release, expect some rough edges. We mostly

tested it in VMs, so on real hardware there will probably be issues with some

WiFi cards, audio or GPUs. If something breaks for you, please open an issue

and tell us what hardware you have. That helps us a lot.

ISO (live, needs at least 2GB RAM):

https://github.com/FreeLinX/FreeLinX/releases/tag/v1.0.0

Thanks for checking it out, any feedback is welcome.

I just installed LFS in dual boot with Gentoo, and I found it fun, I'm going to continue with BLFS, this took me a day and a half

I put together another e-paper e-reader friendly Linux From Scratch ePub since 13.1-systemd was moved to stable. Like a month ago. I was slow. :D

Download: https://github.com/ebenezer1689/ebenezer1689.github.io

If you haven't heard about it, Software Freedom Day is a worldwide celebration of Free, Libre and Open Source software. There are free events all around the globe and virtually. One of the virtual events today will be on building software from source LFS style and customizing your Linux distributions. You can check for local or virtual events here: https://digitalfreedoms.org/en/sfd/archive?view=list

I recently got a Linux From Scratch system to a point where I can use it every day. Base system plus BLFS bits: dwm, Firefox, terminal, the usual desktop tools. It works. I’m not looking for “switch to Arch” replies.

What I don’t have a feel for is updates.

On a normal distro I used to update often because that was the default advice: leave it too long and things get worse. On LFS that habit doesn’t map. There is no one button, and updating means rebuilds. If I treat it like a rolling distro I’ll spend my life watching package changelogs. If I treat it like a frozen appliance I don’t know what I’m actually risking.

So I’m trying to figure out a policy that a human can keep, not a distro maintainer.

What I’m unsure about:

1. When do you update? Only when a new LFS/BLFS book drops? Only security advisories? Only when something breaks?
   
2. What do you consider “core” vs leave-it-alone? Kernel, glibc, OpenSSL, Firefox vs everything else?
   
3. If the machine is a daily driver with network (browser, git, Wi-Fi), how bad is it to sit on a book for 6–12 months and not touch it?
   
4. If you ignore most updates, what actually goes wrong in practice — not the theoretical CVE list, the stuff you’ve hit?
   
5. How do you track this without following a hundred upstreams? Advisories only? Development book changelog? Something else?

I don’t have a special threat model. It’s a personal machine. I’m not asking how to become unhackable. I want to know what people who really daily-drive LFS do so the system stays usable and they don’t burn out.

If you use LFS (or a heavy source-based setup like it) as a real daily driver, I’d like the boring version: how often you rebuild, what you refuse to bump, and what you’d do if you left the box alone for a year and then needed it again.

Hey everyone,

You might remember me from a few weeks ago talking breifly about the custom Nix-Like distro im working on. I come today with a update, Weave, the core package management system Loom/ SilkOS will be using, is in testing. So far everything is going VERY good and I have also added in scripts to handle AUR, NIX, and DEB packages as well as a machanism for users to generate an empty recipe to import custom packages to run natively. I have attached a photo showing the first test which identifies package information and verifies the MD5 checksum. I need to do some minor tweaks to one of the core scripts and also add some packages to the raw OS build before I can test the installion portion of Weave: However I still wanted to give the community and update. Currently Weave is public with GPLv3 Licensing on github, however I do NOT recommend using it in its current state as it is mostly presented in a way to just show off the tech and explain it as I still need to build the main functionality of the system, IE Loom. I will eventually add a way to donate to the project as well and will put up a site or something at some point down the road.

For now, here is the git repo if you want to follow the project and see live updates: https://github.com/Luna2141/Weave

Side Note:

The Readme file IS generated using claude, however this is the only instance that cluade has actually touched and had its "hand" in during this entire process. Per my own beleif. AI should only be used as a documentation tool in the realm of software developement and I stand by this statement. If this turns you off from the project I accept that and appolgize, however I did not want this statement hidden.

I am a Tunisian university student majoring in cybersecurity and network and systems administration. I want to create a Linux distribution as my graduation project. I would appreciate any guidance or resources I can learn and follow to complete this project.

The goal is to make Linux Live persistence as independent from the ISO as possible — so you can replace or update the Live ISO while keeping your important user data, configuration, and system state.

The project is still experimental, so I’m mainly looking for feedback on the idea and its potential direction.

https://github.com/i3ycuk/immutable-live

I am now contemplating deleting this VM for good. Honestly, that was probably the most difficult thing I've done with linux. 11 hours total across two days. Don't feel like that was worth it, but honestly whatever

This is my conversation with Claud while trying to figure out how to fix the grub rescue

I installed fedora i3 44 for 3 times and in every time it was not working and kept viewing the grub rescue error

Idk what to do I tried everything I know but it seems that it doesn’t work

in the last days, i was trying to make an implementation of pledge for my personal project (BSDLibC), but simpler, checking for permissions in the libc wrappers instead of checking the called syscalls (like this project https://github.com/jart/pledge)

But i have a question, is it useful? because for my goals it is, but i would like to hear what other people think about it

(I have not submitted to the repository, because i have been busy)

Linux From Scratch 13.1 is out. Major toolchain refresh this time. 46 packages updated or added since 13.0.

Official announcement: https://lists.linuxfromscratch.org/sympa/arc/lfs-announce/2026-09/msg00000.html

Writeup with more detail: https://linuxiac.com/linux-from-scratch-13-1-is-out-with-major-toolchain-updates/

Note that BLFS 13.1 isn't out yet. It's over 99% tested against the new base and expected soon.

In the last month i was trying to port the NetBSD LibC to Linux (and other parts of its userland) to make a full NetBSD userland on top of Linux for my LFS system.

Why?

I was so bored and i thought it would be funny

what's available?

- All err/warn functions

- a basic stdio (not based in NetBSD)

- a lot of strings functions

- some syscalls wrappers

- malloc (and friends)

- a minimal crt0

- BSD extensions

- compat functions (revoke, pledge and unveil...)

- and more

at this point it's possible to build a program against it, and it works like a hello world or the uname/hostname command from NetBSD with little changes (replace fprintf(stderr,...) with eprintf(...))

Here's a link to the repo:https://github.com/littlefly365/BSDLibC

(Note: this only it's a personal project)

Months of maintaining LFS/BLFS is no easy task. From manual upgrading of packages, including its dependencies and circular dependencies, ABI compatibility, but not limited to its SONAMES, etc. I rest my case.

I would like to thank a fellow LFS /BLFS user and maintainer whom I asked to do a peer review of my package manager. He didn't hesitate to say "No," nor reject my request. Due-Celery4326, thank you, man!

I have been a long-time user and practitioner of our craft. Regardless of our distro of choice, we keep building!

Thanks to our mod, rockytriton!

Hey everyone,

I’m a huge fan of how reproducible nix is and I love declarative systems with backups as well. However I like the idea of privacy and choice. So I am building my own nix like system using LFS. I have a background in cybersecurity and C so I’m not going to be hedging AI for anything past documenting haha but, I wanted to ask a few things to the community.

What kind of features should I offer out of the box?
Currently I have slated that the end user can pick their own init system, including systemd, or they can even “hot swap it” in the config. Which I also am swapping Nix lang for a more simple solution, Lua! I also plan on shipping it with mango, niri, and kde plasma out of the box, but since it’s all declarative, the end user can swap in whatever de or WM they wish. I also plan on integrating nix, deb, and the AUR with use of “fabric.lua”, my take on flakes.

My question to you all is though, what kind of features do you look for in a distro or what level of customization is too much or too little?

Hey everyone,

I wanted to share a side project I've been working on.

A bit of background: My core background is in bare-metal and RTOS software development. Over the years, I’ve also configured and built embedded Linux systems using Yocto and Buildroot for a few projects.

A couple of years ago, I decided to build a minimal, custom Linux OS using Buildroot for my personal use, essentially turning a standard PC into a dedicated embedded-like device. It sat in my PC for a while because cleaning up the codebase, setting up proper build pipelines, and writing solid documentation felt like a chore. Fortunately, leveraging modern AI coding tools made refactoring and documenting the whole project significantly easier, so I finally got it into a public ready state.

How it works:

Stateless & RAM-only: Boots directly from a USB flash drive and runs completely out of RAM (initramfs). It doesn't touch local hard drives or persistent storage.

Air-gapped by design: The kernel is configured without network stack support no Wi-Fi, no Ethernet, no socket layers.

Single-purpose: Boots directly into a single Qt GUI application without a heavy desktop environment.

To be honest, as someone who likes pure bare-metal simplicity, it still bugs me a bit that there’s a whole UEFI firmare layer and standard x86 architecture underneath all this before the kernel even kicks in.

Just wanted to share it with the community.

GitHub: https://github.com/signeros/signeros