Puppy build system alternative?

[jamesbond]

Puppy today is built using Woof-CE. Well, at least, official Puppies.

Some people have suggested that Woof-CE should not be the only way to build Puppies, because in their opinions, Woof-CE is inflexible, difficult-to-use, etc. Regardless of the truth of these opinions, the question is interesting nonetheless: what other build system is available, today, or in near-future, to build a Puppy?

When talking about a system, I'm not talking about some "forum member X" spending countless hours in a dark room tinkering and producing an ISO. The result of such work can be magnificent indeed, but that's not the point of this thread (see below to understand why a build system that does not depend on one individual is important).

I am also not talking about the final product, nor the features of the final product (e.g barebones, small, complete, monolithic, modular, etc), nor the ability of the build system to produce a product with a certain features.

I am specifically talking about:
1. Scripts, which can be downloaded and used by others, to produce a Puppy-like distro (in the form of LiveCD ISO, LiveUSB images, etc).
2. Step-by-step instructions, which can be followed by others, to produce a Puppy-like distro.

---

Ideally, (1) and (2) should go together but I'm willing to accept (2) without (1) with the provision that it has enough detail so that a capable person would be able to automate it to produce (1).

Ideally, the build system should produce a fully finished product, but for the sake of the discussion, I'm willing to accept a system that, let's say, automate 80% of the job. (Of course 80% is subjective, the point is that it should automate most of the tedious work out of the way, leaving only the finer points for the distro-maker to polish).

The raw materials for the build system doesn't matter. It can start by compiling source code, it can start by assembling binary packages, or it can start by taking other distros' ISO and modifying it. What matters is in the end, it produces a Puppy-like distro, in a systematic way.

---

I specifically exclude remaster scripts except if it is also accompanied with step-by-step instructions (2) on how to use that remaster script to produce the Puppy-like distro.

I also specifically exclude Live-CD-making-only tools (e.g. tazlito) because while making a LiveCD is certainly part of making the distro, there are still a lot of things missing (e.g. how to prepare the directories that will be cut into the LiveCD). You need more than just that (e.g. tazlito in combination with other scripts).

When talking about (2), I specifically exclude "instructions" which are spread over 100 pages of thread in this forum. That's not instructions, that's discussion pages. Instructions should be in the form of clear, step-by-step instructions consolidated in one place (in a file, or in a website, or even in multiple consecutive posts in the this forum - but not spread over 10 pages).

Added to clarify: The suggested build system must already been in use, as in, a product of the build system (=the distro, the LiveCD/LiveUSB images) need to be already be available for others to download, since we are talking about __existing__ build system (not future ones). It does not matter if the ISO is still in "alpha" stage, as long as it is available for download (and works to a certain degree e.g. boots to a desktop), it proves that the build system works and can be used.

---

What's the importance of having a build system? Many, but I will only share one point which I think is the most important: In days past, Puppy was produced by one person, Barry. If he went on extended holidays then no Puppy for you. Barry stepped down and he left us with a legacy, that's Woof (which becomes Woof-CE). One of the good thing that happened is that now __everyone__ can build Puppy, not only Barry. Puppy has been liberated, it's existence no longer depends on one person.

This should not be taken for granted. Not all Puppy-like distro has this happy ending. Let me take just one example out of many. Grafpup is a very nicely done Puppy derivative. Apart from being beautifully done (it was done by a graphic artist), it supports __multi-user__ at the time when many Puppy users weren't even aware of the term. However, nobody can produce a new Grafpup today. The distro died along with the death of the motivation of the original author. The same can be said about Puppeee, Fluppy, Saluki, and a lot of other very fine puplets that decorates our Puppy history.

A build system would prevent the tragic demise of these puplets; at the very least, it enables someone else (apart from the original author) to resurrect them if it gathers enough interest.

---

What other systems do you all know, complete or incomplete, which can potentially be used to build Puppy-like distro?

EDIT: Available build systems now listed in the second post.

[jamesbond]

Known build systems (listed in order they are submitted in this thread):

