Sorry KDE,
"Nothing by default, just there when needed."

Which I know is not a perfect system because sometimes things get lost. And I have to search them which isn't very efficient. Since I have started from the drawbacks and pain points lets just continue with it.

1. Things get lost sometimes.
2. Moving the mouse can cause different panes to open.
3. There are only limited places to hide things.
4. Sometimes you just wish you could see things without having to do anything.

Now that we've got that out of the way, lets start with everything that I have set up:

So, by now you might have already realized what the theme for today is. Yes!, it's Extreme Minimalism.

Let's start from the bottom up:

Pre-Desktop

BIOS

Fortunately my BIOS boot animation is very pretty, and I love that the logo of my vendor also somewhat resembles Arch Linux. It's the new ASUS Zenbook Logo, which is located at /sys/firmware/acpi/bgrt/image on my system.

If you know how to extract the actual animation from the BIOS please tell me how, I want to make it into a plymouth boot animation.

This is the end result image after the BIOS animation completes and before it hands over control to the Bootloader.

Bootloader

I use systemd-boot which itself is super minimal. But, I have configured it to be invisible by setting the timeout to be 0.

It can be done by editing /boot/loader/loader.conf and setting timeout 0. Here comes the philosophy of keeping things hidden while still accessible. Because, holding shift while the system boots will let me see the Bootloader Entries if it is necessary.

I normally keep two kernels in case one breaks. Above image is only for reference to show how minimal the UI of systemd-boot is.

initramfs

Since I use the systemd ecosystem including the bootloader and init system. I have used mkinitcpio to build a systemd dependent initramfs. Hence I use the the Hook List table to set up mkinitcpio.

I also add plymouth to the hook in /etc/mkinitcpio.conf:

HOOKS=(base systemd autodetect microcode modconf kms keyboard sd-vconsole block filesystems fsck plymouth)

Unified Kernel Image (UKI)

The default Arch Linux UKI has it's own splash image. And I don't like different things flashing when the system boots. So, I change the splash image of the Arch Linux UKI my BIOS image mentioned above. For that I edit /etc/mkinitcpio.d/linux.preset to have:

default_options="--splash /sys/firmware/acpi/bgrt/image"

Kernel cmdline

In order to supress the messages in the boot process I put the following arguments to /etc/kernel/cmdline:

loglevel=3 quiet splash

The log level and quiet arguments supress the messages while the splash enables the splash screen which will come into play when plymouth is installed.

Plymouth

It is a system that uses Kernel Mode Setting (KMS) to set the native resolution of the display as early as possible, then provides a splash screen leading all the way up to the login manager.

After installing plymouth through pacman, the default splash screen it uses is BGRT which stands for Boot Graphics Resource Table which also utilizes the spinner theme to put a spinner on the bottom of the splash screen.

The spinner theme the Arch Linux logo which I don't want there. So, I delete it from /usr/share/plymouth/themes/spinner/ and delete all animation and throbber images too just to make everything clean. The Arch Linux and spinners will be gone on the next boot.

But, my device boots really fast, so after the kernel splash screen, there is a blank screen for a second then plymouth launches which lasts for not even a second. This causes me to see only a flicker of plymouth. So I have delayed the launch of it by 15 seconds.

In /etc/plymouth/plymouthd.conf:

[Daemon]
ShowDelay=15

Well, you might ask why delay plymouth instead of just uninstalling the it entirely. It is because plymouth also appears during poweroff and reboot while the system is shutting down, which I want to have.

GDM

I use Niri as my window manger of choice. But, have a fallback GNOME session since niri plays well with GNOME's set of utilities.

The default Arch Linux GDM has the Arch Linux logo there which I remove using the GDM Settings application. There might be a way to remove it via the command line but I am lazy and I just delete the application once I change this setting and it remains persistent. Tell me if you know the way. ;)

edit: 2026-05-03: start

greetd

I switched from GDM to greetd to have the same style on the login manager which I have for the lock screen. Which also meant sacrificing the lock screen of the GNOME session and using something new that I know nothing about. I starting tracking the setup for greetd in a markdown file.

For the greeter I use niri as it's compositor and quickshell for the UI.

The immediate issue was, the GNOME Keyring not being unlocked by default. Which was easily fixed by editing /etc/pam.d/greetd with the following PAM(Pluggable Authentication Modules) setup:

#%PAM-1.0

auth       required     pam_securetty.so
auth       requisite    pam_nologin.so
auth       include      system-local-login
auth       optional     pam_gnome_keyring.so
account    include      system-local-login
session    include      system-local-login
session    optional     pam_gnome_keyring.so auto_start

Using greetd meant living with the logs when going from greeter to compositor. So, I went down a rabbit hole. I tried disabling systemd logs for user, for system, for greeter user and what not. I used google, duckduckgo, chatgpt, gemini, heck even grok to find a solution, but nothing helped.

Then, I found out about a side effect of the framebuffer console boot options from the Linux Kernel Documentation saying, "One side effect that may be useful is using a map value that exceeds the number of loaded fb drivers. For example, if only one driver is available, fb0, adding fbcon=map:1 tells fbcon not to take over the console."

So, I appended fbcon=map:1 to /etc/kernel/cmdline.

This completely disabled the console, which meant no text will be printed during switch from greeter to the compositor. But, this also meant that there is now no way to go to ttyX if I had to debug the system in case it breaks. And since it's Arch Linux, noone can guarantee that it would not.

I then went down on another rabbit hole trying to enable the other framebuffers from userspace command line after system fully booted. Which I couldn't solve.

Looking for other console options, I found kmscon, and out of sheer curosity I installed it and rebooted the system. And I can't state the joy I felt when I tried to switch to tty2 and it dropped me into a console. I also found out that it supported fonts and can use pango which I loved and immediately switched to a Nerd Font. I also themed it with the same colors that I theme my Terminal Emulator.

It was as easy as sudo pacman -s kmscon then reboot. By, default only tty2 with ctrl+alt+f2 works, but other sessions can be enabled with systemd too.

So, there it is, another minimal component, greetd added to the my system replacing GNOME's GDM. With the pretty-pretty kmscon, which is my love at first sight.

edit: 2026-05-03: end

Poweroff and Reboot

I hate the annoying systemd wall messages when shutting down or rebooting the system:

Broadcast message from user@host (Thu 1970-01-01 00:00:00 UTC):

The system will power off now!

So I use this one liner from Kira-NT/disable-systemd-wall-messages to disable the wall messages:

curl -Ls https://github.com/Kira-NT/disable-systemd-wall-messages/blob/HEAD/install.sh?raw=true | sudo sh -s

And for the times I use terminal to reboot or power off I put the following shell alias for them:

alias reboot="reboot --no-wall"
alias poweroff="poweroff --no-wall"

Desktop

All that for the 10 to 20 seconds it takes to get from hitting the power button into my desktop.

But, now we are finally at the desktop.

Niri

As I have already mentioned, I use Niri as my desktop of choice. Lets start from then start then!

Wallpaper

awww is what I use to set the wallpaper since it has the ability to set wallpapers to different layers in niri. I start the daemon as follows:

awww-daemon -n wp-front &
awww-daemon -n wp-back &

The wp-front is the namespace for actual layer where niri's wallpaper will be set. The wp-back is the namespace for the layer behind the desktop where niri's overview backdrop will be set.

I set my wallpaper on wp-front and a blurred version of the same wallpaper on wp-back to get the above results. With the following setting on the niri config:

layer-rule {
    match namespace="wp-back"
    place-within-backdrop true
}

and the command to set:

awww img "$BLURRED_WALLPAPER" -n wp-back &
awww img "$SELECTED_WALLPAPER" -n wp-front &

Launcher

In the past I used to use very minimal and customizable launchers like rofi, wofi and tofi but after watching enough number of ads for the Raycast launcher, I fell in love with vicinae.

It just works! The only thing I changed was the fonts to be FantasqueSansM Nerd Font Propo, the Icon theme to Morewaita and enabled blur.

The Shell

I decided to write this blog post because of this shell. It gives me joy with a mix of pain and impostor syndrome to call it mine. I wrote it using AI in quickshell. One one hand, It'd had taken me weeks to completely write all this myself, but I did it in a single day, and it isn't system critical so I guess I get a pass for not doing it myself.

Lockscreen: I decided to recreate the swaylock-effects lockscreen with a blurred screen setup using quickshell.

I want to make the same UI for greetd and use it for the Display Manager too but, I am afraid GNOME will not like it when I use something other than GDM. [ I did it! ]

OSD: For OSD, I took design inspiration from the IOS dynamic island and decided to create an interactive bottom notch.

Bar: For the Bar, I took inspiration from the OSD and made it top notch.

Notifications: Similar to OSD and Bars I made the notifications with a corner swoop.

As a whole it looks like this:

Sorry for the flashbang.

Almost everything in the shell is quickshell now, which replaced various applications like:

• way-edges for bar
• swayosd for brightness and volume OSD
• battery-osd for battery notifications and OSD
• swaylock for lock screen
• swaync for notifications

This is Fun

Funny how describing the setup of the 10 second boot process took more words than describing the desktop. But, if we consider "A picture is worth a thousand words." the desktop wins by a long shot!

If you see some lag, it's because of the screen record. I have applied this "Nothing by default, just there when needed." philosophy everywhere from bootloader to shell (desktop),browser, editor and individual applications if possible. This is how I like it. Tell me if you like it.

Also please give me recommendations if you have any.

See you on the next one!

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

When we were searching for a project to do for our final year submission, I came across a feature request on RedoxOS asking for OverlayFS support. I had kept it as something "I wish I could do". When pitching our ideas for the project, I also said that I wish we could do something like this, to my teammate faultypointer. Since, he was interested in working on low level too while the whole world was doing AI projects we decided that we would do it. Afterall, when we take on the project we must complete it anyhow, otherwise we risk getting the degree.

And, so it began. We proposed the idea to the faculty and they accepted, but they said that it must be a completely original work, without using any existing code written by RedoxOS contributors. We then started the research on how the OS was architectured and how we could implement something like OverlayFS.

Note

Overlay filesystems are pseudo-filesystems which combines multiple filesystems or multiple directories from same filesystems into one, resulting in a single directory structure that contains underlying files and sub-directories from all sources.

High Level representation of OverlayFS

The First Contact

When we contacted the people making RedoxOS on their matrix server, we found out that someone had started the preliminary work for OverlayFS. We then contacted him and said that we wanted to help make the thing. He was positive about it and said that though he couldn't mentor us for it, he would leave some notes for us to better kickstart the project. We took the notes and started the preliminary work on the alien codebase of RedoxOS.

The Struggle Begins

It was a completely new territory for us. Though we had some theoretical knowledge on Operating System and their Architecture from our syllabus, our practical experience for OS development was closer to none. Reading the RedoxOS Book was fun though, I got to learn about the various components of RedoxOS and what their philosophy was. Though I read about RedoxOS in detail, I hadn't made up my mind on where I would start developing the OverlayFS.

First few months, taking about the project and having in my mind that it's a low level project I wanted to do was like a dream. I was excited and so was faultypointer. We talked about the architecture and discussed the plans and theory of how OverlayFS worked, we gathered resources and references. Those were exciting days.

The Build System

It had been very long since we have just studied the theory and we hadn't implemented anything. Until that time we managed to understand the build pipeline and how the source code of RedoxOS was structured. We were using NixOS at the time so, we had to jump to a more normal Linux distribution to make out life easier to work with building RedoxOS. I don't even know how many times we built RedoxOS from scratch deleting containers and reinstalling them again and again and again.

Another thing we realized while building RedoxOS is that it wasn't self-hosted yet. Meaning, you couldn't build programs for RedoxOS from inside RedoxOS. We knew from James Matlik's Implementation Proposal that we had to make a delegate pattern in order to make it on Linux and then integrate it with RedoxOS. I wasn't familier to delegate patterns so, I was still learning about it.

The Initial Implementation

