I recently got a new phone and thus had to re-do the setup of my mobile blogging pipeline. So, basically, allow me to checkout, modify, test, commit and push the sources of this Hugo based static page under Android. While doing so I noticed some necessary changes and improvements, and also wanted to make use of my Taskfile which does most of the heavy lifting now, so here are my updated steps.

Apps & permissions

1. Install Tasker
2. From F-Droid install
   • Termux
   • Termux:Tasker
   • Markor
3. Grant permissions
   • Tasker: Run commands via Termux
   • Termux: Draw over apps

Termux setup

# setup access to storage
termux-setup-storage

# install packages
pkg upgrade
pkg install git gh hugo iconv vim

# log into github
gh auth login

# navigate to Markor's document folder & checkout sources
cd storage/shared/Documents/markor
git clone --recurse-submodules https://github.com/foosel/foosel.github.io

# create symlink in home
ln -s foosel.github.io ~/foosel.net

# mark checkout as safe
git config --global --add safe.directory /storage/emulated/0/Documents/markor/foosel.github.io

# set git user metadata
git config --global user.email "you@example.com"
git config --global user.name "Your Name"

# we want to use our Taskfile...
pkg install golang
go install github.com/go-task/task/v3/cmd/task@latest

As Tasker will stay the only app on my system allowed to send commands to Termux, and I write all my tasks myself, I also added allow-external-apps=true to .termux/termux.properties as described here. That allows me to directly execute stuff from Tasker by absolute path vs having to add a bunch of wrapper scripts to ~/.termux/shortcuts

To quickly test if everything works so far:

cd ~/foosel.net
task serve

This should build the page and serve it on http://127.0.0.1:1313 (with auto reload).

Tasker setup

I created a bunch of tasks, gave all of them an icon and added them to my launcher.

Serve foosel.net

    Task: Serve foosel.net
    
    A1: Termux [
         Configuration: ~/go/bin/task serve
         
         Working Directory ✓
         Terminal Session ✓
         Wait For Result ✕
         Timeout (Seconds): 10
         Structure Output (JSON, etc): On ]
    

Pull foosel.net

    Task: Pull foosel.net
    
    A1: Termux [
         Configuration: /data/data/com.termux/files/usr/bin/git pull
         
         Working Directory ✓
         Stdin ✕
         Custom Log Level null
         Terminal Session ✕
         Wait 
         Timeout (Seconds): 10
         Structure Output (JSON, etc): On ]
    
    A2: Flash [
         Text: Pulled foosel.net sources
         Continue Task Immediately: On
         Dismiss On Click: On ]
    

Push foosel.net

    Task: Push foosel.net
    
    A1: Termux [
         Configuration: /data/data/com.termux/files/usr/bin/git push
         
         Working Directory ✓
         Stdin ✕
         Custom Log Level null
         Terminal Session ✕
         Wait 
         Timeout (Seconds): 10
         Structure Output (JSON, etc): On ]
    
    A2: Flash [
         Text: Pushed foosel.net sources
         Continue Task Immediately: On
         Dismiss On Click: On ]
    

New Blog Post

    Task: New Blog Post
    
    A1: Input Dialog [
         Title: New post
         Text: Enter title
         Close After (Seconds): 120
         Input Type: 540673 ]
    
    A2: Termux [
         Configuration: ~/.local/bin/task new-blog -- "%input"
         
         Working Directory ✓
         Stdin ✕
         Custom Log Level null
         Terminal Session ✕
         Wait For Re
         Timeout (Seconds): 10
         Structure Output (JSON, etc): On ]
    
    A3: JavaScriptlet [
         Code: var uri = "content://net.dinglisch.android.taskerm.fileprovider/storage/emulated/0/Documents/markor/foosel.github.io/" + stdout.trim();
         Auto Exit: On
         Timeout (Seconds): 45 ]
    
    A4: Send Intent [
         Cat: None
         Mime Type: text/markdown
         Data: %uri
         Package: net.gsantner.markor
         Class: net.gsantner.markor.activity.DocumentActivity
         Target: Activity ]

New TIL Post

    Task: New TIL Post
    
    A1: Input Dialog [
         Title: New TIL
         Text: Enter title
         Close After (Seconds): 120
         Input Type: 540673 ]
    
    A2: Termux [
         Configuration: ~/.local/bin/task new-til -- "%input"
         
         Working Directory ✓
         Stdin ✕
         Custom Log Level null
         Terminal Session ✕
         Wait For Res
         Timeout (Seconds): 10
         Structure Output (JSON, etc): On ]
    
    A3: JavaScriptlet [
         Code: var uri = "content://net.dinglisch.android.taskerm.fileprovider/storage/emulated/0/Documents/markor/foosel.github.io/" + stdout.trim();
         Auto Exit: On
         Timeout (Seconds): 45 ]
    
    A4: Send Intent [
         Cat: None
         Mime Type: text/markdown
         Data: %uri
         Package: net.gsantner.markor
         Class: net.gsantner.markor.activity.DocumentActivity
         Target: Activity ]

