Skip to content

XceptN’s Tech Stuff

All About Tech

Typing a Timestamp With One Shortcut on Ubuntu 24.04 Wayland

Posted on August 27, 2026November 19, 2026 By XceptN No Comments on Typing a Timestamp With One Shortcut on Ubuntu 24.04 Wayland

Update, November 2026: I set this up again on Ubuntu 26.04 with GNOME 50, and the layout fix in step 6 does NOT work there anymore. Everything else carried over as is. The GNOME 50 version is at the end of the post.

I have been typing timestamps by hand for years now. File names, notes in a scratch buffer, markers in a log I keep while working on a server.. always the same little finger dance. Last week I decided this is silly and that Ctrl+Super+T should simply type it for me. It sounded like a five minute job.

It was NOT a five minute job. My box is Ubuntu 24.04.4 LTS with GNOME Shell 46.0 on Wayland, kernel 6.14.0-34-generic. Almost every recipe you find for this is written for X11, and on Wayland those recipes do exactly nothing. That is when I started digging, and the digging turned out to be rather more interesting than the feature itself.

Know what you are actually running

First check the session type. Half of the advice you will find online assumes the wrong one, and that is exactly where the wasted evenings begin.

$ echo $XDG_SESSION_TYPE
wayland
$ gnome-shell --version
GNOME Shell 46.0
$ gsettings get org.gnome.desktop.input-sources sources
[('xkb', 'us'), ('xkb', 'tr')]

I keep both a US and a Turkish layout, and that second line will matter a lot later. Note it down if you also switch layouts, it bites in a very sneaky way.

Why the usual tools are dead here

I reached for xdotool first, purely out of habit. It is an X11 tool and it cannot talk to a Wayland compositor at all. wtype is the Wayland answer, but it needs the zwp_virtual_keyboard_manager_v1 protocol, and Mutter does not implement that. So on GNOME it fails as well.

That leaves the kernel. The uinput device lets you create a virtual input device and feed it key events. The compositor cannot tell it apart from a real keyboard, which is exactly what we want. It is a bit low level, but it is the only door that is actually open.

I tried ydotool next, since it is the usual wrapper around uinput. On Noble it is version 0.1.8-3build1 and the package ships only /usr/bin/ydotool, no daemon at all. Its type command works fine. Unfortunately, its key command returns exit code 0 while injecting absolutely nothing, which cost me a good half hour of confusion. I ended up dropping it and writing the uinput calls myself.

1. Give yourself access to /dev/uinput

By default the device is locked down tight:

$ ls -l /dev/uinput
crw------- 1 root root 10, 223 Aug 27 09:10 /dev/uinput

Create /etc/udev/rules.d/60-uinput-uaccess.rules:

KERNEL=="uinput", SUBSYSTEM=="misc", OPTIONS+="static_node=uinput", TAG+="uaccess", \
  RUN+="/usr/bin/setfacl -m u:YOURUSER:rw /dev/uinput"

Then reload and trigger it:

sudo udevadm control --reload-rules
sudo udevadm trigger --sysname-match=uinput

I put both mechanisms in that rule on purpose. The uaccess tag is the clean way to hand a device to the logged-in seat user. Still, /dev/uinput is a static node, and I do not fully trust seat ACLs to be re-applied on those at every boot. The explicit setfacl line makes it certain.

I got a nice surprise on this kernel. Here uinput is compiled in and not a module at all:

$ sudo modprobe -r uinput
modprobe: FATAL: Module uinput is builtin.

So there is no modules-load.d file needed. I had added one and then removed it again (Silly me!).

Please resist the temptation to just add yourself to the input group. That grants READ access to every input device on the machine, which means any process running as you can quietly log your keystrokes. Writing to uinput does not need that at all.

2. Bind the shortcut in GNOME

I set the binding from the command line, since I was scripting the rest anyway. GNOME custom shortcuts live in a relocatable schema, so the commands look a bit ugly.

BASE=org.gnome.settings-daemon.plugins.media-keys
KEY=/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/timestamp/