While I was busy wasting time asking AI to guide me to start the project, faultypointer had already written the preliminary filesystem struct and made the delegate struct to prototype it on Linux. While I hadn't done much, I was much relieved that actual work on the project was finally started. Finally we (by we mean just faultypointer) had started work on the project.

In the first implementation, a delegate FileSystem struct was written that would do the things the overlay scheme would do in the future. What it contained was:

• Functions for open, read, write, close, unlink, readdir.
• Helper functions for copying up files from lower to upper layer, checking for whiteout files and creating whiteout files.
• Some tests for those functions to verify that they were working as expected.

Scheming with SchemeMut then SchemeSync

After the SchemeMut for OverlayFS was implemented and the main scheme function was implemented we could test the workings of initial syscall implementations on RedoxOS as well as on Linux. But, SchemeMut was not what the RedoxOS team was using for other schemes. Later, the SchemeMut implementation was replaced with SchemeSync which finally brought the project to a fairly usable state.

The Great Big Purge

After the verification that the implementation worked in practice, the initial structure of source code wasn't fit for a more involved implementation. The structure was reimplemented using rust's struct and impl syntax. All that was left was to implement each individual filesystem syscall that the scheme required to work with the OverlayFS implementation logic.

Starting to write syscalls, the rust libraries soon didn't cut it. Then libc had to be used.open was implemented. The most visual part of the whole project was done by the getdents syscall, which listed the directory entries that showed the logical merged/overlay layer of the OverlayFS, hence, that had to be implemented next.

Important

Due to RedoxOS being a microkernel based Operating System, it's own filesystem and our OverlayFS was outside the kernel space. The architecture of the OverlayFS can be visualized as follows:

Architecture of the filesystem within RedoxOS

System Calls

After everything was set up, all that remained was implementing more and more syscalls untill each one was implemented. The implemented syscalls in order are as follows:

1. open - Resolves path checking upper then lower layer, respects whiteouts, and forwards UID/GID for permission checks.
2. getdents - Merges directory entries from upper then lower layer, excluding shadowed names and honoring opaque directories; maintains opaque offsets.
3. read - Reads from whichever layer the file was resolved from at open time.
4. write - Performs copy-on-write: copies lower-layer file to upper layer on first write, then writes to the upper copy.
5. fpath - Retrieves the path for a file descriptor via the scheme interface.
6. unlink - Removes upper-layer files directly; for lower-layer files creates a whiteout in the upper layer.
7. rmdir - Validates directory emptiness and removes directories, creating upper-layer markers if the directory originated from lower layer.
8. fchown - Triggers copy-up for lower-layer files, then applies ownership change to the upper-layer copy.
9. fchmod - Triggers copy-up for lower-layer files, then applies permission change to the upper-layer copy.
10. fsize - Returns size metadata from the layer where the file resides (upper or lower).
11. fcntl - Manipulates file descriptor flags through the scheme interface.
12. fvent - Registers events for asynchronous I/O through the scheme interface.
13. flink - Creates hard links only within the upper layer; linking to a lower-layer file triggers copy-up first.
14. ftruncate - Performs copy-on-write if needed, then truncates the upper-layer copy.
15. statvfs - Aggregates filesystem statistics across both layers to report combined capacity and inode usage.
16. futimens - Performs copy-on-write if needed, then updates timestamps on the upper-layer copy.
17. dup - Duplicates file descriptors, preserving the resolved-layer behavior of the underlying handle.

Proof that Syscalls for OverlayFS Work(ed).

Change is Inevitable

Since RedoxOS is a very unstable operating system, which is heavily in development, during the development of the OverlayFS we repeatedly rewrote parts to keep up with upstream changes. Near the project submission a fresh pull from RedoxOS introduced mismatches with our overlay code: path handling and validation required fixes, some Scheme APIs (SchemeSync and related types) had their methods changed so we needed to implement new functions. Also, the way Scheme was started changed (we later found root-start resembled our old approach, but the new init-system startup only allowed a single overlay instance). During this we also came across a runtime freeze where a std library function appeared to hang with no error or panic which was unlikely in upstream CI, so we suspected a deadlock in our code.

So, we decided to limit the implementation on the older commit and settled to showing what already worked on our system in our final project demonstration. This means we won't able to contribute the implementation upstream, and to be very honest we are very insecure (almost unsatisfied) about our current implementation which is one more excuse for us to procrastinate now that the defence is over.

Mentors and Developers

Though everything I contributed to the project was mentored to me by faultypointer, he didn't have anyone who mentored him. I admire faultypointer for his dedication to the craft and his knowledge and flexibility to understand and work on an alien codebase. I don't even know if I had taken up the project and faultypointer wasn't on our team that we could even make an implementation of OverlayFS that actually worked.

Near the final defence I saw exhaustion and burnout on faulty's face that I had never seen before, I wasn't knowledged/skilled enough to help him either. That moment was the time I (maybe we both) realized the importance of mentor and mentorship. After all we are just students learning in this field.

Though I admire low level developers and I try to dabble on it, but, I also like visuals and graphics and something that looks presentable. The amount of work that faultypointer has put on this project compared to me is stellar, and of that work the final result being something so simple that can be explained in 3 sentences is very underwhelming (one might say anticlimactic). This project has immensely increased my respect towards the low-level developers and most importantly faultypointer (Sudesh).

End of an Era

This being a final year project of my bachelor degree also makes me very sentimental about it. Hopefully, we keep in touch even after we part ways to our respective future.

Love you brother! I'll find you from under the ocean and over the sky if you don't keep in touch. This is very much a warning as it is a request.

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

Why?

I am constantly in a quest of making things better for the sake of reducing my media addiction. The only social media with "status updates" that I use is polymaths.social a gotosocial(Fediverse) instance. I have stopped using Facebook and Instagram a while back and I block the shorts section of my YouTube.

Having done that, the addiction has shifted from a whole range of social media to just watching YouTube videos till the end of time. So, I decided to make YouTube only show what I search with no home page or even the subscription page. (Though, I can still access them with a toggle.) I also don't want to consume YouTube on my phone. And I want to read books instead of consuming visual media.

So?

For a while now my YouTube recommendations were full of e-readers, dumb phones and modding kindles. I did like the idea and checked the price of those devices (Classic Consumerism). Since, they are manufactured in small quantities, they are very expensive for the specs they offer. And most of them are not available in my region. But, my stubbornness, or maybe my addiction is so bad that I need to have what I want and if I don't I just can't do any other work properly.

Then I thought, I cannot convert something dumb to something advanced by itself but the reverse is possible. I remembered a device called BOOX Palma and since it is an android device I thought I could recreate it with my own phone that I already have. From the kindle modding video I also realised that KOReader is not just an old, weirdly made e-book reader app.

So, I decided to base the entire personality of my phone to the KOReader app.

Preparing Android

Since I use a custom ROM it is much easier for me to customize my device to a greater potential than vanilla android that google offers. I use Project Infinity X.

1. I wanted the B&W monochromatic look of e-readers, so, the first thing I did is set a white background as my wallpaper.
2. The Monet color is set to be monochromatic.
3. In Accessibility > Color and motion > Use color correction > Grayscale is turned on. (I just disable this via a quick setting toggle when I need colours.)
4. In Accessibility > Color and motion > Remove animations is turned on.
5. In Display > Color > Night Light is turned on.
6. Dark Theme is disabled.
7. Display > Display cutout is set to notchbarkiller. (This setting is generally in Developer Options if not in Display but, the exact name: notchbarkiller may not be present.)
8. Additionally, a Reading Mode can be made with the features like: disabling notifications and setting the screen as greyscale. But, I wanted to control those settings individually.

Installing the Launcher

1. I decided to install InkOS as my launcher because it adds on to the e-reader aesthetic.
2. I removed all the shortcuts of the home screen and set Books as the only shortcut there.
3. From the app drawer I changed the name of the apps to their generic names and hid most of the unused apps.
4. Configured swipe left gesture to KOReader and swipe right to App Drawer.
5. Finally I set InkOs as my default launcher.

Setting Up KOReader

1. Installed KOReader from GitHub and set it to Start with: last file.
2. Disabled Cover Browser Plugin and installed Project: Title.

In KOReader individual books have their individual settings but once everything is set up, scaled and aligned properly for the book that you want to read, only reading it will be the remaining task.

Final Touches

The phone is normally is in DND mode, but when it is not, I have disabled the notifications of almost every app except signal. I have installed uBlock Origin on firefox and have hidden different UI elements that I don't want to see e.g. YouTube Shorts. The quick settings panel is now cleared and only the very essential settings like WIFI, modes and colour correction toggles are there.

All in all, I have made reading books the easiest task on the phone and added friction to everything else by locking the apps so I have some time to realise what I actually want to do.

I aim to read more books with this setup. Wish me luck!

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

The idea of remapping keys isn't new, be it for typing in a different language or to make the escape key more ergonomic for vim users. I mapped my escape key to ` and caps-lock key to escape when I bought my 65% keyboard. It was because I had to use some weird function keybind just to type a ~. Then I realised my laptop key got remapped too, but I just went ahead with it. That is when I used this software called keyd.

Fast forward to today and rewind to a month back, I was bored out of my mind and was fidgeting with my keyboard when I popped one of the keys out of it. And right then I looked at the keys and wondered if I could make a minimal split keyboard out of it using keyd.

I had watched many videos about split keyboards, and one was even in my wishlist for a long time. So, I wondered if I was gonna invest in a keyboard that is going to shape my typing muscle memory, I should at least give it a try beforehand.

Now that I started writing about it, I don't think it was that big a deal. It only took too much of my time to configure it. First I tried the ferris sweep layout which was too much of a sacrifice, then I tried corne and finally decided on the 5 column corne.

Before Operation:

After Operation:

# corne-36.conf

# keyboard id to enable [wired, bluetooth and 2.4ghz]
[ids]
5566:0008
3151:6001
1235:aa22

[main]

# LEFT HAND
# ROW 1
# Press "q" to write q
1 = q
# Press "w" to write w
2 = w  
# Press "e" to write e
3 = e
# Press "r" to write r
4 = r
# Press "t" to write t
5 = t

# ------------------------------------------ #

# LEFT HAND
# ROW 2
# Press "a" to write a
q = a
# Press "s" to write s
w = s
# Press "d" to write d
e = d
# Press "f" to write f
r = f
# Press "g" to write g
t = g

# ------------------------------------------ #

# LEFT HAND
# ROW 3
# Press "z" to write z
a = z
# Press "x" to write x
s = x
# Press "c" to write c
d = c
# Press "v" to write v
f = v
# Press "b" to write b
g = b

# ------------------------------------------ #

# LEFT HAND
# BOTTOM ROW - Special keys
# Press "down-arrow" for leftmeta, hold "down-arrow" for meta
x = overload(meta, leftmeta)
# Press "alt" for space, hold "alt" for navigation
c = overload(navigation, space)
# Press "up-arrow" for esc, hold "up-arrow" for control
v = overload(control, esc)

# ------------------------------------------ #
# ------------------------------------------ #
# ------------------------------------------ #

# RIGHT HAND
# ROW 1
# Press "y" to write y
8 = y
# Press "u" to write u
9 = u
# Press "i" to write i
0 = i
# Press "o" to write o
minus = o
# Press "p" to write p
equal = p

# ------------------------------------------ #

# RIGHT HAND
# ROW 2
# Press "h" to write h
u = h
# Press "j" to write j
i = j
# Press "k" to write k
o = k
# Press "l" to write l
p = l
# Press ";" to write semicolon
leftbrace = semicolon

# ------------------------------------------ #

# RIGHT HAND
# ROW 3
# Press "n" to write n
j = n
# Press "m" to write m
k = m
# Press "," to write comma
l = comma
# Press "." to write dot, hold "." for control
semicolon = dot
# Press "/" to write slash
apostrophe = slash

# ------------------------------------------ #