Result

I now have all these tasks available under a tag in my launcher (Kvaesitso) and can easily work on posts from my phone once more. In fact, this post was entirely written on it.

The whole pipeline is a bit slimmer than last time as well and required less bash wrappers, which I like a lot better 👍

I also decided to go a bit more commandline-centric in this iteration - git add and git commit I’ll actually run manually in Termux this time around (I rarely used the corresponding shortcuts I created last time).

Once I’m satisfied with the local preview and have committed, a git push is all that I need for publishing - the CI does the rest.

So just now I’ve done some long overdue spring cleaning on this page:

1. I updated PaperMod¹ & adjusted my overwrites as necessary
2. I implemented my custom rss feed template with some more logic to render it with all main sections on home
3. I disabled the automatic inclusion of the section feeds and created my own with proper title attributes ("(All|Blog|TIL) posts on foosel.net"), put into the head of all pages
4. I overrode the default name of the generated feeds to be feed.xml & added the necessary redirects (hopefully…)
5. I also added links to the main RSS feed at two prominent places: in the social icons on the home page as well as in the main navigation next to the search button. While the feeds were always discoverable through the related link tags in the HTML page itself, and there were also specific links on the section main pages, I still got some questions here and there on whether there was a feed, so I hope this makes things easier to discover now.

If you want a look behind the scenes on how I did that, this page’s source is on a public repo, so feel free to take a look 😊

All that’s left to say is: I’m sorry should I have broken something there or caused your RSS reader to push all old posts into your face 😬

However, it became a bit annoying adding new vouches to the json manually.

So today I sat down and made it get created automatically during my page build powered by Hugo, based on a list of vouches stored in a vouches.yaml data file¹.

For this I first created said data file in data/vouches.yaml:

- url: https://food.foosel.net
  date: "2026-03-14"
- url: https://chaos.social/@foosel
  date: "2026-03-14"
- url: https://octoprint.org
  date: "2026-03-14"
# ...

Then I created a new output format humanjson in my config.yaml, making sure to also add it to the home page:

outputs:
  home:
    - HTML
    - JSON
    - humanjson
  # ...

outputFormats:
  # ...
  humanjson:
    mediaType: application/json
    baseName: human
    isPlainText: true
    notAlternative: true
  # ...

Finally I created a template for that in _layout/home.humanjson.json:

{
    "version": "0.1.1",
    "url": {{ .Site.BaseURL | jsonify }},
    "vouches": [
    {{- range $index, $vouch := hugo.Data.vouches }}
    {{- with $vouch }}
        {{- if $index }},{{end}}
        {
            "url": {{ .url | jsonify }},
            "vouched_at": {{ .date | jsonify }}
        }
    {{- end }}
    {{- end }}
    ]
}

I kept the required <link rel="/human.json"> in my layouts/partials/extend_head.html file that gets included on all pages by my theme (contrary to how the linking of output formats work, which is why I went with notAlternative: true for that).

And to make it even easier to quickly add a new vouch, I also added a new task to my Taskfile:

  add-vouch:
    desc: Adds a new vouch to human.json.
    vars:
      PAGE: '{{.CLI_ARGS}}'
      FILE: 'data/vouches.yaml'
      TODAY: '{{now | date "2006-01-02"}}'
    cmds:
      - |
        cat >> {{.FILE}} <<EOF
        - url: {{.PAGE}}
          date: "{{.TODAY}}"
        EOF

Now, vouching for a page² is as easy as

task add-vouch -- https://example.com

mediaTypes:
  application/feed+json:
    suffixes:
      - json

outputFormats:
  jsonfeed:
    mediaType: application/feed+json
    baseName: feed
    rel: alternate
    isPlainText: true

This adds a new media type application/feed+json with the extension json and creates a new output format jsonfeed rendering into that media type with a base name of feed (so feed.json as recommended by the JSON Feed spec).

This then needs to be added to the outputs it should be generated for - on this page I’ve only added it to sections. Again, in config.yaml:

outputs:
  home:
    - HTML
    - JSON
  section:
    - HTML
    - RSS
    - jsonfeed

Finally, a template needs to be created so that Hugo can actually render something. I’ve put this into layouts/_default/list.jsonfeed.json (following the expected naming scheme of list.<outputFormat>.<extension>):