gsettings set $BASE custom-keybindings "['$KEY']"
gsettings set $BASE.custom-keybinding:$KEY name 'Type timestamp'
gsettings set $BASE.custom-keybinding:$KEY command "$HOME/.local/bin/type-timestamp"
gsettings set $BASE.custom-keybinding:$KEY binding '<Control><Super>t'

If you already have custom shortcuts, append to that list instead of replacing it, otherwise you will wipe the ones you had. I lost my flameshot binding once this way and it took me a minute to work out what I had done.

3. The first version, and the mayhem

My first script waited 350 ms and then typed. I pressed the shortcut, and my desktop went completely mad. Windows jumped around, Firefox launched twice, and almost nothing was typed anywhere.

The journal explained it immediately:

$ journalctl --user -b | grep gsd-media-keys
Started app-gnome-firefox_firefox-62080.scope - Application launched by gsd-media-keys.

Here is the thing. When the shortcut fires, you are still physically holding Ctrl and Super. GNOME binds Super+1 through Super+9 to switch-to-application-1..9. My timestamp is mostly digits. So every digit became an application switch, and the ones that were not bound arrived as control characters. The shortcut was launching my dock, not typing text.

4. Injecting a release does not work

My next idea felt clever. Just inject key-UP events for Ctrl and Super first, then type. I wrote it, and the result was only slightly less broken.

I typed plain letters instead of digits, to see clearly what was happening. Letters make the modifier state obvious in a way that digits really do not. With Ctrl held, abcdef came out as:

^[^A^[^B

That is Ctrl+A and Ctrl+B. So Mutter had happily ignored my injected release and kept the modifier latched, because the REAL key was still down. This is the single most important thing I learned in the whole exercise. You cannot talk a compositor out of a modifier that is physically held.

Once that sank in, the conclusion was obvious. There is no delay value that is correct, because the delay is a guess about a human finger. The script has to wait for the actual release.

5. Wait for the real release

To know when the keys are up you have to read the keyboard devices, and that needs root. I did not want a permanent read ACL on my keyboard, so I put that one check in a tiny root helper instead.

Save this as /usr/local/bin/type-timestamp-modwait, owned by root, mode 0755:

#!/usr/bin/env python3
import fcntl, glob, os, time

KEY_MAX = 0x2ff
NBYTES = (KEY_MAX + 7) // 8
EVIOCGKEY = (2 << 30) | (NBYTES << 16) | (0x45 << 8) | 0x18
EVIOCGBIT_KEY = (2 << 30) | (NBYTES << 16) | (0x45 << 8) | 0x21
MODS = [29, 97, 125, 126, 56, 100]   # l/r ctrl, l/r meta, l/r alt

def down(buf, code):
    return bool(buf[code // 8] & (1 << (code % 8)))

def keyboards():
    out = []
    for path in sorted(glob.glob('/dev/input/event*')):
        try:
            fd = os.open(path, os.O_RDONLY | os.O_NONBLOCK)
        except OSError:
            continue
        buf = bytearray(NBYTES)
        try:
            fcntl.ioctl(fd, EVIOCGBIT_KEY, buf)
            if down(buf, 30) and down(buf, 31):   # reports A and S, so a keyboard
                out.append(fd)
                continue
        except OSError:
            pass
        os.close(fd)
    return out

def mods_down(fds):
    for fd in fds:
        buf = bytearray(NBYTES)
        try:
            fcntl.ioctl(fd, EVIOCGKEY, buf)
        except OSError:
            continue
        if any(down(buf, c) for c in MODS):
            return True
    return False

fds = keyboards()
deadline = time.time() + 5.0
while time.time() < deadline:
    if not mods_down(fds):
        time.sleep(0.05)
        if not mods_down(fds):
            break
    time.sleep(0.02)

I like this one because it is cheap. The EVIOCGKEY ioctl asks the kernel for the current pressed-key bitmap, and that is a state query rather than an event stream.

I call it with sudo -n from the main script. On my laptop I already have passwordless sudo, so this adds no privilege I did not have. If that is not true for you, add a single NOPASSWD line for this one binary and nothing else.

6. The layout trap

Now the sneaky part I promised. uinput sends raw KEYCODES, not characters. What you get on screen depends on the XKB layout that is active at that moment.

My timestamp contains -, which is KEY_MINUS. On the US layout that is a hyphen. On the Turkish Q layout the same physical key gives you *. So the very same code produced 20260828*110502e0300 when my tr layout happened to be active. Very confusing until you realise what is going on.

The fix is small (might sound dumb but it is practical). Switch to us layout, type, then switch back:

gsettings set org.gnome.desktop.input-sources current 0

I was quite pleased that this key is writable and that GNOME really does follow it. The whole detour lasts a couple hundred milliseconds, and I have never once noticed it while using the shortcut.

(Unfortunately, GNOME 50 ignores this key completely. If you are on a newer release, read the update at the end before copying this part.)

7. The script itself

I keep the main script in ~/.local/bin and it runs as my normal user. It waits, forces the layout, opens uinput, sends the key events, restores the layout and writes a one line log.

#!/usr/bin/env python3
import fcntl, os, re, struct, subprocess, time

UI_SET_EVBIT, UI_SET_KEYBIT = 0x40045564, 0x40045565
UI_DEV_CREATE, UI_DEV_DESTROY = 0x5501, 0x5502
EV_KEY, EV_SYN = 0x01, 0x00
SCHEMA = 'org.gnome.desktop.input-sources'

CHARS = {'0': 11, '1': 2, '2': 3, '3': 4, '4': 5, '5': 6,
         '6': 7, '7': 8, '8': 9, '9': 10, '-': 12,
         'e': 18, 'w': 17}

def gset(*a):
    return subprocess.run(['/usr/bin/gsettings', *a],
                          capture_output=True, text=True).stdout.strip()

def emit(fd, t, c, v):
    os.write(fd, struct.pack('llHHi', 0, 0, t, c, v))

def type_text(text):
    fd = os.open('/dev/uinput', os.O_WRONLY | os.O_NONBLOCK)
    try:
        fcntl.ioctl(fd, UI_SET_EVBIT, EV_KEY)
        for kc in range(1, 256):
            fcntl.ioctl(fd, UI_SET_KEYBIT, kc)
        os.write(fd, b'type-timestamp'.ljust(80, b'\0')
                 + struct.pack('HHHH', 3, 0x1d1d, 0x0001, 1)
                 + struct.pack('I', 0) + b'\0' * (64 * 4 * 4))
        fcntl.ioctl(fd, UI_DEV_CREATE)
        time.sleep(0.25)              # let the compositor attach the device
        for ch in text:
            emit(fd, EV_KEY, CHARS[ch], 1); emit(fd, EV_SYN, 0, 0)
            emit(fd, EV_KEY, CHARS[ch], 0); emit(fd, EV_SYN, 0, 0)
            time.sleep(0.012)
        time.sleep(0.05)
    finally:
        fcntl.ioctl(fd, UI_DEV_DESTROY)
        os.close(fd)

subprocess.run(['/usr/bin/sudo', '-n', '/usr/local/bin/type-timestamp-modwait'],
               capture_output=True, timeout=10)

stamp = subprocess.run(['/usr/bin/date', '+%Y%m%d-%H%M%S%z'], capture_output=True,
                       text=True, check=True).stdout.strip()

# Only the trailing +HHMM / -HHMM sign turns into a letter. The date part has
# its own '-' separator and it must survive untouched.
text = re.sub(r'([+-])(\d{4})$',
              lambda m: ('e' if m.group(1) == '+' else 'w') + m.group(2), stamp)

layouts = re.findall(r"'([^',]+)'\)", gset('get', SCHEMA, 'sources'))
cur = gset('get', SCHEMA, 'current').split()[-1]
us = str(layouts.index('us')) if 'us' in layouts else None
switched = us is not None and cur != us

if switched:
    gset('set', SCHEMA, 'current', us)
    time.sleep(0.2)
try:
    type_text(text)
finally:
    if switched:
        time.sleep(0.1)
        gset('set', SCHEMA, 'current', cur)

I started with date -Iseconds, which gives 2026-08-27T10:17:34+03:00. After using it for a while I got annoyed, because : and + are useless in file names and in quite a few other places (like docker image tags). So I moved to date +%Y%m%d-%H%M%S%z and replaced the + with a -. Sorts nicely, works anywhere.

Still, that was not right either. A - sign in front of the offset is fine in Istanbul, but it becomes a lie the moment I travel west, because -0700 and a converted +0700 look exactly the same. I now spell the direction out as a letter instead, e for east of Greenwich and w for west. So Türkiye gives me 20260828-110502e0300 and New York gives me 20260828-040508w0400. It reads a bit odd for the first day, then it just makes sense.

One detail matters in that substitution. The date part already contains a - separator, so you cannot simply replace every - in the string. Anchor the regex to the trailing ([+-])(\d{4})$ and only the offset sign is touched.

I mapped only digits, the hyphen and the two direction letters in the character table. If the format ever grows a character I have not mapped, the script stops with an error instead of typing something wrong. I prefer a loud failure here.

8. Test it properly, not by feel

I did not trust any of this until I could watch the characters land somewhere I control. My little harness opens a terminal running cat into a file, with the line discipline turned off so nothing is buffered:

kitty sh -c 'echo $$ > /tmp/sink.pid; stty -icanon min 1; cat > /tmp/sink.txt'

(Note that I LOVE Kitty terminal)

Then a second uinput device holds Ctrl and Super down for a couple of seconds, exactly like a slow finger would, while the script runs. Reading /tmp/sink.txt afterwards tells you the truth. I ran it five times in a row and got five clean timestamps, which is when I finally believed it.

A warning from that same afternoon. Do not clean up those test terminals with pkill -f claude-sink or similar. The pattern also matches the shell that is running the very command, so you kill yourself and get a confusing exit code 144. Write the PID to a file and kill that instead, as above.

Step for future:

I left one rough edge in here. The helper gives up after five seconds and types anyway, so if you hold the keys down longer than that you get the mayhem of applications switching, opening and so on. I log the wait result to ~/.cache/type-timestamp.log, so I can see it when something looks odd. In practice I have never hit that timeout, since nobody holds a shortcut for five seconds on purpose.

Update for GNOME 50 (November 2026)

Recently I moved to a new workstation, Ubuntu 26.04.1 LTS with GNOME Shell 50.1 on Wayland and kernel 7.0.0-43-generic. Same two layouts, us and tr. I expected to copy the files over and be done in ten minutes. You can probably guess how that went..

Steps 1 to 5 worked as they are. uinput is built into this kernel as well, so again no modules-load.d file. The trouble was step 6, the layout trap.

The current key is dead

My first run under tr looked perfect, and that was exactly the problem. I had set current to 1 to simulate tr, and minus still typed a hyphen.. the layout had never moved. Then I switched to tr for real with Ctrl+Space. Minus gave * as expected, while current kept saying 0:

# tr is active, switched with Ctrl+Space a second ago
$ gsettings get org.gnome.desktop.input-sources current
uint32 0
$ gsettings get org.gnome.desktop.input-sources mru-sources
[('xkb', 'tr'), ('xkb', 'us')]

So GNOME 50 neither follows that key nor updates it. I wanted to see it with my own eyes, so I pulled the shell’s JavaScript out of its resource bundle (the number in the library name changes between releases):

$ gresource extract /usr/lib/gnome-shell/libshell-18.so \
    /org/gnome/shell/ui/status/keyboard.js | grep 'changed::'
        this._settings.connect(`changed::${this._KEY_INPUT_SOURCES}`, this._emitInputSourcesChanged.bind(this));
        this._settings.connect(`changed::${this._KEY_KEYBOARD_OPTIONS}`, this._emitKeyboardOptionsChanged.bind(this));
        this._settings.connect(`changed::${this._KEY_KEYBOARD_MODEL}`, this._emitKeyboardModelChanged.bind(this));
        this._settings.connect(`changed::${this._KEY_PER_WINDOW}`, this._emitPerWindowChanged.bind(this));

That is sources, xkb-options, xkb-model and per-window, and nothing else. current is not there at all. I suspect it got dropped somewhere between 46 and 50, though I did not go hunting for the exact commit.

mru-sources tells the truth

Still, the same file had the answer. Every time you switch layouts, the shell writes its most-recently-used list back to mru-sources, and the first entry is the active layout. You can see it in the output above. I checked it in both directions and it followed every single switch.

So I stopped switching layouts altogether. The script now reads the active layout and picks the keycodes for it. On Turkish Q the digits, e and w sit exactly where they are on US, and only - moves one key to the right, to KEY_EQUAL (13). /usr/share/X11/xkb/symbols/tr confirms it, <AE12> is minus there.

A nice side effect is that nothing flickers anymore, and there is one moving part less. If the active layout is not in the table, the script stops with an error instead of typing garbage. Add your own layouts to LAYOUT_OVERRIDES after checking their symbols file.

The full GNOME 50 script

This version replaces the one in step 7. It also has the logging I mention under “Step for future”, which I had left out of the listing above (Silly me!).

#!/usr/bin/env python3
# Types a timestamp like 20261119-204501e0300 into the focused window.
# Bound to Ctrl+Super+T in GNOME. Wayland-safe: injects keys through /dev/uinput.
import fcntl, os, re, struct, subprocess, time

UI_SET_EVBIT, UI_SET_KEYBIT = 0x40045564, 0x40045565
UI_DEV_CREATE, UI_DEV_DESTROY = 0x5501, 0x5502
EV_KEY, EV_SYN = 0x01, 0x00
SCHEMA = 'org.gnome.desktop.input-sources'
LOG = os.path.expanduser('~/.cache/type-timestamp.log')

CHARS = {'0': 11, '1': 2, '2': 3, '3': 4, '4': 5, '5': 6,
         '6': 7, '7': 8, '8': 9, '9': 10, '-': 12,
         'e': 18, 'w': 17}

# uinput sends keycodes, so what lands depends on the active XKB layout.
# The 24.04 version flipped org.gnome.desktop.input-sources 'current' to us and
# back, but GNOME Shell 50 neither reads nor updates that key. Instead we read
# the active layout from 'mru-sources' (the shell rewrites it on every switch,
# first entry = active) and pick keycodes for that layout.
# Turkish Q: digits, e and w sit where US has them; '-' is on the '=' key.
LAYOUT_OVERRIDES = {'us': {}, 'tr': {'-': 13}}

def gset(*a):
    return subprocess.run(['/usr/bin/gsettings', *a],
                          capture_output=True, text=True).stdout.strip()

def emit(fd, t, c, v):
    os.write(fd, struct.pack('llHHi', 0, 0, t, c, v))

def active_layout():
    for key in ('mru-sources', 'sources'):     # mru empty on a fresh profile
        found = re.findall(r"\('([^']+)', '([^']+)'\)", gset('get', SCHEMA, key))
        if found:
            return found[0][1] if found[0][0] == 'xkb' else ':'.join(found[0])
    return 'us'

def type_text(text, layout):
    if layout not in LAYOUT_OVERRIDES:         # unknown layout -> fail loudly, type nothing
        raise ValueError(f'no keycode table for layout {layout!r}')
    table = {**CHARS, **LAYOUT_OVERRIDES[layout]}
    codes = [table[ch] for ch in text]         # unmapped character -> KeyError, nothing typed
    fd =os.open('/dev/uinput', os.O_WRONLY | os.O_NONBLOCK)
    try:
        fcntl.ioctl(fd, UI_SET_EVBIT, EV_KEY)
        for kc in range(1, 256):
            fcntl.ioctl(fd, UI_SET_KEYBIT, kc)
        os.write(fd, b'type-timestamp'.ljust(80, b'\0')
                 + struct.pack('HHHH', 3, 0x1d1d, 0x0001, 1)
                 + struct.pack('I', 0) + b'\0' * (64 * 4 * 4))
        fcntl.ioctl(fd, UI_DEV_CREATE)
        time.sleep(0.25)              # let the compositor attach the device
        for kc in codes:
            emit(fd, EV_KEY, kc, 1); emit(fd, EV_SYN, 0, 0)
            emit(fd, EV_KEY, kc, 0); emit(fd, EV_SYN, 0, 0)
            time.sleep(0.012)
        time.sleep(0.05)
    finally:
        fcntl.ioctl(fd, UI_DEV_DESTROY)
        os.close(fd)

def log(line):
    try:
        os.makedirs(os.path.dirname(LOG), exist_ok=True)
        with open(LOG, 'a') as f:
            f.write(time.strftime('%Y-%m-%dT%H:%M:%S%z ') + line + '\n')
    except OSError:
        pass

# Wait until Ctrl/Super are physically released (root helper, max 5 s).
try:
    w = subprocess.run(['/usr/bin/sudo', '-n', '/usr/local/bin/type-timestamp-modwait'],
                       capture_output=True, text=True, timeout=10)
    wait = {0: 'released', 3: 'TIMEOUT', 4: 'NO-KEYBOARD'}.get(
        w.returncode, f'ERROR({w.returncode}: {w.stderr.strip()[:80]})')
    wait += f' {w.stdout.strip() or "?"}ms'
except subprocess.TimeoutExpired:
    wait = 'ERROR(helper hung)'

stamp = subprocess.run(['/usr/bin/date', '+%Y%m%d-%H%M%S%z'], capture_output=True,
                       text=True, check=True).stdout.strip()

# Only the trailing +HHMM / -HHMM sign turns into a letter. The date part has
# its own '-' separator and it must survive untouched.
text = re.sub(r'([+-])(\d{4})$',
              lambda m: ('e' if m.group(1) == '+' else 'w') + m.group(2), stamp)

layout = active_layout()

status = 'ok'
try:
    type_text(text, layout)
except Exception as e:
    status = f'FAILED({type(e).__name__}: {e})'
    raise
finally:
    log(f'text={text} wait={wait} layout={layout} {status}')

The helper from step 5 changed only at the end. It now prints the wait in milliseconds and tells the caller whether the keys were really released, so the log can say so. Add sys to its imports and replace the loop at the bottom with this:

start = time.time()
fds = keyboards()
if not fds:
    print(0); sys.exit(4)
deadline = start + 5.0
released = False
while time.time() < deadline:
    if not mods_down(fds):
        time.sleep(0.05)
        if not mods_down(fds):
            released = True
            break
    time.sleep(0.02)
print(int((time.time() - start) * 1000))
sys.exit(0 if released else 3)

Alt, Super and my own keyboard

One more trap, and this one was entirely mine. My test harness from step 8 pressed Ctrl+Super+T through a second uinput device, and nothing happened. Not the shortcut, not even a throwaway binding that only touched a file. I added three probe bindings, Ctrl+Super+Y, Ctrl+Alt+Y and Super+Y, and the result was rather funny. Injecting Ctrl+Win fired the Ctrl+Alt binding, and injecting Ctrl+Alt fired the Ctrl+Super one.

That is when I checked my XKB options:

$ gsettings get org.gnome.desktop.input-sources xkb-options
['altwin:swap_lalt_lwin']

On this laptop I swap the left Alt and Win keys, so the key I press for Super sends KEY_LEFTALT (56), not KEY_LEFTMETA (125). The modwait helper did not care, since it watches both Alt and Meta codes anyway. The harness cared a lot. Inject the keycodes your fingers actually produce, not the names printed on the keycaps.

A safer test harness

I also made the harness a bit safer. GNOME 50 will not tell other processes which window has focus (Introspect.GetWindows answers AccessDenied and Eval just returns false), so a careless test can type into the wrong window. My beloved Kitty knows its own focus state, though:

kitty -o allow_remote_control=yes --listen-on unix:/tmp/sink.sock \
  sh -c 'echo $$ > /tmp/sink.pid; stty -icanon min 1; cat > /tmp/sink.txt'

kitty @ --to unix:/tmp/sink.sock ls | python3 -c \
  "import json,sys; print(json.load(sys.stdin)[0]['is_focused'])"

I check is_focused before every injection and abort when it says False. It saved me once already, when a stray key combination stole the focus in the middle of a test.

Result

With all that in place I ran the real shortcut five times, three on us and two on tr, four of them with the modifiers held for 1.5 seconds. Five clean timestamps, and the log shows the helper doing its job:

$ tail -3 ~/.cache/type-timestamp.log
2026-11-19T20:46:31+0300 text=20261119-204631e0300 wait=released 232ms layout=us ok
2026-11-19T20:46:37+0300 text=20261119-204636e0300 wait=released 1596ms layout=tr ok
2026-11-19T20:46:41+0300 text=20261119-204641e0300 wait=released 1601ms layout=tr ok

Faking New York with TZ=America/New_York gave 20261119-124653w0500, so the west side works as well. I have not tried this version on GNOME 46. It should work there too, since mru-sources is quite old, but I did not prove it.

This was a lot of work for something that types twenty characters. Still, I use it many times a day now, and I learned more about Mutter and uinput than I expected to. My beloved little shortcut earns its keep.

Do you have a neater way to do this on GNOME 46? Tell me all about it in the comments..

Hope that helps.. Take care..

kernel, keyboard, linux Tags:gnome, gnome-46, keyboard, linux, ubuntu, uinput, wayland

Post navigation

Previous Post: Analyzing Memory Usage on Linux 6.19
Next Post: Monitoring Govee H5074 Hygrometers with a Raspberry Pi, Prometheus and Grafana

Related Posts

udev: what, why, how? linux
gawk – use semicolon as delimiter linux
Enabling “real-time-protection” with ClamAV on Ubuntu 24.04 Desktop for Palo Alto Networks Global Protect (PanGP) VPN desktop
A Baby Named “Linux”!! kernel
Building Binaries from Sources development
Two Generations of Computing Equipment… blogging

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Recent Posts

  • Monitoring Govee H5074 Hygrometers with a Raspberry Pi, Prometheus and Grafana
  • Typing a Timestamp With One Shortcut on Ubuntu 24.04 Wayland
  • Analyzing Memory Usage on Linux 6.19
  • Enabling “real-time-protection” with ClamAV on Ubuntu 24.04 Desktop for Palo Alto Networks Global Protect (PanGP) VPN
  • Dipping Toes into Nix Package Manager | Installing Freeplane

Recent Comments

  1. r0cky on Fujitsu LIFEBOOK UH572 Ultrabook Touch Pad Review: Linux
  2. XceptN on Fujitsu LIFEBOOK UH572 Ultrabook Touch Pad Review: Linux
  3. r0cky on Fujitsu LIFEBOOK UH572 Ultrabook Touch Pad Review: Linux
  4. Kaylee on Mounting an LVM Logical Volume in an Oracle VM Disk Image
  5. Theron Conrey on Open Source Virtualization for Smaller Carbon Footprint

Archives

  • October 2026
  • August 2026
  • April 2026
  • September 2025
  • June 2024
  • November 2014
  • October 2014
  • April 2014
  • March 2014
  • December 2012
  • November 2012
  • October 2010
  • April 2010
  • April 2009
  • March 2009
  • February 2009
  • January 2009
  • December 2008
  • November 2008
  • October 2008
  • September 2008

Categories

  • blogging
  • communication
  • desktop
  • development
  • firmware
  • Fujitsu
  • gprs
  • gps
  • hardware
  • internet
  • java
  • kernel
  • keyboard
  • linux
  • masteryourbiz
  • mms
  • mobile
  • multimedia
  • network
  • OracleVM
  • palm
  • python
  • rokr e6
  • social media networking
  • storage
  • sysadm
  • tablet
  • twitter
  • virtualization
  • wap
  • windows
  • wordpress
  • xen

Copyright © 2026 XceptN’s Tech Stuff.

Powered by PressBook Masonry Dark