# RIGHT HAND
# BOTTOM ROW - Special keys
# Press "->" for enter, hold "->" for alt
m = overload(alt, enter)
# Press "del" for backspace, hold "del" for symbols
comma = overload(symbols, backspace)
# Press "<-" for tab, hold "<-" for shift
dot = overload(shift, tab)


# ------------------------------------------ #

# ALL UNUSED KEYS FROM THE KEYBOARD
tab = noop
capslock = noop
backspace = noop
backslash = noop
rightbrace = noop
esc = noop
enter = noop
6 = noop
7 = noop
y = noop
leftshift = noop
z = noop
b = noop
h = noop
slash = noop
rightshift = noop
leftcontrol = noop
leftalt = noop
space = noop
rightalt = noop
rightcontrol = noop
leftmeta = noop
rightmeta = noop
grave = noop
f1 = noop
f2 = noop
f3 = noop
f4 = noop
f5 = noop
f6 = noop
f7 = noop
f8 = noop
f9 = noop
f10 = noop
f11 = noop
f12 = noop
up = noop
down = noop  
left = noop
right = noop
home = noop
end = noop
pageup = noop
pagedown = noop
insert = noop
delete = noop
kp0 = noop
kp1 = noop
kp2 = noop
kp3 = noop
kp4 = noop
kp5 = noop
kp6 = noop
kp7 = noop
kp8 = noop
kp9 = noop
kpdot = noop
kpenter = noop
kpplus = noop
kpminus = noop
kpasterisk = noop
kpslash = noop

# ------------------------------------------ #
# ------------------------------------------ #
# ------------------------------------------ #

#  [ 1:q ] [ 2:w ] [ 3:e ] [ 4:r ] [ 5:t ]                    [ 8:y ] [ 9:u ] [ 0:i ] [ -:o ] [ =:p ]
#   [ q:a ] [ w:s ] [ e:d ] [ r:f ] [ t:g ]              	[ i:h ] [ o:j ] [ p:k ] [ [:l ] [ ]:; ]
#    [ a:z ] [ s:x ] [ d:c ] [ f:v ] [ g:b ]          	     [ j:n ] [ k:m ] [ l:, ] [ ;:. ] [ ':/ ]
#          [ x:meta ] [ c:nav/space ] [ v:ctrl/esc ]    	[ m:alt/return ] [ ,:sym/backspace ] [ .:shift/tab ]

# ------------------------------------------ #
# ------------------------------------------ #
# ------------------------------------------ #

[symbols]

# LEFT HAND
# ROW 1
# Hold "del" and press "q" for "!"
1 = S-1
# Hold "del" and press "w" for "@"
2 = S-2
# Hold "del" and press "e" for "#"
3 = S-3
# Hold "del" and press "r" for "$"
4 = S-4
# Hold "del" and press "t" for "%"
5 = S-5

# ------------------------------------------ #

# LEFT HAND
# ROW 2
# Hold "del" and press "a" for "1"
q = 1
# Hold "del" and press "s" for "2"
w = 2
# Hold "del" and press "d" for "3"
e = 3
# Hold "del" and press "f" for "4"
r = 4
# Hold "del" and press "g" for "5"
t = 5

# ------------------------------------------ #

# LEFT HAND
# ROW 3
capslock = noop
# Hold "del" and press "z" for "6"
a = 6
# Hold "del" and press "x" for "7"
s = 7
# Hold "del" and press "c" for "8"
d = 8
# Hold "del" and press "v" for "9"
f = 9
# Hold "del" and press "b" for "0"
g = 0


# LEFT HAND
# BOTTOM ROW - Special keys
x = noop
c = backslash
v = '

# ------------------------------------------ #

# RIGHT HAND
# ROW 1
# Hold "del" and press "y" for "^"
8 = S-6
# Hold "del" and press "u" for "&"
9 = S-7
# Hold "del" and press "i" for "*"
0 = S-8
# Hold "del" and press "o" for "("
minus = S-9
# Hold "del" and press "p" for ")"
equal = S-0
# ------------------------------------------ #

# RIGHT HAND
# ROW 2
# Hold "del" and press "h" for "_"
u = minus
# Hold "del" and press "j" for "="
i = equal
# Hold "del" and press "k" for "`"
o = grave
# Hold "del" and press "l" for "["
p = leftbrace
# Hold "del" and press ";" for "]"
leftbrace = rightbrace

# ------------------------------------------ #

# RIGHT HAND
# ROW 3
# Hold "del" and press "n" for "_"
j = S-minus
# Hold "del" and press "m" for "+"
k = S-equal
# Hold "del" and press "," for "~"
l = S-grave
# Hold "del" and press "." for "{"
semicolon = S-leftbrace
# Hold "del" and press "/" for "}"
apostrophe = S-rightbrace

# ------------------------------------------ #

# RIGHT HAND
# BOTTOM ROW - Special keys
m = backspace
comma = noop
dot = rightshift

# ------------------------------------------ #
# ------------------------------------------ #
# ------------------------------------------ #

[navigation]

# LEFT HAND
# ROW 1
# Hold "alt" and press "q" for "f1"
1 = f1
# Hold "alt" and press "w" for "f2"
2 = f2
# Hold "alt" and press "e" for "f3"
3 = f3
# Hold "alt" and press "r" for "f4"
4 = f4
# Hold "alt" and press "t" for "f5"
5 = f5

# ------------------------------------------ #

# LEFT HAND
# ROW 2
# Hold "alt" and press "a" for "f6"
q = f6
# Hold "alt" and press "s" for "f7"
w = f7
# Hold "alt" and press "d" for "f8"
e = f8
# Hold "alt" and press "f" for "f9"
r = f9
# Hold "alt" and press "g" for "f10"
t = f10

# ------------------------------------------ #

# LEFT HAND
# ROW 3
# Hold "alt" and press "z" for "f11"
a = f11
# Hold "alt" and press "x" for "f12"
s = f12
d = noop
f = noop
g = noop

# ------------------------------------------ #

# RIGHT HAND
# ROW 1
8 = noop
# Hold "alt" and press "u" for "tab"
9 = tab
# Hold "alt" and press "i" for "pageup"
0 = pageup
# Hold "alt" and press "o" for "pagedown"
minus = pagedown
# Hold "alt" and press "p" for "print"
equal = print

# ------------------------------------------ #

# RIGHT HAND
# ROW 2
# Hold "alt" and press "h" for "left"
u = left
# Hold "alt" and press "j" for "down"
i = down
# Hold "alt" and press "k" for "up"
o = up
# Hold "alt" and press "l" for "right"
p = right
leftbrace = noop

# ------------------------------------------ #

# RIGHT HAND
# ROW 3
# Hold "alt" and press "n" for "home"
j = home
# Hold "alt" and press "m" for "end"
k = end
l = noop
semicolon = noop
apostrophe = noop

# ------------------------------------------ #

# RIGHT HAND
# BOTTOM ROW - Special keys
m = noop
comma = delete
dot = noop

I even vibe coded a layout visualiser to remember the keybinds.

Happy Ending?

Well, I could just lie and say that I have increased my productivity by 200% but, that is far from the reality. After I had fun changing the layout, I am just happy with the comfort of my laptop keyboard and have not used the split keyboard at all. I do use it sometimes but, I am so slow on it that I immidiately fall back to the laptop. It is obvious, it takes time to learn a split layout but, I am just not investing my time on it. Nevertheless, it was so damn fun while I configured it.

Projects like keyd just keep the spirit of Linux alive.

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

Ironically, after the setup, I only have received Webmentions from myself during testing (I am not counting the mastodon likes that propagated through Bridgy Fed). I am still sceptical about Bridgy Fed because It isn't what I wanted Webmentions to be, I didn't want any connections to a social media but I wanted to test the workings so I connected it.

How I Do It

My blog is a static site and being static comes with the cost of not being able to continuously listen to incoming messages. So, Webmentions don't really work on a static site. At least that's what I thought at first, then I found out about webmention.io.

It's sort of like a retrofitted static site to support Webmentions.

Components

• A Static Site Generator www.getzola.org
• Indieweb Compatibility indiewebify.me
• Send webmentions webmention.app
• Receive Webmentions webmention.io
• Render Webmentions keats.github.io/tera
• Runner GitHub actions

A Static Site Generator

I am using zola as my static site generator and I love it. The comfort of just writing in markdown and letting zola do the heavy lifting to generate feeds is awesome. Generating an Atom/RSS feed is a must. This is needed by webmention.app to send webmentions by reading all your posts.

Indieweb Compatibility

To make an Indieweb compatible static site you need to pass these tests from indiewebify.me.

1. Web Sign In - This helps you sign in to indieweb services with your domain. You must have your own registered domain name.
2. h-card and h-entry classes on homepage as well as on the "post" page.
3. Ability to send Webmentions.

Sending Webmentions

I use my generated Atom feed and webmention.app CLI to send Webmentions. It is as simple as running:

npx webmention https://scientiac.space/atom.xml --limit=0 --send

Receiving Webmentions

To receive Webmentions you need a perpetual listening server and the service is provided by webmention.io.

1. Sign into webmention.io with your domain. It will use indielogin.com. This requires you to have at least an email address on your h-card.
2. Go to sites and in the table click on Get Setup Code which will give you a tag to put on your HTML template header.
3. Test that you actually can receive Webmentions by mentioning yourself in a site and running the above command. It should show up in the dashboard of webmention.io.

Render Webmentions

You can now fetch the json feed of the Webmentions you have received in webmention.io using the following command and replacing the ${WEBMENTION_TOKEN} with your own token.

curl -s "https://webmention.io/api/mentions.json?token=${WEBMENTION_TOKEN}" -o webmentions.json

This json file can be used to render the Webmentions on your website using your static site generator's feature to read json files.

I made and activity page in zola where all the webmention activities are listed.

{% extends "base.html" %}

{% block content %}

<div class=section>

{% set data = load_data(path="webmentions.json", format="json") %}

<div class="activity-box">
{% for links in data.links %}
    {% set trimmed_path = links.target | trim_start_matches(pat="https://" ~ config.extra.url ~ "/") | trim_end_matches(pat="/") %}
    {% set relative_path = trimmed_path ~ ".md" %}
    {% set target_page = get_page(path=relative_path) %}
    {% if not links.source is starting_with("https://" ~ config.extra.url) %}
        {% if links.activity.type == "like" %}
            <div class="mention-profile like">
                <code><a href="{{ links.source }}">{{ links.data.author.name }}</a> liked <a href="{{ links.target }}">{{ target_page.title }}</a></code>
            </div>
        {% endif %}

        {% if links.activity.type == "link" %}
            <div class="mention-profile link">
                <code><a href="{{ links.source }}">{{ links.data.author.name }}</a> mentioned <a href="{{ links.target }}">{{ target_page.title }}</a></code>
            </div>
        {% endif %}

        {% if links.activity.type == "reply" %}
            <div class="mention-profile reply">
                <code><a href="{{ links.source }}">{{ links.data.author.name }}</a> replied to <a href="{{ links.target }}">{{ target_page.title }}</a></code>
            </div>
        {% endif %}
    {% endif %}
{% endfor %}
</div>

</div>

{% endblock content %}

+++
template = "activity.html"
+++

Webmentions are rendered by zola utilizing the load_data function of tera templating engine. The fetched webmention.json file is parsed and formatted. [Can be seen in activity.html in the above template.]

Runner

To rebuild the site by fetching new Webmentions we will need a runner that does the process repeatedly in said amount of time. This is where GitHub actions come in. I have three workflows send-webmentions.yaml, zola.yml and fetch-webmentions.yaml which as the name says, sends Webmentions from the site, builds the site using zola and fetches received Webmentions from webmention.io.

For fetching I have saved my webmention.app api key as a secret in GitHub and use that in the workflow file.

First put your token form webmention.io in settings > security > secrets and variables > actions > new repository secret of your GitHub repo with the name WEBMENTION_TOKEN.

Then, the workflow files should be put in place.

name: Fetch Webmentions