1. Woof-CE: obviously, the build system currently used to build official Puppy. It has scripts, it is well documented, and it can build from various parent distros although at the moment only Debian/Ubuntu/Slackware are well supported due to lack of maintenance for other distros. It builds from binary packages, and has extensive options to customise the build process. It has been used to produce various Puppies, official and unofficial.

Complementarily, Woof-CE has a "petbuild" system that can produce binary packages from source. The binary packages created this way can be used by Woof-CE, when generating the final distro.

---

2. Fatdog64 ISO Builder: the build system used by Fatdog64. It builds Fatdog64 ISO from individual Slackware-style (TXZ) binary packages. This is a configuration-driven build system, there is no GUI. It is well documented (sort of). (Disclaimer: I'm the author of this build system).

Complementarily, Fatdog64 has a "pkgbuild" system that can produce binary packages from source. The binary packages created this way can be used by the ISO builder, when generating the final distro.

---

3. Tazpup build system. The build system to make Tazpup and Tazpup64, from either SliTaz ISO or from SliTaz binary packages (tazpkg). See post from s243a directly after this post.

Binary packages can be created using tazwok, SliTaz package builder.

---

4. DebianDog build system. The build system to build DebianDog family of distros (DebianDog Jessie, StretchDog, etc). It builds ISO from Debian binary packages. Building from Devuan parent requires slight modification to the build system, as documented here.
Note: as confirmed by fredx181, this build system is only for Debian-based derivatives, not for the Ubuntu based ones (XenialDog, BionicDog).

Binary packages can be created using dpkg-buildpackage and friends.

---

5. WoofQ and WoofE build systems. Descended from the same Woof2 build system that Woof-CE came from are WoofQ (the build system for Quirky distro), and WoofE (build system for EasyOS). Both of these build a distro from OpenEmbedded binary packages. Note: One tarball contains both WoofQ, WoofE, and Woof2 (Woof2 is the predecessor to Woof-CE).

Binary packages can be produced by using OpenEmbedded framework with an extra "layer", which Barry provides here.

---

[s243a]

What other systems do you all know, complete or incomplete, which can potentially be used to build Puppy-like distro?

I'm developing a buildsystem for TazPup64 (name may change):

BuildKit%28TazPup64%29-PreAlpha7-unclean.tar.gz (large because it includes the package binaries, I'll create a version later that doesn't).
See post: http://murga-linux.com/puppy/viewtopic. ... 77#1026677

but it is out of date with my development of TazPup64 because as I make changes to the output (a root file system for the base_sfs), it takes time to check that all the changes are properly incorporated into the build system and then there is the job of fixing any bugs due to code changes.

It's configuration based. Example 75 line configuration file:
https://pastebin.com/fUHYDSWN

1. It installs packages using tazpkg to a new root file system
2. Can also install unpacked packages from a directory and I did this for some woofCE packages like ptheme and roxconfig
3. applies some patches to some scripts based in part from work by mistfire.
4. uses the kernals/firmware/initrd from an existing puppy.

The build system is based on mistfire's build script for tazpup but the difference is that my version can build the system from binaries without using the rootfs from an exiting Slitaz ISO.

I have a lot of work still to do on it and so I won't try to argue whether or not it meats the criteria that you set out.

[s243a]

Puppy today is built using Woof-CE. Well, at least, official Puppies.

Some people have suggested that Woof-CE should not be the only way to build Puppies, because in their opinions, Woof-CE is inflexible, difficult-to-use, etc. Regardless of the truth of these opinions, the question is interesting nonetheless: what oher system is available, today, or in near-future, to build a Puppy?

From what I here on this forum it take a fair bit of time for WoofCE to build a package. It may well be easy to use (I don't know) but my guess is that if you make a mistake then it might be a long process to correct the mistake, unless you decide to just patch the output instead.

Anything which takes a long time to do and has complex internals might appear as a challenging task and this perception might make said task feel daunting. I like mistfires script because it is a single script with not that many lines of code. This makes it easy to understand. In an effort to make mistfires code more flexable I've broken it up into many separate functions, and while this is more maintainable one now has to jump around between multiple files to follow the logic. The resulting fragmentation may make my system harder to understand as a whole then mistfires script even though the individual pieces of my system may be easier to understand than mistries.

WoofCE is a much more mature product then both mine and mistfires build system and as a consequence there are many more lines of code to read so whether or not WoofCE is easy to use it might not be the easiest place to start if one wants to understand how build system works.

In my opinion understanding how build systems work is often useful if one wants to teak them to get them to do what they want. Code can be fabulously written but as the code becomes more complex, some people find it easier to start fresh. The best analogy I think of is a tree. Sometimes we prune a tree so it has relatively speaking a greater root system to support it. In this analogy I equate the roots with the knowledge and understanding of the developers and the above ground part of the tree as the output. By taking only pieces of WoofCE at a time and incorporating them into their build system one might better match what they produce with their understanding but when they there understanding grows deep enough they can decide if WoofCE is or is not the build system that they want to support.

[dancytron]

Certainly Fred's scripts that produce Debian Dog Stretch and Devuan Dog meet your criteria. https://github.com/DebianDog/MakeLive/b ... Stretch.md

[Lobster]

I am specifically talking about:
1. Scripts, which can be downloaded and used by others, to produce a Puppy-like distro (in the form of LiveCD ISO, LiveUSB images, etc).
2. Step-by-step instructions, which can be followed by others, to produce a Puppy-like distro.

Great insights already from our smart-dogs



Lobster design script

1. Select hardware (eg. Raspberry Pi)
2. Select must have software (what is a Puppy like distro?)
eg. terminal, Bash commands, GUI, text editor, browser, file manager (Rox-Filer) etc



I used the original Woof, when it was being developed and got to about 50% to 60% of a working build. In other words nothing to show for my time. Far too complex for my limited capacity.

[jamesbond]

@s243a, @dancytron: thanks. They're certainly build systems according to the criteria I set above in the first post.

I now use the 2nd post to list all the known alternative build systems, and will keep expanding it as I receiver further feedback.

@Lobster: "Puppy-like distros" means distros that look like, or behave like, Puppy Linux. This includes (of course) Puppy Linux itself, in its various incarnations, both official (bionicpup etc) and unofficials (dpup-stretch, puduan etc); it includes direct derivatives (puplets - e.g. lxpup, etc); it also includes "spiritual derivative" e.g. distros that are "inspired" by Puppy Linux, e.g. fatdog, debiandog, tazpup, and many others.

whether or not WoofCE is easy to use it might not be the easiest place to start if one wants to understand how build system works.

This is true, and worthy of a separate discussion thread. Once we know what are the available build systems, we can discuss the relative merit of them, looking from various aspects (ease of use, time to build, ease of modification, supportability, code readability (for ease of learning), maintainability, etc).

[Lobster]

Understood @JamesBond

Good luck.

Perhaps 'Linux from Scratch' and similar would qualify? I seem to remember this has been used for at least one official Puppy
https://unix.stackexchange.com/question ... lash-drive

Remastering scripters ... where are they?

... and now back to the script ...

[ozsouth]

@jamesbond - sorry to displace this important discussion with my frippery - I posted before I read this. I have had issues with most pups since Slacko64-6.9.9.9. Is it a build system issue? I don't know and am MOST reluctant to cast aspersions on great efforts for what is now the backbone of Puppy. Multiple build systems - would be great to have, but does that put more pressure on the few? Best wishes with your quest.

[s243a]

To add to the list I believe both Quirky and EasyOs have their own build systems but someone can confirm.

[jamesbond]

@Lobster: Linux from scratch (LFS) won't cut it as a build system, as it is more of a "book". Furthermore, if we follow the instructions in the book, we don't end up with a Puppy, or even a distro. We end up with a running Linux system (not packaged as a distro, or as an ISO), CLI-only, with only bash and a few other common tools (gzip, etc), without any package manager whatsoever ...

There is a sister project of LFS called ALFS (Automated LFS), which aims to "automate" the build process of LFS instructions. There have been many variants of of ALFS, the latest incarnation is "jhalfs". But even when running this tool, won't give you an ISO file; you end up instead with a root filesystem, containing basic CLI-based Linux system, with bash, and a few other common tools (gzip, etc), without any package manager whatsoever ... you get my point

You can, however, make a build system based on the instructions given in LFS. That's what I do with Fatdog.

@s243a: Indeed Quirky and Easy has their own build system (WoofQ and WoofE), which was forked from the original Woof. I will add that.

@ozsouth: No apologies necessary

As for Woof-CE: Woof-CE has two components:
1) "Woof-CE the distro build system"
2) "Woof-CE the puppy essential scripts"
These two components are largely independent of each other but not totally, since some scripts need tweaks and/or configuration depending on the parent distro; these tweaks/configuration are done/created by (1) during the build process.

