05/13/2025
Ayllu release 0.4.0 has been tagged after a year of inconsistent development. This release has seen a major reduction in the number of features available in Ayllu and a simplification of it's operation. Most of the features that have been removed will eventually make their way back into the software as time permits and can be done in a way that is simple to maintain. Although the core functionality of Ayllu has been minimized, two new major (unfinished) libraries were developed adjacently: maitred, an embedable SMTP server, and papyri, an OCI compliant container registry. See more details below.
The ayllu-jobs binary has been temporarily removed after several iterations
of implementing sqlite based state. The binary is responsible for
doing CLOC anaylsis with Tokei,
calculating authorship statistics, and anything else that needs to be run at a
periodic interval. The jobs themselves have worked well but I've not been
satisfied with any approach I've used to communicate stateful data into the UI
in a way that is extensible. Ultimately my goal is to maintain an ultra fast
static web interface that can be easily extended with new kinds of repository
information. A future update will re-enable the state as opt-in likely via
an RPC interface or shared database crate.
Although the server has the ability to generate everything that is needed
to display git blame data I haven't been able to design UX that looks good
enough to present it so I've opted to remove the code for now. If anyone has
suggestions for how to do it in pure html/css please reach out.
The themeing engine was reverted back from Tera to Askama see commit: 5c5e94.
A concept of static "membership" has been added to the server which is browsable
over the webfinger protocol. You
can use the quipu binary to query resources on an any Ayllu server:
quipu finger "acct:demo@example.org"
{
"subject": "demo@example.org",
"links": [
{
"rel": "http://webfinger.net/rel/profile-page",
"type": "text/html",
"href": "https://example.org/demo"
},
{
"rel": "http://webfinger.net/rel/profile-page",
"type": "text/html",
"href": "https://example.org/@demo"
},
{
"rel": "http://webfinger.net/rel/avatar",
"href": "https://example.org/avatar.png"
},
{
"rel": "http://ayllu-forge.org/rel/description",
"properties": {
"text": "Programmer interested free software"
}
}
]
}
# Or via curl
curl 'http://localhost:10000/.well-known/webfinger?resource=acct:demo@example.org' |jq .
Currently the server only can share static account information from the global configuration file but future updates will expose repository and other information. Eventually there are plans to implement global searchable index of Ayllu instances which will crawl this protocol data.
Ayllu will detect repositories that contain origins that have the mirror flag
enabled and display them as "non-canonical" sources in the UI.
The multiuser container image has been further developed and offers a simple way for managing trusted multi-user forge environments.
Two new crates ayllu-shell and ayllu-keys were added which when completed will allow a simple static configuration of user authorization into an Ayllu managed server.
A new crate offering an embeddable SMTP server has been developed called
maitred for use in Ayllu so that it
can easily receive patches over SMTP. This project is made possible by the
low-level protocol implementation of the
stalwart project. Most of this
crate is functional however ARC and DMARC verification need to be finished
before we can safely handle messages. Once completed this will be implemented
as part of the ayllu-mail binary.
The Papyri OCI container registry has started development which will provide the ability to read and write container images directly into an Ayllu instance. This crate currently only supports direct file system storage but a SQLite blob backend or possibly S3 compatible store may be added. This crate is shipped with an export of Axum routes and once integrated will allow pushing and pulling OCI manifests directly from the web interface.
That's all for now, thanks for reading!
There is no deficiency of static website generators these days and so naturally I had to write my own.
The main functionality of the tool will be encapsulated in a Python script
called render.py. Even though
string based templates are the wrong solution
we're going to use a combination of
Jinja and markdown to generate HTML
output. Each page will be generated by a single call to the script which will
allow the whole thing to be ran in parallel across multiple CPUs by wiring
it together using ninja.
Here you can see an example invocation of the render.py script with some
annotated flags.
./render.py \
# the HTML template file
--template=index.jinja \
# this contains a map of each webpage which is available in the renderer
# as well as page level configuration options.
--sitemap sitemap.yaml \
# markdown file, this one contains the text I'm currently typing!
--content=blog/building-this-website/README.md \
# output of the rendered HTML page
gen/blog/building-this-website/index.html
I want to generate a "tree" sitemap similar to a file browser like NERDTree.
We'll pass in a YAML document to the render.py script and then transform
it into an XML tree.
def _load_sitemap(path, current_path):
by_name = dict()
flattened = []
with open(path, "r") as fp:
links = yaml.safe_load(fp.read())
def _link(links, parent=None):
for link in links:
flattened.append(link)
link["parent"] = parent
if "others" in link:
_link(link["others"], parent=link)
def _make_url(link):
path = [link["name"]]
parent = link["parent"]
while parent is not None:
path.append(parent["name"])
parent = parent["parent"]
path.reverse()
return "/".join(path)
_link(links, parent=None)
for link in flattened:
target = "/" + _make_url(link)
if target == current_path:
link["active"] = True
else:
link["active"] = False
link["url"] = target
by_name[target] = link
return dict(by_name=by_name, links=links)
def _make_tree(links):
def _populate(root, links):
for link in links:
elm = ET.Element("li")
if "directory" in link and link["directory"]:
elm.text = link["name"]
else:
lref = ET.Element("a", href=link["url"])
lref.text = link["name"]
if link["active"]:
lref.text = lref.text + " <"
elm.append(lref)
if "others" in link:
others = link["others"]
ul = ET.Element("ul")
elm.append(ul)
_populate(root=ul, links=others)
root.append(elm)
params = {"class": "tree"}
root = ET.Element("ul", **params)
_populate(root=root, links=links)
return ET.tostring(root).decode()
Images can be reduced in size with dithering algorithms and they also look very cool. The idea for this was inspired by LOW←TECH MAGAZINE.
I can implement some basic spell checking against the website with aspell.
find content -name '*.md' -exec aspell --mode=markdown check {} \;
We'll use the native inotify via the inotifywatch tool which is available on all Linux distributions.
#!/bin/sh
# the actual command we want to run each time any file changes in the project
BUILD_CMD="$@"
# some pretty colorized output
_do_build() {
$BUILD_CMD && {
echo -e "\033[32;1;4mSuccess\033[0m"
} || {
echo -e "\033[31;1;4mFailure\033[0m"
}
}
# build the project the first time you start up the watch
_do_build
# watch all the files in the project except for the output directory
find . -type d -not -path './gen*' -printf '%p ' | xargs inotifywait \
-m -e close_write \
--format %e/%f |
while IFS=/ read -r events file; do
echo "file $file modified, rebuilding"
_do_build
done
Now we can test the script by launching it scripts/watch.sh build.py.
You can checkout the source for the whole site here.