on:
  push:
    branches:
      - main
  schedule:
    - cron: '*/30 * * * *'  # Runs every 30 minutes
  workflow_dispatch:  # Allows manual triggering of the workflow if needed

jobs:
  fetch_webmentions:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Fetch Webmentions
        env:
          WEBMENTION_TOKEN: ${{ secrets.WEBMENTION_TOKEN }}
        run: |
          mkdir -p static/webmention
          # Fetch webmentions and save (overwrite) to a single file
          curl -s "https://webmention.io/api/mentions.json?token=${WEBMENTION_TOKEN}" -o static/webmentions.json

      - name: Commit and Push Webmentions
        run: |
          git config --global user.name "github-actions[bot]"
          git config --global user.email "github-actions[bot]@users.noreply.github.com"
          git add static/webmentions.json
          git commit -m "Update webmentions" || echo "No changes to commit"
          # Pull latest changes from main with rebase to avoid conflicts
          git pull --rebase origin main
          # Now push the updated branch
          git push

name: Zola on GitHub Pages

on:
  workflow_run:
    workflows: ["Fetch Webmentions"]
    types:
      - completed

jobs:
  build:
    name: Publish site
    runs-on: ubuntu-latest
    steps:
    - name: Checkout main
      uses: actions/checkout@v4
    - name: Build and deploy
      uses: shalzz/zola-deploy-action@v0.19.2
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

name: Send Webmentions
on:
  workflow_run:
    workflows: ["Zola on GitHub Pages"]
    types:
      - completed
jobs:
  send_webmentions:
    name: Send Webmentions with Delay
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
        
      - name: Wait for Delay
        run: sleep 60  # Waits for 1 minute (60 seconds) before running the next steps
        
      - name: Read Site URL from CNAME
        id: get_url
        run: |
          SITE_URL=$(cat static/CNAME)
          echo "site_url=$SITE_URL" >> $GITHUB_OUTPUT
        
      - name: Install Webmention Package
        run: npm install @remy/webmention
        
      - name: Send Webmentions
        run: npx webmention https://${{ steps.get_url.outputs.site_url }}/atom.xml --limit=0 --send

Sending Webmentions

In order to send Webmentions, the content should be formatted accordingly. In general I like to utilize three activities to send Webmentions. [It is preferred to only use one activity for one mention.]

Mention

One can mention a site using webmention by simply putting the link to the page being mentioned. The site will get the webmention if it supports it.

[Void Bed](https://flux.3o14.com/void-bed/) by flux.
or
<a href="https://flux.3o14.com/void-bed/">Void Bed</a> by flux

Like

One can like a post using webmention by formatting the link as follows:

I like how flux talks about his bed in <a class="u-like-of" href="https://flux.3o14.com/void-bed/">Void Bed</a>

I like how flux talks about his bed in Void Bed

Reply

One can reply to a post by formatting the link and the text as follows:

<a class="u-in-reply-to" href="https://flux.3o14.com/void-bed/">Void Bed</a>

I feel the same about my bed. Nice writing flux!

Bridges

Though I have connected this site to the fediverse with Bridgy Fed, it is opt in using a zola shortcode. Because, I want the articles to have a "blog interaction" from other peoples blog but not from the social media. But, I do use bridgy on my short posts sometimes. Webmentions and Linux is/not Difficult are some posts I have used bridgy with and they also work as example posts to see how different webmention activities look like in my website.

Lastly

I had forgotten about webmentions and interactions on my site, but I recently read a post from Joel titled Webmentions but manual (for Jekyll) and people giving names to the interactions really caught my attention. I haven't given it a name because mine are just Webmentions but I feel like Webmentions are still a good option to have (with much less spam) for interaction if it isn't connected to an actual social media. Some other posts I read were: [At least for the sake of just pinging them.]

Implementing Community Echoes
Blog interactions
What Others Said...

I hope webmention on blogging sites takes off. Or maybe it has already taken off. I want the future where everyone can express themselves with their own taste and creativity not having to compromise personality for protocols.

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

                  -`                     scientiac@einstein
                 .o+`                    ------------------
                `ooo/                    OS: Arch Linux x86_64
               `+oooo:                   Host: ASUS Zenbook 14 UM3406HA_UM3406HA (1.0)
              `+oooooo:                  Kernel: Linux 6.15.4-arch2-1
              -+oooooo+:                 Uptime: 31 mins
            `/:-:++oooo+:                Packages: 997 (pacman)
           `/++++/+++++++:               Shell: zsh 5.9
          `/++++++++++++++:              Display (SDC419D): 2880x1800 @ 60 Hz (as 1440x900) in 14" [Built-in]
         `/+++ooooooooooooo/`            WM: niri (Wayland)
        ./ooosssso++osssssso+`           Cursor: Adwaita (24px)
       .oossssso-````/ossssss+`          Terminal: ghostty 1.1.3-arch1
      -osssssso.      :ssssssso.         Terminal Font: FantasqueSansM Nerd Font Mono (11pt)
     :osssssss/        osssso+++.        CPU: AMD Ryzen 7 8840HS (16) @ 5.13 GHz
    /ossssssss/        +ssssooo/-        GPU: AMD Radeon 780M Graphics [Integrated]
  `/ossssso+/:-        -:/+osssso+-      Memory: 2.51 GiB / 14.91 GiB (17%)
 `+sso+:-`                 `.-/+oso:     Swap: 0 B / 4.00 GiB (0%)
`++:.                           `-/+/    Disk (/): 20.95 GiB / 475.94 GiB (4%) - btrfs
.`                                 `/    Local IP (wlan0): 192.168.1.71/24
                                         Battery (ASUS Battery): 52% [Discharging]
                                         Locale: en_US.UTF-8

Firstly...

My friend challenged me to achieve flicker free boot on my laptop like someone achieved it many-many years ago, and said if fedora can do it by default why can't we?

Technically he didn't challenge me, he only mentioned that it was possible. And, I took it as a challenge. Because I know that linux can be as smooth and polished looking as other commercial OS offerings. And I want my laptop to be as smooth as possible and as clean looking as possible.

So, I tried.

How did you start?

The only thing I didn't really want to do was reinstall my OS again. But, I had to. I had never used the Unified Kernel Image (UKI) and I was using systemd-boot as my bootloader. So, the bootloader had to go and UKI had to be installed.

Note

1. When installing Arch Linux, use UKI Unified Kernel Image and instead of using a bootloader, use EFIstub (EFI Boot Stub)

I used archinstall and it had both of these options. It was very easy. I picked all other configurations as I used to do and just installed the system.

After Installation

I had to change the kernel parameters, to make all those text go away. So, I tried using efibootmgr and failed again and again. I couldn't for science's sake use it properly. Once, I tried using the script recommended by the arch-wiki, the boot process flickered more than It had ever flickered. Luckily it hadn't removed the original entry and efibootmgr had a way to remove the broken entries, so I brought everything back to normal and tried it a countless times, failing each time.

I gave up on efibootmgr, from previous experiences with booting with a splash screen, I knew plymouth was a thing. So, I installed it. And went searching for ways to put kernel-parameters during boot. Plymouth needed quiet splash to work.

Then, I found /etc/kernel/cmdline. I added quiet splash to the end of the line and then rebooted. It showed no changes. I found out that I had to rebuild the initial ramdisk environment. In other words I had to run:

# To (re-)generate initramfs images based on all existing presets, the -P/--allpresets switch is used. 
sudo mkinitcpio -P

Note

2. To add kernel parameters, you need to append the text on /etc/kernel/cmdline and then, rebuild the initramfs image using sudo mkinitcpio -P.

My /etc/kernel/cmdline looks like this:

root=PARTUUID=4638cd24-77e4-4ed3-bb8a-9478d9c2d2db zswap.enabled=0 rw rootfstype=btrfs quiet loglevel=3 udev.log-priority=3 systemd.show_status=false splash

The part until rootfstyps=btrfs was autogenerated during installation and I added the rest afterwards.

Now, It Worked! But, it was the same(somewhat). The splash animation for ASUS ran, then it showed me a big Arch Linux logo, then the screen went black and then the splash screen reappeared and it dropped me to my login manager. This was the behavior it used to show before I installed arch without doing anything I previously did. Basically, I was back to how it was before I reinstalled my OS. All that copying and configuring for nothing.

Why you should not give up

So, I started putting different kernel params to check if one of it worked and if any of it removed blackout before showing me the splash screen again. The wiki for silent boot suggested I put loglevel=3 systemd.show_status=auto rd.udev.log_level=3 in the kernel parameters.

It also said:

If you also want to stop systemd from printing its version number when booting, you should also append udev.log_level=3 to your kernel parameters. If systemd is used in an initramfs, append rd.udev.log_level=3 instead.

Since, I wasn't using systemd in the initramfs, I used udev.log_level=3 instead. Then I rebuilt the initramfs and rebooted. It was the same.

Note

3. Append quiet loglevel=3 udev.log-priority=3 systemd.show_status=false splash in /etc/kernel/cmdline to enable splash and quiet out the logs.

Then I became desperate and started looking everywhere; forums, wikis, even YouTube comment section. And, you know what? YouTube comments helped for once.

This comment is from the YouTube video I have linked above.

I finally realised, plymouth was the culprit. The kernel had to hand over the process to plymouth and it caused the delay after the big Arch Linux logo.

I also found out that kernel itself can render the logo without plymouth, that was how the Arch Linux Logo was being rendered even before plymouth had started. If only, I had read the silent boot wiki entry properly:

To prevent the kernel from blanking the vendor logo, Linux 4.19 introduced a new configuration option FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER that retains the contents of the framebuffer until text needs to be printed on the framebuffer console. Since version 4.19.arch1, the official Arch Linux kernels are compiled with CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER=y.

Thanks to arch I didn't have to recompile the kernel to get that.

Tip

There is no need to use plymouth because the Linux kernel can show splash images by itself and enabling both only makes the process less smoother.

It still wasn't "smooth"

I didn't want the Arch Linux logo, I wanted my vendor logo to be continued, like it was still booting until my login screen appeared. If only I can replace the "Arch Linux" logo with bgrt (The vendor's splash logo). So, I went looking where I could change that.

The Boot Graphics Record Table (BGRT) is an optional ACPI table which contains a pointer to the image that has been drawn during boot.

I found /etc/mkinitcpio.d/linux.preset to be the exact thing I was looking for. And from the name itself I knew I needed to rebuild the initramfs again for the changes to be reflected.

I had to change the following line in linux.preset:

default_options="--splash /usr/share/systemd/bootctl/splash-arch.bmp"

My first instinct was to go to /usr/share/systemd/bootctl/ and rm splash-arch.bmp. I did that and rebooted, Now, It showed black screen until the login manager showed up. It was progress.

Then I found my bgrt image in /sys/firmware/acpi/bgrt/ it was named image with no file extension.

So, I changed the above line to:

 default_options="--splash /sys/firmware/acpi/bgrt/image"

Then I rebuilt the initramfs and rebooted. To be greeted with a smooth boot. Like I wanted it to be. Showing bgrt until the login manager showed up.

Note

4. Change the default_options= configuration to /sys/firmware/acpi/bgrt/image in /etc/mkinitcpio.d/linux.preset then rebuild the initramfs by doing sudo mkinitcpio -P.

It was not as "smooth" as plymouth

The booting process was good and how I wanted it to be, but when it came to rebooting it showed:

[    54.796241] watchdog: watchdog0: watchdog did not stop!
[    54.918590] watchdog: watchdog0: watchdog did not stop!
[    55.597358] reboot: Restarting system

I didn't want that to show up and with a bit of research, I came to a conclusion that disabling watchdog was fine so I did. I edited /etc/modprobe.d/blacklist.conf and added blacklist sp5100_tco. Intel users are supposed to blacklist iTCO_wdt or the watchdog that their system used.

Now my /etc/modprobe.d/blacklist.conf has:

# Do not load the watchdog module on boot.
blacklist sp5100_tco

Note