(1) job is build the distro, resulting in a LiveCD ISO, LiveUSB image, etc. If it can produce this, then it's job is done and by definition it is not broken.
(2) job is to actually run the operating system and provides the familiar Puppy functions, GUI, etc.

If you're having the exact identical failure with all pups across different breeds (Slacko, Debian/Ubuntu-based pups) but with the common factor that they are built from Woof-CE, and excluding stuff like hardware problem, kernel problem, missing firmware, etc: then most likely the culprit is in (2) because indeed the same set of puppy scripts get incorporated into every Woof-CE pup out there.

I would not call this as a "build system issue" (because that refers to (1)), however I do would call this as a Woof-CE bug since (1) and (2) are maintained together. The best way to resolve this is to report the issue to whoever maintains the distro (666philb, peebee, micko, etc) and they will then escalate this to whoever maintains Woof-CE. Of course, you can report this directly to Woof-CE guys too if you wish.

Multiple build systems - would be great to have, but does that put more pressure on the few? Best wishes with your quest.

Thank you. My intention with this thread is to discover __existing__ build systems that are currently used to build puppy variants, not to invent a new one (although if others are interested to start their own build system, then why not). Lobster already started "Puppy 9" movement, and we have people who are dissatisfied with Woof-CE, suggesting to replace it. So I thought, ok, lets look at what we currently have so we can have a realistic expectation going forward. Once we have more or less complete list, then we can have an objective comparison of these build systems (which I intend to do in another thread, not this one) so we can judge the relative merits of each one of them. After that, what happens next depends on the actual Puppy distro builders, really. At the very least they will be armed with additional knowledge that there are choices when selecting a build system.

