Let us start explaining the concepts inside fillPouch.

Think of the fact that kangaroos can grow inside the pouch of an earlier kangaroo. once grown, each female kangaroo in turn can grow other kangaroos in their respective pouches. That is the kind of recursion that is seen here. That's also the reason for the name: FillPouch!

FillPouch allows you to just write plain-jane HTML if that is what you want. Then as your HTML becomes more sophisticated, you can refactor what you wrote -- split up parts of the HTML into different files ("fragments") and include those parts in all the appropriate locations. All using meta-instructions embedded anywhere. You would write special "pouch" meta-instructions in some files that inserts the appropriate fragment in those locations.

Budweiser*? But why sir?
The simple, age old reason: Divide and Conquer. Many times making websites gets you hopelessly entangled in both form and function (err... content). FillPouch allows you to separate out the form, from the content. Fleshing out contents has never been easier. You are focussed ONLY on the work at hand, and not distracted by other things happening in the HTML!

All kinds of divide and conquer can be done
This "reductionist" approach can be done as per your own terms. At your own pace. In some cases you may want to place the contents you wrote only in one place. For e.g. an article in a blog would be available only on one HTML page. In some cases that one file may be assembled together from multiple different fragments.

In some other cases, you may want to place the same contents in multiple places. In yet some other cases, you may want to write a short piece of text, and not be bothered by writing a separate file just for that. So you write that using an instruction in the project file.

Similar in concept to HTML itself
One big advantage of this approach is that you can treat chunks of HTML code as if they are special HTML elements. We all know that HTML can have paired tags for one logical block inside the HTML. For example; <i> is paired with </i>

On similar lines, you can think of one chunk of HTML stuff at the beginning of the HTML file (the header portion) and another chunk at the ending of the HTML file (the /body portion) Similarly you find all CSS libraries handling the beautification by doing some chunk of work at the beginning of some content, and some chunk of work at the end.

In FillPouch, you can place each of those chunks in their own individual fragments, and insert meta-instructions to insert those chunks in your data, as if they were special HTML elements (albeit with our syntax) FillPouch will therefore stitch the front chunk with the back(rear) chunk and build the page perfectly. The special "pouch" meta-instructions come in handy for these insertions.

Why is it so fast?
One of the reasons why FillPouch is really fast is because it simply reads all the files from first character to last, without retracing and keeps building the site. The moment it encounters a meta-instruction, it reacts to it and carries out the instruction. It had remembered its place before the instruction was carried out. So once the work is done as per the instruction, it returns back there to continue building the site. It NEVER retraces or does multiple passes.

There are some more reasons for its speed. Explained at the end.

FillPouch picks up each file listed in the project file, work on the meta-instructions inside it. Some meta-instructions are simple insertions of pieces of text (called "strings" in programmer's parlance) But some meta-instructions will ask FillPouch to get the entire text of a file. In some cases, the file string is placed verbatim -- and FillPouch merrily proceeds ahead. In some cases, FillPouch will notice that the new file has its own meta-instructions inside which it now needs to work on the way it did for the earlier one...And on and on it can go. That is how recursion happens here. Hopping from one file into another, and thence into the next one inside...

FillPouch has no clue about HTML
Strange as it may sound, FillPouch does NOT understand HTML at all. It just knows and acts on the meta-instructions you leave behind on which files to be processed and what should happen inside those files; in terms of replacing the meta-instruction with the actual content. FillPouch does have a deep understanding of tree structures and metadata -- but it is not based on figuring out the DOM (Document Object Model) of the HTML. This is yet another reason why FillPouch is so fast -- as it does away with micro-managing HTML! It also agnostic about CSS -- so you can use practically any CSS library in your website. Albeit, ones that do not need additional tooling. All those CSS libraries that gets to work with just a link element in the HEAD section of HTML; those are the ones that FillPouch loves.

FillPouch is also a lean-mean well oiled machine -- a compiled Windows executable with no dependencies on anything else. We focussed it entirely on the internal concepts used here, instead of that of HTML or CSS itself.

*Mallus will get this joke!