5. Blacklist your watchdog so you don't get watchdog messages when rebooting and powering off by editing /etc/modprobe.d/blacklist.conf.

I don't like having nice things

What I did above is enough to get flicker free boot/smooth boot or whatever you call it, but I wanted more, I want plymouth to work without flicker. Spoiler: I couldn't.

Anyway, I switched to systemd instead of udev so my /etc/mkinitcpio.conf has the following hooks now:

HOOKS=(base systemd modconf autodetect kms keyboard sd-vconsole block filesystems fsck plymouth)

I reinstalled plymouth, and I like it when it smoothly transitions to GDM instead of flashing me to GDM. It was a tradeoff between GDM flash or just flicker when loading spalash screen.

I added more kernel parameters to mitigate the flashing but I couldn't do it.

root=PARTUUID=4638cd24-77e4-4ed3-bb8a-9478d9c2d2db zswap.enabled=0 rw rootfstype=btrfs amdgpu.modeset=1 amdgpu.dc=1 video=efifb:keep plymouth.use-simpledrm quiet vt.global_cursor_default=0 loglevel=3 rd.udev.log_level=3 systemd.show_status=auto splash

plymouth.use-simpledrm does start plymouth immediately but when the amdgpu driver is ready it mode-switches to it and the black screen appears. I can technically use nomodeset and achieve true flicker free boot with plymouth and everything but then I lose out on my graphics driver setting dpi scaling and brightness and more for me on boot.

I even tried setting /etc/plymouth/plymouthd.conf to delay it's starting but it still doesn't stop flickering. It either flickers or it skips and I get the UKI splash screen until the login manager.

[Daemon]
ShowDelay=0
DeviceTimeout=30

I think I will just remove the plymouth configuration since it isn't helping anything. Or maybe I'll just leave it there because it is not doing anything.

Removing Arch Linux Logo

To remove the logo from GDM I quickly installed gdm-settings and there was a toggle which I turned off.

I didn't like the logo shown by plymouth during boot either, so I just removed the image watermark.png from the spinner theme in /usr/share/plymouth/themes/spinner/. I also removed all animation and throbber images just to make everything clean.

Conclusion

I did eventually come back to "not so smooth boot" but I am one sudo pacman -R plymouth away from it. Furthermore, I can boast about having 3 splash screens that look the same transitioning seamlessly*, even 4 if you count the UEFI animation.

It goes as follows:

1. UEFI animation starts and ends.
2. UKI Splash Screen starts and ends.
3. simpledrm backed plymouth bgrt theme starts and screen goes blank.
4. amdgpu backed plymouth screen gradually appears and transitions to GDM.

But, if I remove plymouth:

1. UEFI animation starts and ends.
2. UKI Splash Screen starts and drops me to GDM.

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

Preface

When I started using Linux, I found out that I had to use cronjobs to run some scripts I wanted to run in repeat, that was how I was introduced about services/daemons. Then it was when trying to make a website, I needed a server to continuously see the live changes that I did to my HTML file. I gradually learned about more industry standard servers like Apache after playing with the python server module almost all the time when testing and making a website. Then I found out about self-hosting. [That's what's like growing in a Linux environment.] I hated subscriptions and was unable to use the "free" VPS services due to their credit card requirements. Almost everything I did was entirely on my laptop and on my phone with Termux. [I used to use Termux even before I got a laptop.] Then, being in the Linux communities I got interested in Privacy and Security, then I joined mastodon as a healthier alternative social media platform as an experiment.

I didn't know about decentralization and federation back then, I used the link from the YouTube channel I liked and that was my social media home, until that server (Instance) got shut down, and I had to move to a new instance, that is how I got to know about decentralization and federation. Now living in one of the servers, I found out about more services like mastodon that weren't mastodon but could communicate with my instance but had a completely different UI and features. I learned about single user instances and servers particularly for a single user. Since then, I wanted my own private island(instance) of my social media. I did somewhat treat this blogging site as my own island, but it is static and isn't like a "social" media at all. This is how I got interested in ActivityPub and wanted to build my own.

Introduction