EDIT: typo, grammar.

[dancytron]

Known build systems (listed in order they are submitted in this thread):
4. DebianDog build system. The build system to build DebianDog family of distros (DebianDog Wheezy, DebianDog Jessie, StretchDog, etc). It builds ISO from Debian binary packages.
(question - is there similar build system to build from Ubuntu parent, e.g. to build XenialDog? Or does the same build system work for both, only needing a different config file?)

I am sure Fred will chime in, but I am under the impression that before Jessie (Wheezy and before), Debian Dog was built by hand. For Jessie, it was more a set of instructions on how to use Debian's gui tool. So, Stretch was the first mklive script. After Stretch, Fred built one for Devuan.

If there is a script for the Ubuntu builds, I don't think Fred has released it into the wild.

[jamesbond]

Although this isn't exactly on topic, I'd like to say a little bit about the two parts of Woof-CE:
1. The build system proper.
2. The "puppy essential scripts" (and initrd, etc).

To a certain extent, all other build systems listed above have these two components inside; and as I said above, these two components are largely independent from each other although they do have some dependency with each other.

Now this begs the question: is it possible to separate the two, and mix and match them (e.g extract the "essential scripts" from Woof-CE and use other build system to build a pup?).

The answer is of course yes, and to a certain extent this has been done. For example, s243a said exactly that with his tazpup build system. In the past I also did this with woof-ng; I basically build a new build system (1) while re-using the same puppy essential scripts (2).

