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.

Example: https://foosel.net becomes view-source:https://foosel.net.

I’ve always been a bookworm. As a child, my favourite past time was reading. I usually dragged my current book with me everywhere and would read at any opportunity¹. So, when e-readers became a thing, I was very excited to save on a ton of shelf space in the future and got myself an Amazon Kindle at the first chance I got. Back then in 2010 I actually had to import my Kindle 3 Keyboard from the US since it wasn’t available in Germany yet. And since then I’ve gone through a couple of e-readers, all of them Kindles. But all the time I was a bit annoyed at two things:

1. Vendor lock-in. Yes, you can send books from other sources than Amazon itself to your Kindle, can convert PDF and EPUB and whatnot, but in my experience it was always a bit of a hassle and especially in the case of PDFs a mess. Even with Calibre in my toolbelt I didn’t feel all too happy and most of the books I got through Humble Bundle and the like - which tend to be EPUB or PDF - stayed unread in my collection while I kept throwing money at Amazon.
2. Black and white only. That’s still an issue with pretty much all e-readers out there, as color displays are only now slowly becoming a thing. But the lack of color means that things that very much profit from color, like coding related books (syntax highlighting), comics, RPG source books, etc. so far were something I had to read on my phone or tablet.

Then I came across Scott Hanselman’s post “The quiet rise of E Ink Tablets and Infinite Paper Note Takers - reMarkable 2 vs Onyx Boox Note Air “ back in June of 2021, and immediately was intrigued. I had heard of the Remarkable 2 before, but decided against it due to yet another case of vendor lock-in. But through Scott’s post I learned about Onyx’ e-reader line-up. The fact that they run Android, have Google Play store integration and you can just install your own stuff on them out of the box was very much intriguing, and the Wacom digitizer was an additional point for that model range². And after perusing the Onyx website for a while, I decided to pull the trigger on a Nova 3 Color - the color e-ink intrigued me and the 7.8” size was right on the sweet spot. I ordered it on June 14th 2021 directly from the Boox EU store, and it arrived on June 16th³. All in all I paid 399€ for a bundle of the e-reader itself, a case, some screen protectors (that I don’t use) and of course a stylus. Not too shabby.

So now, 1.5 years later, how do I like it? Let’s find out!

Visuals

To just address the elephant in the room right away: How does the color screen perform? Well, it’s obviously not something you can compare to a tablet OLED. The colors are way more muted and the contrast is not as high. If you’ve ever seen a comic printed on newspaper paper, that’s pretty much the same kind of color reproduction you can expect here. But for what I got it for, it’s absolutely fine.

Syntax highlighting in code snippets is now visible beyond grayscale, and for comics and similar it also works. Given, if I want to really enjoy the colors, I’m still getting a hold of my tablet, but for the use case of actually reading long form books with the occasional code snippet, illustration, map or even short comic strip, it’s absolutely fine. And for highlighting text, it’s also a great feature to have.

To give you an idea here are a couple of pictures of the screen, each with a shot of how the same thing looks like on a regular screen added to the right⁴. First we have a code snippet in the PDF version of “Fluent Python 2nd edition”:

Then a page from the “Attack on Titan Anthology”:

The third one is a page from the “Tales from the Loop” RPG source book:

And the final one shows a page from the rules PDF of the boardgame “Nemesis”:

So, if you expect vibrant colors like on OLED from a color e-ink, I have to disappoint you. At least with the current technology we aren’t there yet. But it does add a needed touch of color to books like the above examples that I sorely missed before, and I think I wouldn’t want to go back to a black-and-white only e-ink display at this point anymore.

Now, what makes the display a bit more hit and miss when it comes to things like the shown boardgame rules is its size. If this was a 10” screen, the rules PDF would be far easier on the eyes. As things are, the pixels wash a bit into each other. But truth be told, that particular PDF is something that even on my 10" tablet I only view zoomed in, and I have some other examples like this - mostly A4 sized RPG books - that simply become too small on the 7.8" display here.

When reading e-reader optimized formats like EPUB or MOBI, or in the Amazon Kindle app, and also with PDFs that are more suited for the form factor, the text is great to read. No eye strain, no blurry text. There is however always a bit of a grainy texture to the screen, and that is due to the lower resolution color layer that’s on top of the grayscale one. It’s not something I notice while reading however. Overall, I’m totally happy with the text quality!

Update: Mihir Joshi asked me on Mastodon how fast screen refreshes perform on the Nova, and I made a quick video to demonstrate:

Imho, the performance is on par with a classic e-ink reader, it certainly doesn’t feel slower than my Kindle did.

Touch & feel

So, we’ve covered how it looks, but how does it feel?

The reader’s shell is all plastic, but it feels solid. No sharp edges, all just nice to the touch. It certainly feels cheaper than my tablet or phone, but honestly about the same as my various Kindles. The case that came with it snaps to it and has a magnetic cover, and the reader wakes up when I open it - just like I’m used to from my Kindles and the tablet. The stylus fits into a small loop on the cover flap; it feels a bit on the cheap side, but it works just fine and is pressure sentitive as expected.

The reader only has two hardware buttons, a power button on the top edge and a button centered beneath the display that acts as back button and backlight toggle (on long press). Everything else is done through configurable gestures and a little hover menu. The top edge has two drag zones, left opens the Android notification area, right the reader’s quick settings menu.

The left and right side can be configured as touch sliders, and I’ve set mine to have brightness control on the left and nothing on the right.

The bottom edge supports three zones for dragging upwards from as gestures, and I had them mapped to the standard Android buttons back, home, recent.

However, while writing this post and verifying some things, I noticed the latest firmware update added an optional dedicated navigation bar at the bottom, so I’m going to test this out now for a while 😁