3o14 (pi) is a single user ActivityPub based social media that also supports rendering mathematical typesetting as a way to scientifically communicate between people. It is a self-hostable social media for a single person that is Privacy respecting (obviously) and we (It's not my single effort.) built it to understand the underlying protocol ActivityPub and how it worked. (And as a minor project for our computer engineering degree.)

How the Fediverse works

The Fediverse operates on a decentralized model, allowing various independent servers, or instances, to communicate with one another through open protocols like ActivityPub. Each instance hosts its own community and user base [It could be a single user too], enabling users to create accounts on different servers while still interacting seamlessly with users on other instances. When a user posts content, that activity is packaged in a standardized format and sent to other instances, allowing for real-time updates and interactions across the network. This federated approach ensures that no single entity controls the entire ecosystem, promoting user autonomy and privacy. Additionally, the use of open-source software means that anyone can set up their own instance, fostering a diverse range of platforms and experiences within the Fediverse. By leveraging these protocols, you can build applications that not only respect user privacy but also facilitate rich, interconnected social experiences across various platforms.

What we wanted to build (and eventually built)

We wanted to build a single user social media platform using the protocol, that supported mathematical syntax for scientific communication. It had to be easy to deploy with minimal efforts and had to be federated with the network of Fediverse. It would be a platform for tech minded scientific people who want privacy in their social media and want to own their own data without having to rely on big tech and black box social media with constraints like Facebook, X, Instagram, etc. which do not have anything helpful for using mathematical symbols in the posts. [This absolutely doesn't mean that it doesn't support regular posts, it should.]

I want to start from the frontend, because that is the most amount of work I have put in.

Frontend

For the frontend, I used React Native because I was looking at the trends and saw a growing social media Bluesky writing its cross-platform frontend entirely in React Native and saw how they had all the features available in both their web and mobile platforms. It was fairly easy to use with a framework called 'Expo', which made building and testing the app in web and in android much easier. Learning about routes of expo and how it handled screens and modals was a bit difficult at first, but it got easier as the app grew. But working with multiple platform did bring multiple issues for different platforms.

One of the issues was rendering mathematics, there was no library that could render math on web as well as in mobile. I had to work around by using two libraries with separate rendering logic for web and mobile, of which I still am not satisfied with how the mobile renderer is a bit slow and janky, but I made the two platforms act as closest as possible.

Learning about ActivityPub APIs was fun, I got to know how the requests were made and how things worked after the UI is clicked, how screens were loaded and so much. AI tools helped a lot to write logics and understand them when I was absolutely blank about what to do. [It happened more often than you'd think.]

Backend

I did not do much work on the backend, faultypointer did the work. But I do understand the technologies used in it. Hono was used for the server and fedify was used as the typescript library to eliminate the boilerplate for building Fediverse apps (I didn't just take that from the fedify site). The server too is written in typescript like the frontend. Fedify works as the middleware that processes the activity/json data that are requested to the server for federation. The database is Postgres and the schema and query is handled by the drizzle ORM.

Showcase

Conclusion

There isn't much to conclude here because we have achieved the basics of what we want, but the work is very incomplete and alpha. We have an android app that does work with all other servers, not just ours thanks to Fediverse, but everything is bare-bones and need many improvements. This piece of art is presentable, but I now need to host both the webui and backend on a Raspberry Pi to show that a simple device can handle your social media, and you don't have to rely on big tech for it.

Lastly, here is the source for what we are working on, github/3o14-com. Enjoy!

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

I am very much into customization, and I like to keep changing things around. When I was using gnome in arch Linux some years back I had come across rafaelmardojai/firefox-gnome-theme which I immediately installed to make my system consistent with the libadwaita style. That was the time when I realized the repo had almost 100% CSS in the GitHub language thingy bar. I knew what CSS was but never bothered to look into the Firefox theme, it simply worked.

Fast-forward to a few months ago, the arc browser had the internet going crazy about it. I did like the UI being minimal and focused on viewing websites, hiding the settings that would normally show up all the time. Since you had to make an account to just use the browser, I didn't use it. Then I went searching for themes that replicated the UI on Firefox itself. I found KiKaraage/ArcWTF which I used for a while. This time I modified the CSS and restarted Firefox and kept on updating the CSS and restarting Firefox until I got what I wanted. I hated that I had to restart Firefox to apply the small change in userChrome.css that I was going to repeat because I didn't know what I was doing.

I am currently using nix, so, eventually this was to come. I had to configure my Firefox with home-manager. This caused me to leave behind my arcWTF css because there was no easy way to simply put the chrome folder in its place with nix. But, there was a way to write userChrome within the nix configuration. This way of changing CSS was even more of a hassle because I had to first write it inside nix with no LSP for CSS, then I had to evaluate the nix file to put things into place and then restart Firefox.

Aaah! That was really clunky but, I then made single userChrome.css and userContent.css files and then just imported them with nix to read the file instead of writing the CSS inside the .nix file, and it was a little better. Now started my journey to make the most minimal and at the same time good Firefox userstyle in a single .css file. I then found simplefox a goldmine for minimal Firefox config, but there was a single issue, I was used to the tabs being tree style and on the left sidebar. So, I installed sidebery and got some CSS from arcWTF to make the collapsed sidebar work.

Then I got a new laptop, which currently has windows, but It has a gorgeous screen which in comparison to the previous laptop is the difference of 70% more DCI-P3 with a 3k OLED screen. I copied my CSS from my NixOS machine, and it was working pretty well. Until I had an idea to improve it further. For days, I kept editing the CSS and restarting my Firefox to change the .css with hit and trial getting more failures than success in the style actually being like I intended it to be. And then yesterday I was fed up with doing that and actually searched if there was a way of doing that without restarting Firefox (live).

Surprise, surprise, it was not just possible but intentional. I wished I had known about this before. You just do the following things:

1. Open the hamburger menu.
2. Go to more tools.
3. Click on web developer tools. The web developer interface will open, now on the top right side of the toolbox,
4. Click on the 3 dot menu.
5. Click on settings.
6. Enable two options:

    enable remote debugging

    enable browser chrome and add-on debugging toolboxes.

7. Then go to hamburger menu > more tools > browser toolbox or the shortcut Ctrl+Shift+Alt-I.
8. Then it'll ask for confirmation with the following prompt:

    An incoming request to permit remote debugging connection was detected. A remote client can take complete control over your browser!

    Client Endpoint: 127.0.0.1:51146
    Server Endpoint: 127.0.0.1:51141

    Allow connection?

9. Allow it and the toolbox opens. Go to the style editior from the menu.
10. Find userChrome.css and enjoy live tinkering. When you are done, just click on save or Ctrl+S and it is permanent.
11. For userContent.css just come to the Firefox homepage and hit Ctrl+Shift+C, go to the style editor and find the userContent.css.

Finally

I created this beautiful Firefox userstyle with a focus on minimalism and web content. It's called scifox because duh! It's my Firefox I will call it whatever I want. I am also working on a version with hidden panels that show up on hover to make it even more minimalistic and immersive. If you want to check that out, it's on the immersive branch.

I have grown to prefer this minimal UI, and I absolutely love Adaptive Tab Bar Colour for making the whole UI follow the style the creator of the website intended. And one more thing, I am in love with uBlock Origin and can't live without it. So, if you are not a Firefox user give Firefox a go, I know it'll not disappoint you and even if it does Firefox is like Linux, you can pick and plug features make it work the way you want.

Looking for the URL bar in webpage? Hover where it should be and you might just find it.

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

In the video, I am picking the robot up sometimes to keep it on a new position to show that it can track it's last position and go directly there instead of trying to calculate the route again.

In today's world, efficient waste management is becoming increasingly crucial due to rapid urbanization and population growth. Traditional methods of waste collection and dumping are labor-intensive and often inefficient. By integrating robotics and advanced algorithms, we can streamline these processes, reduce human effort, and ensure a cleaner environment. This project, 'manoid', aims to demonstrate how a robot can autonomously detect, navigate, and manage waste using only a single overhead camera and advanced computer vision techniques.

I have written another blog post related to this: Manoid: Communication

Let's see how it was made.

Requirements:

Basic Setup

Setting Up Arduino IDE

To install the ESP32 board in your Arduino IDE, follow these instructions:

1. In your Arduino IDE, go to File > Preferences.
2. Enter the following into the “Additional Board Manager URLs” field:

  https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

3. Click the “OK” button.
4. Open the Boards Manager. Go to Tools > Board > Boards Manager.
5. Search for ESP32 and press the install button for the “ESP32 by Espressif Systems”.
6. Once installed, select your ESP32 board in Tools > Board menu.
7. Select the appropriate Port in Tools > Port menu (in my case it was the DOIT ESP32 DEVKIT V1).

Now your Arduino IDE is set up to work with ESP32.

Setting Up The Environment

I've got my environment all sorted out with Nix and Nix Flake, and I've made it even easier with direnv activation. Mosquitto's up and running smoothly on its default port 1883. python and it's dependencies opencv,numpy,paho-mqtt and flask in a virtual environment are set up via nix flakes as well. You can look at the nix documentation to know more about how it works.

To set it up:

1. I assume that nix is installed with flakes enabled on your computer.
2. Clone the repo and enter the environment by running nix develop or allowing direnv to do it for you if you have it installed.

  git clone https://github.com/scientiac/manoid

3. A MQTT server will be running as soon as you enter the environment on the default port of 1883 and you can check the logs using the screen command.
4. Change parameters to match your device and make sure everything in on point.
5. Run the main.py script and admire the magic.

Changing Parameters

When adjusting parameters due to dynamic changes in Wi-Fi or IP addresses, several key locations in the code need to be updated to ensure MQTT and IP camera is properly connected. Here's a breakdown of where to make these adjustments:

In the esp32.ino file:

  const char* ssid = "Your_WIFI_SSID";
  const char* password = "Your_WIFI_Password";
  const char* mqtt_server = "Your_MQTT_Server_IP";

In the main.py file:

  MQTT_BROKER = "Your_MQTT_Server_IP" # this is at the top of the document
  args=("http://Your_IP_Camera_feed_Address",) # this is almost at the end of the document
  
  # to use a usb camera 
  args=(0,), # this can be used and the camera may have ID other than `0` so make sure to check that

Tuning the motors is essential because it directly impacts the robot's movement, responsiveness, and overall efficiency. Factors such as the size, power, and weight distribution of the robot, as well as the surface it operates on, can all influence how the motors should be configured.

In the esp32.py file:

  # Tuning the motors
  int left_min_pwm_forward = 110;
  int left_min_pwm_backward = 115;
  int right_min_pwm_forward = 110;
  int right_min_pwm_backward = 115;

In the main.py file (tuning PID settings):

  robot_settings = {
      6: {  
          # Robot ID 6
          "P_left": 0.8,
          "P_right": 0.8,
          "P_center": 0.4,
          "I_left": 0.01,
          "I_right": 0.01,
          "I_center": 0.01,
          "D_left": 0.001,
          "D_right": 0.001,
          "D_center": 0.001,
          "backward_speed_left": 10,
          "backward_speed_right": 10,
          "left_prev_error": 0,
          "right_prev_error": 0,
          "center_prev_error": 0,
          "dt": 0.3,
      }
  }

Making the bot:

1. Assemble the bot following the diagram below:

2. Then open the file inside the project directory on etc/esp32/esp32.ino on your Arduino IDE set up to work with esp32 and change the parameters to fit your environment.
3. And finally flash it!

You can test the bot manually by connecting to the mqtt server using an application (like MyMQTT on android) and sending values from 0 to 255 to the topics :
/robot6_left_forward
/robot6_left_backward
/robot6_right_forward
/robot6_right_backard
where 0 being the wheels at no speed and 255 being the max speed

What is in the code?

The Functions, duh!

Finally

Testing

To test only the main.py file for it's pathfinding capabilities, you can run the ./pngstream.py file in the etc directory and put http://127.0.0.1:5000/video_feed on the following placeholder in main.py:

    args=("http://Your_IP_Camera_feed_Address",) # this is almost at the end of the document

and then run main.py. This will open up a window with the png showing the detected path in the screen along with detecting all the ArUco markers. If only the markers are detected and the path doesn't show up, it can be assumed that the code isn't working corrctly.

I suggest testing this way as soon as nix finishes setting the environment and keep testing the code like this to minimize the need to test it physically.

Troubleshooting Common Issues

• Connection Problems: If the robot fails to connect to the MQTT broker, double-check your Wi-Fi credentials and ensure the broker's IP address is correct in both the ESP32 firmware and main.py. (The main.py script will print errors if something isn't properly connected.)
• Movement Issues: If the robot's movements are erratic or it doesn't move as expected, recheck the motor connections and ensure the PWM values are correctly tuned in main.py and esp32.ino.
• Marker Detection Failures: If the robot cannot detect ArUco markers, ensure the camera feed is clear and unobstructed. Adjust the camera's focus and lighting conditions to improve detection accuracy."

Possible Improvements

1. In my pathfinding algorithm, I don't search for the diagonal paths which lengthens the "short path" as I wanted the robot to face the waste or the destination from either sides of the square and not the corners.
2. Making swarm robots instead of using only one.
3. Making the code object-oriented.
4. Adding grippers to grab the waste instead of the 5-second delay and drop the waste on its destination.

We had added the functionalities of gripping and swarm navigation when using this bot on a Robotics Competition in Nepal called Yantra Swarmanoid but decided to remove it on this showcase, though the code to grab and drop the waste is still in there in 'main.py'.

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

Introduction

Building a clueless robot isn't an easy task and I am only in the beginning of it. This report will discuss on how to setup the microcontroller boards and how the communication will work for project manoid (A waste management robot). Also, the much difficult image processing and mapping is on the way, which I should be working on instead of writing this but I'll leave that for next year. Communication seems like a simple topic to work on for now.

Note : I wrote the code for the bot manoid in arduino's '.ino' instead of using micropython's '.py' but micropython can be used to do the same as well.

Requirements:

Basic Setup

Flashing Firmware

Micropython is an implementation of Python 3 that includes a small subset of the Python standard library and is optimised to run on microcontrollers and in constrained environments. The microcontroller I am using is the ESP8266 (NodeMCU). Flashing it with micropython was easy (for me), I've been flashing things since years. It goes like this:

1. Install esptool and erase flash your ESP8266 first.

You should first confirm that /dev/ttyUSB0 is your device which you want to flash micropython on.

    esptool.py --port /dev/ttyUSB0 erase_flash

2. Then flash the latest firmware of ESP8266.

    esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect 0 <path to the .bin file (firmware)>

The default flashing mode worked on my first ESP8266 but when I tried to flash it to another ESP8266 it flashes successfully but didn't let me access the repl. So, I had to set the flashing mode to dout.

    esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect --flash_mode dout 0 <path to the .bin file (firmware)>

3. Check if everything is working by connecting to the micropython repl. You can use screen or tmux or your own solution to connect to the repl. Here is how you can use screen:

    screen /dev/ttyUSB0 115200

The above command gives you a blank screen, when you hit enter you'll get the prompt, type help and hit enter. This should show up:

MQTT

I am sure you played with the repl and now it's time to push some scripts to run in it. For now we will focus on using MQTT protocol to transfer data from one machine to another.

An overview of how MQTT works

1. A MQTT client establishes a connection with the MQTT broker.
2. Once connected, the client can either publish messages, subscribe to specific messages, or do both.
3. When the MQTT broker receives a message, it forwards it to subscribers who are interested.

Here, server will be mosquitto running on the computer publisher will be the python script on the computer and subscriber will be the ESP8266 running micropython. [Message will be sent from python script through mosquitto server to ESP8266]

Mosquitto

To set the mosquitto server first we should allow port 1883 on your firewall. I am using a custom configuration file for now. So, make a file named mosquitto.conf and put the following lines to allow all connections:

    listener 1883
    allow_anonymous true

then run the server by the following command:

    mosquitto -c ./mosquitto.conf

This is how it'll look when a client named tesseraclient connects to the server:

Pushing Scripts to the Microcontroller

There are two important files that MicroPython looks for in the root of its filesystem. These files contain MicroPython code that will be executed whenever the board is powered up or reset (i.e. it 'boots'). These files are:

boot.py

This file is run first on power up/reset and should contain low-level code that sets up the board to finish booting.

main.py

If this file exists it's run after boot.py and should contain any main script that you want to run when the board is powered up or reset.

To push the scripts I am using adafruit-ampy but the official way to push files is using their webrepl.

Using ampy you can push scripts with the following command:

    ampy -p /dev/ttyUSB0 put <filename.py>

Programming

Publisher

Firstly a python script on the computer to send messages, it sends on and off in the interval of 500ms with topic led to the mosquitto server:

    import time
    import paho.mqtt.client as mqtt
    BROKER_ADDRESS: 000.000.00.00 # IP address of the device running the mosquitto server


    def on_connect(client, userdata, flags, rc):
        if rc == 0:
            print("Connected to broker")
        else:
            print("Connection failed with code", rc)


    def on_disconnect(client, userdata, rc):
        print("Disconnected from broker")


    def establish_connection():
        client_id = "tesserver"
        client = mqtt.Client(client_id=client_id)

        client.on_connect = on_connect
        client.on_disconnect = on_disconnect

        client.connect(BROKER_ADDRESS, 1883, 60)

        return client

    led_topic = "led"
    client = establish_connection()

    client.publish(led_topic, "off")
    time.sleep(500)
    client.publish(led_topic, "off")
    time.sleep(500)

Subscriber

boot.py

This will start when I plug the esp to the power supply. No need to connect via webrepl and start manually. Generally it's not recommended to touch the boot.py file. main.py should be used instead but this is I who programming the microcontroller so boot.py it is.

    import esp
    import os, machine
    import gc
    import webrepl

    webrepl.start()
    gc.collect()

    import network
    import time
    import machine

    # Wi-Fi configuration
    ssid =  abcdef #WIFI_SSID
    password = 12345678 #WIFI_PASSWORD


    # Function to connect to Wi-Fi
    def connect_wifi():
        wlan = network.WLAN(network.STA_IF)
        wlan.active(True)

        if not wlan.isconnected():
            print("Connecting to WiFi...")
            wlan.connect(ssid, password)
            # wlan.connect(ssid)

            while not wlan.isconnected():
                time.sleep(1)

        print("Connected to WiFi")


    # Connect to Wi-Fi
    connect_wifi()

    # Check if Wi-Fi connection is successful before executing mqtt.py
    if network.WLAN(network.STA_IF).isconnected():
        # Execute mqtt.py
        try:
            import mqtt  # Replace 'mqtt' with the actual name of your Python script
        except Exception as e:
            print("Error executing mqtt.py:", e)

mqtt.py

Upon connecting to the WIFI successfully the above script will import this file and things magically happen.

    import machine
    from umqtt.simple import MQTTClient
    import time
    from secrets import BROKER_ADDRESS

    # MQTT configuration
    client_id = "teserraclient"
    broker_address = 000.000.00.00 # IP address of the device running the mosquitto server
    led_topic = b"led"

    # LED Pin
    led_pin = machine.Pin(15, machine.Pin.OUT)


    def connect_mqtt():
        c = MQTTClient(client_id, broker_address)
        c.set_callback(callback)

        while True:
            try:
                c.connect(clean_session=False)
                print("Connected to MQTT broker.")
                c.subscribe(led_topic)
                return c
            except OSError as e:
                print(f"Connection error: {e}")
                print("Retrying in 5 seconds...")
                time.sleep(5)


    def callback(topic, msg):
        print(f"Received message on topic {topic.decode('utf-8')}: {msg.decode('utf-8')}")

        if topic == led_topic:
            if msg == b"on":
                print("Turning on the LED")
                led_pin.on()
            elif msg == b"off":
                print("Turning off the LED")
                led_pin.off()


    mqtt_client = connect_mqtt()

    if mqtt_client:
        print("Waiting for messages...")
        while True:
            try:
                mqtt_client.wait_msg()
            except OSError as e:
                print(f"Error: {e}")
                print("Reconnecting...")
                mqtt_client = connect_mqtt()
                if not mqtt_client:
                    break

Finally

If everything works after installing all the python dependencies you will see this if you are supplying power to your microcontroller using a computer that can accept serial in upon doing a soft reboot and running your python (publisher) script from your computer.

This indicates that the publisher i.e. python script has connected to the server i.e. mosquitto and is now sending on and off messages to the server with topic led which then is sent to the subscriber i.e. ESP8266 which is interpreted by the microcontroller as a command to enable and disable the set GPIO pin i.e. pin 15 if you look closely at the code.

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

            #####           scientiac@mobius
           #######          ---------------
           ##O#O##          OS: Droidian trixie aarch64
           #######          Host: wcd937x Audio Codec AB IDP EXCALIBUR
         ###########        Kernel: 4.14-288-xiaomi-miatoll
        #############       Uptime: 1 hour, 40 mins
       ###############      Packages: 1945 (dpkg), 390 (nix-user), 47 (nix-default), 28 (flatpak)
       ################     Shell: bash 5.2.15
      #################     Resolution: 1080x2400x60x164823
    #####################   DE: GNOME (actually 'phosh')
    #####################   WM: weston (actually 'phoc')
      #################     Theme: adw-gtk3 [GTK2/3]
                            Icons: Papirus [GTK2/3]
                            Terminal: kgx
                            CPU: Qualcomm SM7125 (8) @ 1.804GHz
                            Memory: 2370MiB / 5587MiB

    * neofetch gathered some false data so i have manually edited this text blob.

Firstly...

I have been playing around and testing Droidian on my Xaomi Redmi Note 9 Pro Max (miatoll - excalibur) as a daily driver since November 17th. Before this I had tried Droidian about a year ago on this very device.

Note: The screenshots attached here are of my customized version of phosh and GTK colors, the default UI will look different.

A quick THEN v/s NOW

Then, the UI was not tailored for the device I was using, it was vanilla phosh with clock in the center of the bar which was covered by the punch-hole of my device and the notification panel was also not aligned correctly to the device. Now, it's fine and the UI is just how it should be for the device.

Then, The Camera was not working at all. Now, the droidian-camera does work but it's laggy. Though it technically can capture videos the frame rate drops very randomly and the video comes out to be choppy. The file size of the choppy video is also very high.

Then, Apps like telegram and messenger from Firefox did not connect to calls at all. Now, microphone is generally supported by all apps and voice calling via other apps work fine.

Then, Waydroid used to work without much problems. Now, upon launching Waydroid and trying to video-call the entire shell crashes and the only way to bring back the UI is by a forced restart.

Experience

Gnome Asia 2023 is starting Tomorrow, I travelled from Dharan to Kathmandu with Droidian on my phone and it feels like I am handicapped using this device coming from android.

Voice Calls

Since it is a phone it should be able to make calls and it does. Though my device supports two SIMs, droidian on my device only detects and uses one so, I had to let go of my secondary SIM.

Notifications

Apps should be running in the background to be able to make notifications, and the other thing is I am not notified with sound or vibration of any of my texts messages be it from apps like fractal, nheko, telegram-desktop or even gnome-messages even if the app is running in the background when the screen is off.

The gnome-calls app is the only app I know which can make "noisy notifications" when my phone is locked and the screen is off. So, I only know if anyone is calling me on my number but nothing if they use any other platform.

Maps

Yes, Gnome Maps works on this device but it does not show my real time location. And coming from using Google Maps, it isn't a very pleasant of an experience.

Waydroid

The waydroid experience was buggy when used in the default condition but it worked fine under a nested weston session. But, weston comes with a drawback. The resolution when used in the default phoc is great everything looks crisp but when used in a nested weston session the resolution is low and it's only usable. At least waydroid doesn't crash the whole phoc session when used inside the nested weston session.

The first image below is with 400dpi (in default phoc session) whereas the second one is on 1700dpi (in weston session) set from android developer settings.

Though gnome-maps do not show real time location, google maps from waydroid is able to do it. But, it requires some time to load everything.

Web Browsing

Web browsing is fine in droidian. Firefox with a mobile focused custom layout is the default browser. There are some glitches here and there on firefox caused by the inability to adapt to a mobile form but normal day to day browsing can be done nicely. Various websites, Facebook, Instagram, YouTube, everything works fine but not as smooth as using on desktop or android and it is expected because I am technically running a whole desktop application on a smartphone.

The desktop extensions work fine, but the UI to edit them from their window glitches on my device. So, the extensions which work by default work the best.

Social Media and Messaging

Well, mastodon is my favourite social media ever and Tuba is a dedicated app from flathub which works more than fine for it. YouTube, Facebook and Instagram can be used from the Firefox browser. For communication, telegram-desktop works fine, so does Nheko for matrix supporting voice calls as well, other matrix clients like Fractal work too. And there always are web based clients that work in responsive mode.

It's not always gtk apps, qt apps are convergent too; telegram-desktop and nheko are two examples. They are the only "apps" which support voice calls natively and even video calls if it detects a camera (it doesn't in mine).

File Sharing

Sharing files is surprisingly important in our day-to-day life. Since it is a whole Linux system ssh can be used to transfer and receive files as well as modify it remotely. For a more GUI approach the best way to share files from any kind of device is the magic-wormhole protocol. And warp being the GTK convergent app for Droidian, it has made my life a lot easier.

I am writing this blog on my laptop while taking screenshots from my phone and sending them to my laptop using warp.

Customization

The thing that introduced Linux to me and made it interesting was the customizability of it. I encountered Linux when YouTube recommended a video of KDE while I was searching for ways to customize windows. So, you can pretty much assume that I don't use things without giving some of my touch to it.

Colors and Textures

As I have mentioned before, the screenshots attached here are of my customized version of phosh and GTK colors. So, since it is basically a GTK environment, gradience works like a charm for changing the color palette of the apps. And for the phosh shell, some custom gtk.css on ~/.config/gtk-3.0/ will do the trick.

Here, I am using the gruvbox theme to customize my shell.

    phosh-home, .phosh-overview, phosh-app-grid {
        background-color: #282828; /* gruvbox primary color */
    }

    phosh-top-panel, phosh-lockscreen, .phosh-lockshield {
        background-image: url('file:///home/droidian/Desktop/image.png'); /* a blurred version of wallpaper or any preferred image */
        background-size: cover;
        background-position: center;
    {

Shell Tweaks

Changing icons, showing battery percentage in the bar, setting themes enabling Application filter, everything was done with an app called postmarketos-tweaks which I compiled from the source.

    https://gitlab.com/postmarketOS/postmarketos-tweaks

Scaling

The default scale is good for the eyes but for me it was a bit too big. I wanted more stuff on this small screen of my phone. For that I went to /etc/phosh/phoc.ini and set the following:

    [output:HWCOMPOSER-1]
    scale = 2.5

Finally...

The whole Linux ecosystem isn't convergent yet, and many apps go beyond the screen resulting in hidden buttons and texts. To tackle that problem, Droidian comes with Mobile Settings that helps to scale down particular apps so that they fit on the screen.

It would have been much better if it had...

Some features like, the semi-automatic screen rotation that android has nowadays which would show a small prompt to rotate the screen upon rotating the device but without automatically rotating it. Also, gestures in apps like video players to scroll and double taps to skip, which would make the droidian experience much better. And, maybe a qr-code scanner to connect to wifi networks.

Lastly, Some Mentions

Waydroid has been a life saver for using essential video calling apps and surprisingly banking apps. But, the default waydroid experience is very buggy. It is not the fault of droidian devs though, waydroid is a completely different project.

Gnome Online Accounts made it very easy to sync my contacts saved on google contacts, calender events, emails on droidian. It also connected my google drive with nautilus [Gnome Files] making it easy to upload and access files from my drive.

So,

My experience with Linux on Mobile was interesting, though it has a lot to improve, I didn't expect it to be "functional enough" that I could use it for days without diving back to android. I will use this for some more days, maybe until the Gnome Asia 2023 event ends.

There is lot more to try but, I want to end this experiment for now.

Goodnight!

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

Introduction

The purpose of this report is to document the process of building a CV robotic arm prototype using Arduino. The arm is designed to be controlled with natural hand gestures removing the need to look at the buttons on a screen or a controller to control it.

Materials Used:

1. Arduino Uno
2. 16 Channel Servo driver
3. Buck Converter
4. Jumper Cables
5. 3D Printed MK2 Chassis
6. 4 Servos
7. A Portable Computer with Camera

Software Used:

1. Arduino IDE V2
2. Python 3

Design:

The first step in building the CV controlled arm is to make a schematic of it. The arm is based on the MK2 Model, which is pretty easy to 3D-print and assemble. 4 servos are used for the base, the lower arm, the upper arm and the gripper. The servos are connected to the Servo Driver and the Servo Driver is connected to 5 volts DC power. The Arduino is used to control the Servo Driver to send PWM signals to servo.

The decisions for what signals to send for recognized gestures handled by a Python script which sends serial to Arduino via the USB. The Arduino receives the signal which is now converted to mechanical output.

Construction:

The assembly of the base is a bit tricky with gears and servos to be attached to it, but the upper part is easily attached. The four servos are placed on the right place according to MK2 schematics and are connected to 16 Channel Servo Driver. (I connected 0,2,4 and 7 as base, lower arm, upper arm and gripper respectively on the Servo Driver.) While connecting the Servo Driver to Arduino; the VCC is connected to 5 volts and Grounds of Arduino and Servo Driver are connected. From Arduino the analogue 5 pin is connected to SCL and analogue 4 pin is connected to SDA respectively.(This connects the Servo Driver to the Arduino.)

The servo diver is connected to 5 volts DC converted from 12 volts power supply using a buck converter. USB connected to the Arduino supplies power to Arduino as well as the Servo Driver but not the Servos connected to the Driver. The USB also doubles as a data transmission device to send serial input to the Arduino from the laptop running the python script.

Programming

In Arduino:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);

#define SERVOMIN 100   // This is the 'minimum' pulse length count (out of 4096)
#define SERVOMAX 450   // This is the 'maximum' pulse length count (out of 4096)
#define SERVO_FREQ 50  // Analog servos run at ~50 Hz updates

// our servo # counter
uint8_t servonum = 0;
char prevSerial = '\0';
char data;

// Setting the default state of the arm.
int val1 = 312, val2 = 350, val3 = 174, val4 = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("Running...");

  pwm.begin();
  pwm.setOscillatorFrequency(27000000);
  pwm.setPWMFreq(SERVO_FREQ);

  delay(10);
}

void loop() {

  // checking if serial is available or not and setting values to "data" as soon as the serial changes
  if (Serial.available() > 0) {
    data = Serial.read();

    if (data == 'W') {
      if (val4 < SERVOMAX) {
        Serial.print("Gripper IN");
        Serial.println(val4);
        pwm.setPWM(7, 0, val4);
        val4 += 4;
      }
    }

    if (data == 'A') {
      if (val4 > SERVOMIN) {
        Serial.print("Gripper OUT");
        Serial.println(val4);
        pwm.setPWM(7, 0, val4);
        val4 -= 4;
      }
    }

    if (data == 'Y') {
      if (val2 < SERVOMAX) {
        Serial.print("Arm Base IN");
        Serial.println(val2);
        pwm.setPWM(2, 0, val2);
        val2 += 4;
      }
    }

    if (data == 'C') {
      if (val2 > SERVOMIN) {
        Serial.print("Arm Base OUT");
        Serial.println(val2);
        pwm.setPWM(2, 0, val2);
        val2 -= 4;
      }
    }

    if (data == 'B') {
      if (val3 < SERVOMAX) {
        Serial.print("Arm Top IN");
        Serial.println(val3);
        pwm.setPWM(4, 0, val3);
        val3 += 4;
      }
    }

    if (data == 'X') {
      if (val3 > SERVOMIN) {
        Serial.print("Arm Top OUT");
        Serial.println(val3);
        pwm.setPWM(4, 0, val3);
        val3 -= 4;
      }
    }

    if (data == 'D') {
      if (val1 < SERVOMAX) {
        Serial.print("Base IN");
        Serial.println(val1);
        pwm.setPWM(0, 0, val1);
        val1 += 4;
      }
    }

    if (data == 'Z') {
      if (val1 > SERVOMIN) {
        Serial.print("Base IN");
        Serial.println(val1);
        pwm.setPWM(0, 0, val1);
        val1 -= 4;
      }
    }

    if (data == 'S') {
      Serial.println("stop");
    }
  }
}

In Laptop:

#!/bin/python

import cv2
import mediapipe as mp
import math
from serial import Serial

mp_drawing = mp.solutions.drawing_utils
mp_hands = mp.solutions.hands

def calculate_distance(x1, y1, x2, y2):
    return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)