But of course, a lot of work is involved, because not only the dependency between (1) and (2) must be severed and resolved, but also there are other factors involved. For example, Woof-CE currently supports only Slackware (+derivative) and Debian (+derivative). There are support for Arch but it has gone bitrotten and probably won't work without extensive re-work. Whe s243a integrates the puppy essential scripts to tazpup, he basically has to adapt it so that it works with a new parent distro - SliTaz. It gets more complex when one wants to support multiple architecture (32-bit x86, 64-bit x86, 32-bit ARM, 64-bit ARM, etc). Of course, not all of (2) are parent distro or even arch dependent. Some are totally parent/arch independent and can be used anywhere as long as the supporting tools are available (e.g. SFS Loader, etc); but in general, you still need to do this adaption to transfer (2) to another build system.

Could (2) be totally separated from any build system, and be made modular so that it can be used with __any__ distro? E.g. can they be distilled into a package, that one can install, so that by installing a .deb package to Debian, it will turn into Dpup? Or distill into a .TXZ package and installing to Slackware will turn it into Slacko? Or perhaps distill into an SFS (then rename to .tcz) and by using it on Tiny Core, it will turn into some sort of Puppy? I leave the answer as an exercise for the reader

[jamesbond]

I am sure Fred will chime in, but I am under the impression that before Jessie (Wheezy and before), Debian Dog was built by hand. For Jessie, it was more a set of instructions on how to use Debian's gui tool. So, Stretch was the first mklive script. After Stretch, Fred built one for Devuan.

If there is a script for the Ubuntu builds, I don't think Fred has released it into the wild.

Thanks. Let's see what Fred or wiak have to say about it.

[Lobster]

Thanks for the info @jamesbond

Appreciate it

[s243a]

2. Step-by-step instructions, which can be followed by others, to produce a Puppy-like distro.[/b]

---

Ideally, (1) and (2) should go together but I'm willing to accept (2) without (1) with the provision that it has enough detail so that a capable person would be able to automate it to produce (1).

As a side note there is also "corepup". I don't think it has a build system (and I haven't tried it), but if there is (or alternatively if someome will make) step by step instructions on how to produce it then maybe it will qualify.

That said it doesn't use the "layered file system" which is a pretty dominant characteristic of puppy linux. Maybe wanderer, fredx181 or wiak can speak more about what corepup is all about.

[musher0]

Hello all.

IIRC, forum member nosystemdthanks has evolved a figOS
script that builds corepup and other Pups.

If he reads this thread, could he please confirm?

This is FYI only. I have never tried it, so I don't know if it meets
jamesbond's criteria.

BFN.

[ally]

http://archive.org/download/Puppy_Linux_Refractapup

look for mkfigos**

[fredx181]

Known build systems (listed in order they are submitted in this thread):
4. DebianDog build system. The build system to build DebianDog family of distros (DebianDog Wheezy, DebianDog Jessie, StretchDog, etc). It builds ISO from Debian binary packages.
(question - is there similar build system to build from Ubuntu parent, e.g. to build XenialDog? Or does the same build system work for both, only needing a different config file?)

I am sure Fred will chime in, but I am under the impression that before Jessie (Wheezy and before), Debian Dog was built by hand. For Jessie, it was more a set of instructions on how to use Debian's gui tool. So, Stretch was the first mklive script. After Stretch, Fred built one for Devuan.

If there is a script for the Ubuntu builds, I don't think Fred has released it into the wild.

Not for Xenialdog (or other Ubuntu builds) only for the already mentioned DebianDog build system. and for the Devuan "ascii" branch of Debian "Stretch":
http://murga-linux.com/puppy/viewtopic. ... 908#996908

Fred

[wiak]

There is also dCoreDog, from a couple of years ago, which uses tinycore linux dcore (debian repos):

http://www.murga-linux.com/puppy/viewtopic.php?p=949292

No build script provided for that; rather it is a step by step HowTo, though of course that could be scripted. Some of the same steps could be adopted/modified for corepup - especially the gtkdialog extras needed to run Pup utils. However, I'm not planning to do further on tinycore quite at the moment.

Come to think of it, Fred produced a quick one-off version of Dog Slitaz he referred to as TazDog (using Porteus boot as far as I recall). Not scripted though - just a manual build methinks.

wiak