{{- $pctx := . -}}
{{- if .IsHome -}}{{ $pctx = site }}{{- end -}}
{{- $pages := slice -}}
{{- if or $.IsHome $.IsSection -}}
{{- $pages = $pctx.RegularPages -}}
{{- else -}}
{{- $pages = $pctx.Pages -}}
{{- end -}}
{{- $limit := site.Config.Services.RSS.Limit -}}
{{- if ge $limit 1 -}}
{{- $pages = $pages | first $limit -}}
{{- end -}}
{{- $title := "" }}
{{- if eq .Title .Site.Title }}
{{- $title = .Site.Title }}
{{- else }}
{{- with .Title }}
{{- $title = print . " on "}}
{{- end }}
{{- $title = print $title .Site.Title }}
{{- end }}
{
    "version": "https://jsonfeed.org/version/1.1",
    "title": {{ $title | jsonify }},
    "home_page_url": {{ .Permalink | jsonify }},
    {{- with  .OutputFormats.Get "jsonfeed" }}
    "feed_url": {{ .Permalink | jsonify  }},
    {{- end }}
    {{- if (or .Site.Params.author .Site.Params.author_url) }}
    "authors": [{
      {{- if .Site.Params.author }}
        "name": {{ .Site.Params.author | jsonify }},
      {{- end }}
      {{- if .Site.Params.author_url }}
        "url": {{ .Site.Params.author_url | jsonify }}
      {{- end }}
    }],
    {{- end }}
    {{- if $pages }}
    "items": [
        {{- range $index, $element := $pages }}
        {{- with $element }}
        {{- if $index }},{{end}} {
            "title": {{ .Title | jsonify }},
            "id": {{ .Permalink | jsonify }},
            "url": {{ .Permalink | jsonify }},
            {{- if .Site.Params.showFullTextinJSONFeed }}
            "summary": {{ with .Description }}{{ . | jsonify }}{{ else }}{{ .Summary | jsonify }}{{ end -}},
            "content_html": {{ .Content | jsonify }},
            {{- else }}
            "content_text": {{ with .Description }}{{ . | jsonify }}{{ else }}{{ .Summary | jsonify }}{{ end -}},
            {{- end }}
            {{- if .Params.cover.image }}
            {{- $cover := (.Resources.ByType "image").GetMatch (printf "*%s*" (.Params.cover.image)) }}
            {{- if $cover }}
            "image": {{ (path.Join .RelPermalink $cover) | absURL | jsonify }},
            {{- end }}
            {{- end }}
            "date_published": {{ .Date.Format "2006-01-02T15:04:05Z07:00" | jsonify }}
        }
        {{- end }}
        {{- end }}
    ]
    {{ end }}
}

By default, this generates a feed with summaries only. If you want a full content feed, set params.showFullTextinJSONFeed to true in config.yaml.

The relevant docs for custom media types, output formats and template locations can be found here.

On the Papermod theme the above will automatically cause something like

<link rel="alternate" type="application/feed+json" href="https://foosel.net/til/feed.json">

to be added to the head of the page, as needed for discovery. In other themes you might have to do it yourself.

The result of all of this is something like this.

One thing that kept me from blogging more so far was the difficulty in working on posts on my phone. So after switching this blog over to Hugo I decided to see if I couldn’t improve on this situation.

I needed a solution that would allow me to

1. Checkout my page’s git repository from GitHub
2. Quickly create a new post, consisting of a new folder inside content/blog matching my chosen <year>-<month>-<day>-<title slug>/index.md folder structure, based on just a title
3. Allow me to edit the post, preferably in a text editor focused on Markdown (and ideally allow me to preview the post as well)
4. Optional: Run the Hugo build on my phone as well for final checks
5. Finally, commit the new post and push it so that my GitHub Action workflow can take care of the rest

I started hunting for options, and I’m happy to report that for now I seem to have found a - quite geeky - solution that involves the use of Termux (Linux terminal environment for Android), Markor (Markdown editor) and Tasker (Automation tool)¹.

I installed Termux, Termux:Tasker, Termux:Widget and Markor via F-Droid - the versions available on Google Play are outdated and no longer supported. I already had Tasker installed, but I made sure to give it the additional permission to send commands to Termux. For Termux, I also made sure to allow it to draw over other apps.

I then fired up Termux and took care of storage access and some packages first:

termux-setup-storage
pkg upgrade
pkg install git gh hugo iconv vim

Markor’s default folder is located at Documents/markor and so this is where I decided to checkout my page’s repository to. I also made sure to set some config settings needed for stuff to work²:

gh auth login
cd storage/shared/Documents/markor
git clone https://github.com/foosel/foosel.github.io
git config --global --add safe.directory /storage/emulated/0/Documents/markor/foosel.github.io
git config --global user.email "you@example.com"
git config --global user.name "Your Name"

Next I took care of some helper scripts for Termux:Widget and Tasker. I first created some folders:

mkdir -p ~/.shortcuts
chmod 700 -R ~/.shortcuts
mkdir -p ~/.termux/tasker
chmod 700 -R ~/.termux/tasker

Then I added some helper scripts to them:

~/.shortcuts/pull_blog

#!/bin/sh

cd ~/storage/shared/Documents/markor/foosel.github.io
git pull

~/.shortcuts/push_blog

#!/bin/sh

cd ~/storage/shared/Documents/markor/foosel.github.io
git push

~/.termux/tasker/serve_blog

#!/bin/sh

cd ~/storage/shared/Documents/markor/foosel.github.io
hugo server -D -F --noBuildLock

~/.termux/tasker/new_blog_post

#!/bin/bash

checkout=~/storage/shared/Documents/markor/foosel.github.io

slugify () {
     echo "$1" | iconv -t ascii//TRANSLIT | sed -r s/[~\^]+//g | sed -r s/[^a-zA-Z0-9]+/-/g | sed -r s/^-+\|-+$//g | tr A-Z a-z
}

title=$1
date=$(date +%Y-%m-%d)
slug=$(slugify "$title")

cd $checkout
mkdir -p content/blog/$date-$slug
cat > content/blog/$date-$slug/index.md <<EOF
---
title: "$title"
date: $date
draft: true
---

EOF

echo $date-$slug/index.md

~/.termux/tasker/commit_blog

#!/bin/sh

message=$1

cd ~/storage/shared/Documents/markor/foosel.github.io
git add .
git commit -m "$message"

pull_blog and push_blog take care of git synchronization.

serve_blog runs Hugo with draft and future posts visible. The page can be viewed in the browser on the phone at http://localhost:1313.

new_blog_post takes a post title as its first argument and from that creates the aforementioned folder structure within the content/blog folder, including a prefilled index.md.³

And finally commit_blog takes a commit message as its first argument, stages all changes in the checkout and commits them with the supplied message.

Next, I created Termux:Widget widgets on my desktop for pull_blog, push_blog and run_hugo.

Then I opened Tasker and created two new tasks:

    Task: New Post
    
    A1: Input Dialog [
         Title: New post
         Text: Enter title
         Close After (Seconds): 30
         Input Type: 540673 ]
    
    A2: Termux [
         Configuration: new_blog_post "%input"
         
         Working Directory ✕
         Stdin ✕
         Custom Log Level null
         Terminal Session ✕
         Wait For Result ✓
         Timeout (Seconds): 10
         Structure Output (JSON, etc): On ]
    
    A3: JavaScriptlet [
         Code: var uri = "content://net.dinglisch.android.taskerm.fileprovider/external_files/storage/emulated/0/Documents/markor/foosel.github.io/content/blog/" + stdout.trim();
         Auto Exit: On
         Timeout (Seconds): 45 ]
    
    A4: Send Intent [
         Action: android.intent.action.SEND
         Cat: None
         Mime Type: text/markdown
         Data: %uri
         Package: net.gsantner.markor
         Class: net.gsantner.markor.activity.DocumentActivity
         Target: Activity ]

    Task: Commit Blog
    
    A1: Input Dialog [
         Title: Commit Blog
         Text: Enter commit message
         Close After (Seconds): 30 ]
    
    A2: Termux [
         Configuration: commit_blog "%input"
         
         Working Directory ✕
         Stdin ✕
         Custom Log Level null
         Terminal Session ✕
         Wait For Result ✓
         Timeout (Seconds): 10
         Structure Output (JSON, etc): On ]

“New Post” queries a post title from the user, calls new_post with that and then opens the new post in Markor.

“Commit Blog” queries a commit message from the user and calls commit_blog with that.

I created desktop shortcuts for these too and placed all of them, together with Markor, Termux and a browser shortcut, in a new folder “Blog”.

So, my workflow now consists of pulling, creating a new post, editing it, optionally firing up Hugo to check on the whole thing locally, committing and pushing, all at least without needing to touch the terminal, but always able to if so desired.

It’s not perfect, and some app that takes care of all of this from a nice UI would certainly be better (hint hint). But - as this post created entirely from my phone proves - it works for now 😁

However, once that was done, I realized that while I had learned a lot about React and next.js in the process, I had not really created something that is fun to use, which reflected in my reluctance to actually use it. Writing the post about my custom SteamDeck buttons, yesterday really drove that point home again, and in fact kinda broke the camel’s back for good 😅

So I decided to do what I’d been meaning to do for a long time and finally took a look at Hugo, which I had seen used a lot by others for their blogs over the past years, and also its PaperMod theme that I had seen on Jürgen Gmach’s website (👋).

Color me extremely surprised when I had my page rebuilt within a couple of hours, with all the features I wanted and more, and a way nicer experience for me as the content creator. I didn’t even have to touch my posts that much, mostly some small changes on the frontmatter and boom, done.

So I went down the rabbit hole further, fine tuned some things, customized some others, and now I’m really happy with the result.

And thus, please say hello to a new version of foosel.net, now powered by Hugo and PaperMod.