def is_fist(landmarks):
    # Check if all finger tips are below their corresponding middle joints
    return (
        landmarks[mp_hands.HandLandmark.THUMB_TIP].y < landmarks[mp_hands.HandLandmark.THUMB_IP].y and
        landmarks[mp_hands.HandLandmark.INDEX_FINGER_TIP].y < landmarks[mp_hands.HandLandmark.INDEX_FINGER_PIP].y and
        landmarks[mp_hands.HandLandmark.MIDDLE_FINGER_TIP].y < landmarks[mp_hands.HandLandmark.MIDDLE_FINGER_PIP].y and
        landmarks[mp_hands.HandLandmark.RING_FINGER_TIP].y < landmarks[mp_hands.HandLandmark.RING_FINGER_PIP].y and
        landmarks[mp_hands.HandLandmark.PINKY_TIP].y < landmarks[mp_hands.HandLandmark.PINKY_PIP].y
    )

def get_hand_side(landmarks):
    # Check if the wrist is to the left or right of the index finger tip
    if landmarks[mp_hands.HandLandmark.WRIST].x < landmarks[mp_hands.HandLandmark.INDEX_FINGER_TIP].x:
        return "Left"
    else:
        return "Right"

def main():
    cap = cv2.VideoCapture(0)

    with mp_hands.Hands(max_num_hands=1) as hands:
        while cap.isOpened():
            ret, frame = cap.read()

            if not ret:
                print("Unable to capture frame.")
                break

            # Flip the frame horizontally to mirror the image
            frame = cv2.flip(frame, 1)

            # Convert the image from BGR to RGB
            image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

            # Process the image with MediaPipe Hands
            results = hands.process(image_rgb)

            # Check for hand landmarks
            if results.multi_hand_landmarks:
                for hand_landmarks in results.multi_hand_landmarks:
                    # Draw hand landmarks on the image
                    mp_drawing.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)

                    # Get the coordinates of the index finger and thumb landmarks
                    index_finger = hand_landmarks.landmark[mp_hands.HandLandmark.INDEX_FINGER_TIP]
                    thumb = hand_landmarks.landmark[mp_hands.HandLandmark.THUMB_TIP]
                    wrist = hand_landmarks.landmark[mp_hands.HandLandmark.WRIST]

                    # Convert landmark coordinates to pixel values
                    height, width, _ = frame.shape
                    x1, y1 = int(index_finger.x * width), int(index_finger.y * height)
                    x2, y2 = int(thumb.x * width), int(thumb.y * height)

                    # Calculate the distance between the index finger and thumb
                    distance = calculate_distance(x1, y1, x2, y2)

                    # Count the number of fingers that are up
                    fingers_up = 0
                    landmarks = hand_landmarks.landmark
                    if landmarks[mp_hands.HandLandmark.THUMB_TIP].y < landmarks[mp_hands.HandLandmark.THUMB_IP].y:
                        fingers_up += 1
                    if landmarks[mp_hands.HandLandmark.INDEX_FINGER_TIP].y < landmarks[mp_hands.HandLandmark.INDEX_FINGER_PIP].y:
                        fingers_up += 1
                    if landmarks[mp_hands.HandLandmark.MIDDLE_FINGER_TIP].y < landmarks[mp_hands.HandLandmark.MIDDLE_FINGER_PIP].y:
                        fingers_up += 1
                    if landmarks[mp_hands.HandLandmark.RING_FINGER_TIP].y < landmarks[mp_hands.HandLandmark.RING_FINGER_PIP].y:
                        fingers_up += 1
                    if landmarks[mp_hands.HandLandmark.PINKY_TIP].y < landmarks[mp_hands.HandLandmark.PINKY_PIP].y:
                        fingers_up += 1

                    # Determine if the hand is right or left
                    hand_side = get_hand_side(hand_landmarks.landmark)

                    # Determine if there is a fist or not
                    is_hand_fist = is_fist(hand_landmarks.landmark)

                    # Display the number of fingers, distance, hand side, and fist status on the image
                    cv2.putText(frame, str(fingers_up), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
                    cv2.putText(frame, str(int(distance)), (10, 70), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
                    cv2.putText(frame, hand_side, (10, 110), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
                    cv2.putText(frame, str(is_hand_fist), (10, 150), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

                    # Combine the values
                    combined_values = [fingers_up, int(distance), hand_side, str(is_hand_fist)]

                    # Print the combined values
                    print(combined_values)

                    # Print the corresponding letter based on the conditions
                    if fingers_up == 2 and distance < 60:
                        print("Gripper IN")                    
                        input_value = 'A'
                        ardu = Serial('/dev/ttyUSB0', 9600, timeout=0.01)
                        ardu.write(input_value.encode())

                    elif fingers_up == 2 and distance > 60:
                        print("Gripper OUT")
                        input_value = 'W'
                        ardu = Serial('/dev/ttyUSB0', 9600, timeout=0.01)
                        ardu.write(input_value.encode())

                    elif fingers_up == 4 and hand_side == "Right" and not is_hand_fist:
                        print("Arm Base IN")
                        input_value = 'C'
                        ardu = Serial('/dev/ttyUSB0', 9600, timeout=0.01)
                        ardu.write(input_value.encode())

                    elif fingers_up == 4 and hand_side == "Left" and not is_hand_fist:
                        print("Arm Base OUT")
                        input_value = 'Y'
                        ardu = Serial('/dev/ttyUSB0', 9600, timeout=0.01)
                        ardu.write(input_value.encode())

                    elif not is_hand_fist and hand_side == "Right":
                        print("Arm Top IN")
                        input_value = 'B'
                        ardu = Serial('/dev/ttyUSB0', 9600, timeout=0.01)
                        ardu.write(input_value.encode())

                    elif not is_hand_fist and hand_side == "Left":
                        print("Arm Top OUT")
                        input_value = 'X'
                        ardu = Serial('/dev/ttyUSB0', 9600, timeout=0.01)
                        ardu.write(input_value.encode())

                    elif fingers_up == 5 and hand_side == "Right":
                        print("Base IN")
                        input_value = 'D'
                        ardu = Serial('/dev/ttyUSB0', 9600, timeout=0.01)
                        ardu.write(input_value.encode())

                    elif fingers_up == 5 and hand_side == "Left":
                        print("Base OUT")
                        input_value = 'Z'
                        ardu = Serial('/dev/ttyUSB0', 9600, timeout=0.01)
                        ardu.write(input_value.encode())

                    else:
                        print("STOP")
                        input_value = 'S'
                        ardu = Serial('/dev/ttyUSB0', 9600, timeout=0.01)
                        ardu.write(input_value.encode())

            # Display the mirrored image with landmarks
            cv2.imshow('Finger Tracking', frame)

            # Exit loop when 'q' is pressed
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

Testing:

The arm was completed, and it was time to test it. The servos were connected to power supply and the USB was connected to the Arduino. With the necessary code uploaded to the Arduino, the python script was run, and hand gestures were read from the computer which then converted to Serial signals and the code in Arduino interprets those Serial signals as per the uploaded code. Here, in the first trial reading the Front and Back side of the hand gave same results, I replaced the code for Left and Right aligned hand, which showed Right when I showed my right-hand palm to the Camera, and left when I showed my right-hand back to the camera, and vice-versa for the left hand. Which fixed the issue.

Challenges and Solutions:

There were not many challenges to make a working prototype which my arm is at the moment. But further improvement on the gestures are going to be challenging like; to read and interpret natural human arm movements in digital form and to match the movement of robot arm with an actual human arm.

Conclusion:

In conclusion, the CV robotic arm is a working prototype for better control of devices requiring less time to adapt. It helps people to be familiar with using complex devices like robotic arm in a very short period of time.

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.

Introduction

The purpose of this report is to document the process of building a fire extinguishing and gas sensing car using Arduino. The car is designed to detect fire using a flame IR sensor and go towards it to extinguish it if necessary. It also detects gas leaks and alerts the user via SMS. This report will detail the steps taken to design and build the car, as well as the challenges encountered and the solutions implemented.

Materials Used:

1. Arduino Uno
2. 3 Flame IR Sensors
3. MQ-2 Gas Sensor
4. Motor Driver
5. 2 DC Motor
6. Servo Motor
7. Water Pump
8. Fire Extinguisher (tested with water)
9. SIM800L GSM Module
10. Breadboard and Jumper Wires
11. Power Supply (Battery)

Design:

The first step in building the fire extinguishing and gas sensing car was to design a schematic. The car is powered by an Arduino Uno microcontroller, which controls the sensors, motors, and other components. The 3 flame IR sensors are used to detect fire from three different directions, and the MQ-2 gas sensor is used to detect gas leaks. The motor driver is used to control the DC and servo motors, which drive the car and the water pump, respectively. The fire extinguisher reservoir is mounted on top of the car and the pump pushes the extinguisher from the pipe which is spread by the back-and-forth motion of the servo motor. The SIM800L GSM module is used to send SMS alerts to the user in case of a gas leak.

Construction:

Once the schematic was finalized, the next step was to build the car. The components were connected to the Arduino Uno using a breadboard and jumper wires. The flame IR sensors were mounted on the front of the car on in the front and two facing either sides, and the MQ-2 gas sensor was mounted on top. The DC motors were connected to the motor driver and were used to drive the car. The servo motor was connected to the L298N motor driver and was connected to the fire extinguisher. The water pump was connected to the Arduino Uno and was used to pump water from the reservoir to the fire extinguisher which moved in a to and fro motion to spread the water coming out of it.

Testing:

Once the car was built, it was time to test it. The car was placed in a test environment and was subjected to various scenarios. The flame IR sensor was able to detect fire and direct the car towards it. The MQ-2 gas sensor was able to detect gas leaks and activate the SMS alert system. The fire extinguisher was successfully activated by the servo motor, and the water pump was able to pump water to the fire extinguisher.

Challenges and Solutions:

One of the major challenges encountered during the construction of the car was the calibration of the flame IR sensor. The sensor needed to be calibrated to detect the flame accurately and direct the car towards it. The heater connected to our room was also detected as a fire source which made it harder to test the bot. This was solved by testing the sensor with different fire sources and adjusting the code accordingly. Our test subject for demonstration was a burning paper which was used for the calibration of flame sensor.

Another challenge was the activation of the fire extinguisher. The servo motor had to be calibrated to activate the extinguisher at the right time, and the water pump had to pump the water at the right pressure. This was solved by adjusting the code and the components until the system worked correctly.

Conclusion:

In conclusion, the fire extinguishing and gas sensing car using Arduino is a useful device that can prevent fires and detect gas leaks. The car is powered by an Arduino Uno microcontroller and uses sensors, motors, and other components to perform its functions. The car was designed and built with the help of a schematic, and was tested successfully. The challenges encountered during the construction were solved by adjusting the code and the components. The car can be further improved by adding more sensors and refining the code as the SMS functionality was still flaky.

You might be wondering how I know that you're awesome!
Because I know you read this via RSS.