What about page turning? Well, there’s nothing predefined here - it’s app specific. But I’ve found that everything I’ve thrown at it in terms of reader software either supported “tap to turn” out of the box, or could be configured this way. You probably won’t get happy with an app that demands “drag to turn” - with the refresh rate of an e-ink screen that is just too laggy.

Software

The fact that the Nova 3 Color runs Android is a huge plus for me. I’ve been using Android for years now (funnily enough as long as I’ve been an e-reader owner: 2010), and therefore I felt right at home when it came to customizing my Nova.

Now, the first thing I actually installed after enabling the Play Store was NetGuard. I had read online that Onyx devices tend to phone home to China a lot, and that is not something I like very much. So, I threw NetGuard on there, denied everything by default, and from then on only allowed the additional stuff I put on there through to the internet (and occasionally the whole device when I let it check for updates). Rooting it would probably have been even better, but frankly after some network traffic sniffing it looked like NetGuard was enough.

The second thing I installed was the official Kindle app, as that is where I have most of my fiction and also the one or other non fiction books. It’s probably what I’ve used the most on the device, and it works great. Until a recent update it sometimes crashed and I had to restart it (sometimes twice or thrice before it worked) and scroll to the last page I was on, but with the last OS update I installed, 2022-11-24, this has so far not happened again. In any case it wasn’t something that happened on a daily basis, more like once or twice per month, and while definitely annoying never became bad enough to make me start debugging this.

The third app was ReadEra Premium. I tested many PDF/EPUB readers throughout the years, and currently that is the one that works best for me. On top of PDF and EPUB it also supports CBR/CBZ, which is commonly used for comics, and a whole bunch of other formats. On the Nova, I had to fiddle around a bit with the settings to enable page switch by tap, optimize the display and such, but I sadly cannot remember what exactly I did. In any case, it works well with almost anything I throw at it now (large format PDFs being hit and miss).

I have my book collection stored in my Google Drive, and so I installed DriveSync to be able to keep it in sync with that and mirrored on the device. So far, every time that I’ve opened up the Nova to check out a new book I had just pushed into Drive earlier, it was usually already there, so that’s a nice workflow.

In theory there’s also a full featured e-reader app integrated and I briefly played around with it, but I was already used to ReadEra from my tablet and so stuck with it.

So far, pretty much everything that I threw at it worked, albeit with some visual glitches here and there (most apps really don’t expect to be run on an e-ink display).

There are also a bunch of stock apps installed on the reader, apart from stock options for e-reading and note taking that have their own buttons in the navbar on the left.

Everything else is just pretty much the usual suspects, with two exceptions. The navball app that allows you to configure the menu behind the little button always hovering on your display (I have things in there like taking a screenshot, triggering a manual refresh and similar), and the screensaver app that allows you to configure the cover displayed whole the reader is sleeping. I’ve put a little fake book cover on there that always makes me laugh 😅

But apart from these two, the only stock app I actually did use for a while was the app for note taking.

Note taking

The original idea when I got this device to use it as both my e-reader and my notebook. And that’s what I tried for the first week or so. But there were two reasons why I stopped doing that and went back to first paper and now my tablet again.

One was that I could only use the stock app for note taking. While every other app did in fact get the stylus input, anything but the (probably heavily optimized) stock note taking app lagged severely, to the point of being not only frustrating but actually impossible to use. And I didn’t find any way to sync my notes with any standardized format without Onyx’ own cloud (and I’m unclear what would have been possible there) - I simply don’t want to require yet another account on someone else’s server farm for that, I have enough of these already. Also, the app felt very basic functionality wise.

The other issue was the display size - perfect for reading, definitely too small for my handwriting in combination with a Wacom digitiser. I had thought that it would be fine for me since I also used to be quite happy with A5 sized Moleskine notebooks, but I seem to write slightly bigger with a stylus than with the Uniball Signo 307 that is my usual go to pen, and so closer to A4 like 10" as found on my tablet definitely works way better.

So, I guess if note taking is your goal, go with something bigger than the Nova.

Conclusion

Would I buy it again? Yes, as an e-reader, but not as a note taking device.

For reading, it has the right size, with even most PDFs working just fine. The color display adds just the right dusting of color to make some things previously quite annoying to read on grayscale e-ink fine, and having it run stock unlocked Android means I can use whatever app I want to do the reading in. It has fully replaced the Kindle Paperwhite I used before - I frankly don’t even know where that is at the moment 😅 - and I’ve read many a book on it now.

For note taking however I found 7.8" to be just too small to be useful. And the fact that only the stock app works well and doesn’t seem to have some well supported way to get the notes out of it makes it a bit of a suboptimal experience as well.

If note taking was my focus, I’d look at something larger, 10", and pay close attention to the sync options of the notebooks. Something like OCR enabled PDFs synced into the file system would already be nice (then DriveSync or Syncthing could take care of the rest). From what I’ve read online however, something like that doesn’t seem to really be available yet.

For either though I think I’ll really want color 🌈 from now on 😁

echo $PREFIX | grep -o "com.termux"

This can also be used to set a variable in a Taskfile:

vars:
  TERMUX: '{{and .PREFIX (contains "com.termux" .PREFIX)}}'

Source

• Action: android.intent.action.SEND
• Cat: None
• Mime Type: text/plain
• Data: content://net.dinglisch.android.taskerm.fileprovider/external_files/path/to/the/file (be sure to replace /path/to/the/file with the absolute path to the file you want to open)
• Package: net.gsantner.markor
• Class: net.gsantner.markor.activity.DocumentActivity

Source

Update from 2026-06-19: I went through these steps again after getting a new phone and had to change some things here and there while also improving other bits. You can find an update here.

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 😁