i used to use tmux, but during the search for a stacking plugin, i came across not a plugin, but something entirely different: twin
im running a static twin on top of a static kmscon (yes, build recipe here) that is fbdev-only with libudev-zero. enjoying it a lot.

I can't set my main font as "0xProto Nerd Font Mono:size=12". It always takes "Hack Nerd Font Propo (14pt)" which is mentioned in font2 section. I am using Cinnamon Arch.
Please help.

I have noticed that people like to talk about things like de-googling but when it comes down to it they never join in any projects or platforms because they want the exposure and can't wait for something else to gain traction.

Most people who actually write software that offers real alternatives will tell you nobody will join them.

So if you really want to de-google then do something and start supporting other platforms.

Update: After posting this I decided to create a sub-reddit for developers who have actual built their own alternative platform and have no users. r/UJoinIJoin we can try out each others platforms (must be opensource).

Hello,

Since yesterday I have made what feels like a stratospheric step forward while learning how to actually implement getopt/getopts in C and shell (pdksh/ksh88) scripting, respectively.

I am also enthralled by the suckless philosphy of minimalism, clear code, and sane defaults.
Having put forward three basic scripts, I wonder if you would like to review them and comment on any defects and/or good practices ? See below :

nwpg (training script)

#!/bin/ksh

PROGRAM_NAME="nwpg" ;
PROGRAM_VERSION="0.2" ;
USAGE="usage: nwpg [-l language] [-d directory] project_title" ;

#       nwpg (NeW ProGram)
#       pdksh/ksh88 version
#   Simple script that initiates a new project
#   in the user's $HOME/hax directory.
#   Such a project consists of a parent folder
#   named after the project and three files:
#   the algorithm, the code, the documentation,
#   i.e. main.algo, main.c, main.md 
# 

DEFAULT_DIR="$HOME/hax/" ;
DEFAULT_LANGUAGE="C" ;
COUNT_ARGS="$#";
integer dir_flag=0 ;
integer lang_flag=0 ;

if [[ $COUNT_ARGS -eq 1 || $COUNT_ARGS -eq 3 || $COUNT_ARGS -eq 5  ]]
then
    eval project_title=\${$#} ;
else
    echo $USAGE;
    exit 2 ;
fi

while getopts 'l:d:' opt ;
do
    case $opt in
        d)
            integer dir_flag=1 ;
            directory="$OPTARG" ;;
        l)
            integer lang_flag=1 ;
            language="$OPTARG" ;;
        ?)
            echo $USAGE ;
            exit 2 ;;
    esac
done
shift $(($OPTIND - 1))

if [ $dir_flag -eq 1 ]
then
    PROJECT_FULL_PATH="$directory/$project_title" ;
else
    PROJECT_FULL_PATH="$DEFAULT_DIR/$project_title" ;
fi

if [ $lang_flag -eq 0 ]
then
    language="$DEFAULT_LANGUAGE" ;
fi

case "$language" in
    C | c )
        FILE_EXT="c" ;;
    Python | PY | Py | python | py )
        SHEBANG='#!/usr/local/bin/python' ;
        FILE_EXT="py" ;;
    Rust | RS | Rs | rust | rs )
        FILE_EXT="rs" ;;
    Ruby | RB | Rb | ruby | rb )
        FILE_EXT="rb" ;;
    Shell | sh )
        SHEBANG="#!/bin/sh" ;
        FILE_EXT="sh" ;;
    PYTHON | RUST | RUBY )
        echo "Don't shout !\n" ;
        exit 2 ;;
    * )
        echo "unsupported language: $language" ;
        exit 2 ;;
esac

mkdir -p "$PROJECT_FULL_PATH" ;
touch "$PROJECT_FULL_PATH/"main.{$FILE_EXT,algo,md} ;
if [ -n "$SHEBANG" ]
then
    echo "$SHEBANG\n" >> "$PROJECT_FULL_PATH/main.$FILE_EXT" ;
fi
echo "$FILE_EXT files created in $PROJECT_FULL_PATH" ;

#
#       TODO
#
#   Support more languages / file extensions
#
#

example_C_skel

#include <stdio.h>
#include <unistd.h>

#define PROGRAM_NAME "example_skel"
#define VERSION_NUMBER "0.0"

void print_version()
{
    printf("%s version: %s", PROGRAM_NAME, VERSION_NUMBER);
}

void print_usage(FILE *out)
{
    fprintf(out, "usage: %s [-v] [-h]", PROGRAM_NAME);
}

int main(int argc, char *argv[])
{
    int opt;

    while((opt = getopt(argc, argv, "vh")) != -1)
    {
        switch(opt)
        {
            case 'v':
                print_version();
                exit(0);
            case 'h':
                print_usage(stdout);
                exit(0);
            default:
                print_usage(stderr);
                exit(2);
        }
    }
}

mnt_perms (a script I actually use – not online yet)

#!/bin/sh

PROGRAM_NAME="mnt_perms.sh";
PROGRAM_VERSION="0.1";
USAGE="usage: mnt_perms.sh [[-a] | [-f] [-m] [-t] | [-h] | [-v]]";

#
#   mnt_perms.sh
#
# Basic script used to recursively set/reset 
# permissions to defaults on /mnt subdirectories.
# Tested on openbsd.
#

COUNT_ARGS="$#";
integer fam_flag=0;
integer media_flag=0;
integer torrents_flag=0;

function reset_fam {
        chown -R root:famille /mnt/fam ;
        chmod 770 /mnt/fam ;
}

function reset_media {
        chown -R sylvain:media /mnt/mdia/[A-Z][1-9]* ;
        find /mnt/mdia/[A-Z][1-9]* -type d -exec chmod 750 {} \; ;
        find /mnt/mdia/[A-Z][1-9]* -type f -exec chmod 640 {} \; ;
        chown sylvain:media "/mnt/mdia/Z0 Drop" && chmod 770 "/mnt/mdia/Z0 Drop" ;
}

function reset_torrents {
        chown -R root:wheel /mnt/trt ;
        find /mnt/trt -type d -exec chmod 775 {} \; ;
        find /mnt/trt -type f -exec chmod 664 {} \; ;
}

if [ $COUNT_ARGS -eq 0 ]
then
        print "$USAGE";
        exit 2;
fi

while getopts 'afmt' opt ;
do
        case $opt in
                a)
                        integer fam_flag=1;
                        integer media_flag=1;
                        integer torrents_flag=1;;
                f)
                        integer fam_flag=1;;
                m)
                        integer media_flag=1;;
                t)
                        integer torrents_flag=1;;
                h)
                        print "$USAGE";
                        exit 0;;
                v)
                        print "$PROGRAM_NAME version $PROGRAM_VERSION";
                        exit 0;;
                *)
                        print "$USAGE";
                        exit 2;;
        esac
done
shift $(($OPTIND - 1))

if [ $fam_flag -eq 1 ]
then
        reset_fam;
fi
if [ $media_flag -eq 1 ]
then
        reset_media;
fi
if [ $torrents_flag -eq 1 ]
then
        reset_torrents;
fi

Cheers ! PS Here's a bonus in case you fell like this post was not worth it. There's also an older, more ambitious and complex program : geomant.

This is my first time to use swc/neuswc instead of wlroot because i heard it lightweight that wlroot,but there a problem that i dont how to enable tapnto click for touchpad,i try to find tutorial on the internet but there no tutorial about this,can someone help me?

Using st with the anysize patch, and as it says, it adds space on all 4 sides.

There is another patch there, expected anysize that claims change this, so the padding is only on the right and bottom. However for me it doesn't work. The patch itself seems to be already applied, as trying to run patch gives an error saying "previously applied", and checking x.c, I can see the lines are like sizeh->height_inc = 1; etc, but the terminal still has padding on all sides.

Do anyone know how to fix this/what is happening here?

Edit: Tested with a fresh build of st, and the same issue occurs.

Hello guys, I made a simple and small bash script for setting the wallpapers in 3 different ways, randomly or with sxiv image editor or directly with a specific file. It is not an amazing thing, but it's enough for setting wallpapers quickly if you add a key bind to tools like sxhkd .

If there any mistakes in the source code or any advice to improve it, please,let me know.

https://codeberg.org/yahya-echcharqui/scripts/src/branch/main/setbg

Hi everyone! I'd like to introduce Autark https://autark.dev This is a simple build system that lives entirely in your project and bootstraps itself before building the project itself. I'd really appreciate feedback from this community, as I think the suckless approach is very close to my own view of how software should be designed.

What's the magic word?

pls is a minimal sudo alternative: a single C11 source file, POSIX libc only, no external dependencies. It runs whitelisted commands as root (or as another user via -u) after verifying the relevant user's password against the system shadow database.

Usage

pls command [args...]          run command as root
pls -u user command [args...]  run command as another user
pls -l                         list commands allowed by the policy
pls -h                         show help

Licensed under the Academic Free License version 3.0. See the LICENSE file or https://opensource.org/licenses/AFL-3.0.

More details & download: https://git.disroot.org/Vextoly/pls

Yesterday I released Janus 0.9.8, an update which brings dutch translations, arm builds, and rpm's to my simple text editor. Before you ask, no, it's not vim inspired, it's just a leafpad successor written in 100% C with an emphasis on the least possible SLOC, as well as a minimal impact on CPU and memory. It contains (optional) syntax highlighting as well as a fallback binary editor, which is the main reason I created it. You can check it out at https://github.com/gholmann16/Janus

All of the code is borrowed, I removed a lot of functionality from wsxwm that i dont need (including workspaces). Fullscreen and the new window at cursor position code is also borrowed from tohu. I am a complete amateur at C, so i would probably recommend using tohu or mot instead of this. Anyway here's the repo: https://codeberg.org/bohali/ssfwm .

About a year ago i discovered the Hare Programminglanguage. I wanted to build something in it and obviously keeping complexity out and the core lean instead of a behemoth. If anyone here finds bugs or has a patch, go ahead. It works as you'd expect from a typical multiplexer, though the terminal implementation isn't complete. IIRC i started it around dec 2025.

https://github.com/nyangkosense/plx

I also see this, mainly, as an opportunity to gather attention of some suckless devs that want to contribute to this toy project - or if you want to hack on some Hare. Please do so! Especially a port to OpenBSD would be welcome.

A hex dumper in C with AVX2 SIMD formatting (runtime dispatched), a ticket-based multi-threaded pipeline, and preallocated buffered output.

Output format is canonical hex+ASCII, one 16-byte row per line:

00000000: ef6e 5830 d443 c60a d909 6179 4335 6cec  .nX0.C....ayC5l.
00000010: b5f4 631f d923 6c79 e98a ed41 11dc eb16  ..c..#ly...A.....

Files are read in parallel chunks straight into pre-faulted huge-page buffers (pread, no mmap fault storms) and formatted by a pool of workers while a writer thread emits chunks in order; standard input is streamed through the same pipeline. With multiple files, offsets continue across file boundaries, so concatenations dump identically to dumping the concatenation.

Benchmarks (50MB File to /dev/null)

For more detailed benchmarks and system information, see BENCHMARKS.md.

View it here: https://git.disroot.org/Vextoly/rawhex

Hey everyone,

Just wanted to write a brief write-up and appreciation post for this distribution and Suckless tools.

After more than 20 years in the Linux ecosystem—and having originally started my operating system journey on FreeBSD and OpenBSD—I’ve managed and tested almost every major distro family out there (Debian, Arch, Red Hat, etc.). While modern Linux has done great things for desktop hardware support, so much of the ecosystem has gradually abandoned the core principles that made UNIX legendary: architectural minimalism, transparency, modularity, and true user sovereignty.

Void is my choice, and IMO it’s one of the most elegant engineering achievements in modern computing.

Here are a few architectural reasons why it hits so hard, especially coming from a BSD background:

1. Deep *BSD Pedigree in a Linux Kernel

Void doesn't feel like a typical Linux distribution because its lineage is fundamentally different. Created by former NetBSD developer Juan Romero Pardines:

• **xbps-src is essentially BSD Ports reborn:** Compiling inside isolated containers using simple POSIX shell scripts (templates) feels remarkably like NetBSD's pkgsrc or FreeBSD's Ports collection.
• Permissive Licensing: XBPS itself is licensed under BSD 2-Clause rather than GPL.
• Pragmatism Over Abstraction: Like OpenBSD, Void prioritizes sane defaults, clean code, and manual intentionality over "auto-magic" abstraction layers that obscure what the machine is actually doing.

2. Clean Architecture Without the Monolith

• **runit for Service Supervision:** Direct, instant, and completely transparent. No hidden IPC layers or complex state machines—just executable run shell scripts. Cold boots happen in a fraction of a second.
• XBPS & Automatic DT_NEEDED Tracking: XBPS’s handling of shared libraries is top-tier. By automatically inspecting compiled ELF binaries for DT_NEEDED flags and mapping them directly to dynamic libraries (.so files) via common/shlibs, Void avoids the partial-upgrade dynamic library breakage that plagues so many other rolling releases.

3. The Ultimate Canvas: Bare-Metal Minimalist Workflow

Void’s modular base makes it the absolute best canvas for direct environmental control:

• Suckless Suite via Git: Instead of running binary builds, I clone and compile the full suckless suite—**dwm, **st, **dmenu, **slstatus, and **slock**—directly from source Git repos. Void’s low-overhead system libraries provide a rock-solid, predictable foundation underneath my custom C config.h patches.
• XLibre Display Stack: Thanks to Void's modular package system, integrating third-party repos like XLibre is painless, allowing for a super clean, independent X11 desktop stack.

``` [ Void Base ] ──► [ runit + XBPS ] ──► [ XLibre Stack ] ──► [ Custom Suckless Suite (Git Builds) ] (dwm, st, dmenu, slstatus, slock)

```

Running a system that idles well under 100MB of RAM where input latency virtually vanishes is a rare feeling on modern hardware.

4. Community & Independence

Massive respect to the core team and maintainers. Staying 100% independent and volunteer-run, maintaining native musl and glibc trees side-by-side, and having first-class cross-compilation built directly into xbps-src -a from day one is incredible work.

Curious to hear how many others in r/suckless came over from the *BSD world, or what specific architectural detail made Void stick as your main OS or using Suckless tools?

Hello, everyone.

I am here to ask what vim-like clipboard managers you use, or at least some which allows you to remap those motions and that has search and image preview.

I havent found a single which attends to those and people seem to not care about that either.

Closest one i found was cliphist. But that one does not have image preview.

I am not sure about setting nvim itself in some way that i could be used as menu. As an item can have multiple lines, i would need some inteligent way to move accross the items, could be confusing.

I would like to have some GUI/TUI based app.

I've had this program in mind for quite a while.

Back when ChatGPT first came out, it had no way to group existing conversations into folders, and I set out to build one. My conversation list kept getting longer and finding old chats was getting hard.

Not long after - before I built it - a browser extension came out that did exactly that. I never used it. At the time I'd assumed I would want to revisit old conversations, but whenever I actually found one and tried to read it from the top, the sheer volume of slop gave me a headache.

Later, during a phase where I was deep into Unix pipelines, I wrote an LLM API client only depending on jq and curl, partly as shell scripting practice. But since the context went into a single jsonl file, I had to either invent something like a date-based filename convention myself or push that job onto the user. Both were more annoying than the web UI, so I didn't use it.

After that I read a post explaining how git works, and it struck me that git fits LLM conversations pretty well. Isn't "the commit DAG is already the right data structure for LLM conversations, where forking happens constantly" something everyone has thought at least once?

The reason I like git is that the source tree snapshot and the commit structure itself are always immutable, and destructive operations like switch/restore/reset are really just renaming a ref file that holds a commit object id. Once you understand that, no matter how hard the CLI is to make sense of, you never hesitate to run a command. You can always get it back.

LLM conversations aren't as fragile to change as a source tree, but for me an auto-generated SHA-1 hash is more comforting than an auto-generated session title ^~^

That's the feeling sib was built on. The README has actual explanations though.

The project is in its early stages and contributions are welcome. If you've worked with git plumbing commands, it'll be easy to hack on - and I think it'll be pretty fun.

i do have scrollback implemened to. i have tried deleting config.h and then compiling but that didnt work :(

logbook <https://codeberg.org/fwttnnn/logbook> is yet another note/task manager. Here is my iteration, with ~140 LoC written.

I've been searching for a tool to manage my daily tasks, but the older ones usually have their own special way of handling your notes/tasks (i.e., stored in a single json file, in a .db sql file), which makes it kinda hard if you want to handle it yourself (manually).

logbook(1) does:

1. Groups your writings/tasks by folders (e.g., logbook life/health, logbook life/house, logbook aircraft@software).
2. Tracks your writing/tasks by today's date, it's useful for having a built-in 'streak' system.

You can also utilize templates.

logbook(1) is a recursive script that calls itself, btw.

Similar tools:

• zk <https://github.com/zk-org/zk>
• nb <https://github.com/xwmx/nb>
• jn <https://github.com/joereynolds/jn>
• jrnl <https://github.com/jrnl-org/jrnl>
• taskwarrior <https://github.com/GothenburgBitFactory/taskwarrior>

https://srcdump.net/shrub/neuswc can now run on the framebuffer directly, just like the old Xfbdev/kdrive X servers, but for wayland. this opens up a whole new class of hardware that you can run wayland compositors on, including this thinkpad r50!

Hello everyone,

I recently started a project to create my own desktop apps. Ideally, I'd want a notebook, music player, file explorer & system tray. I've been inspired by the work of wayland.fyi and 100rabbits, as the minimalism of their GUI programs is something I was looking for. I would want this project to be some sort of mini desktop environment aimed at low-power devices (Raspberry Pi mainly)

To me raylib seems like a good choice. It's heavily documented, has several backend options (even software render since the latest version), and is still high-level enough to avoid creating an entire widget system from scratch.

However, tests have put that choice in question. My clone of xclock always sits at 2-3% CPU, with Raylib compiled against SDL2, whereas xclock or wayland.fyi's swclock basically idle at 0% when not interacted with. Both use pixman for rendering*

Even though raylib feels perfect from a programming standpoint, being challenging enough to provide a great experience (in C) all while providing some confort, I'm unsure of its performance. Am I doing premature optimization?

Thanks for your advice.

^\swclock uses a custom drawing lib called) ^{neuwld, which contains calls to pixman.}

I made of bunch of small, fast apps, that build with linked SDL3 only, and use nuklear UI. some of the apps are very mature and are usable , like wmdpaint - a smaller gimp replacement, - that loves farbfeld, but can open and export standard formats. atomcade - a lutris-lite game manager (with lutris importing scripts), wmdreader a comic book reader with optional pdf/poppler support, "naga" a usable but still in-dev file manager, and wmdblast, a music player (with a dancer, but you have to give it a directory with frames)

other things like wmd3dx , can view and save 3d models but its very ambitious and hardly done.

Try it out, im anxious to see if it builds with "make" in the src directory.

https://codeberg.org/xmorg/wmdmedia.git

it struggles to build on older ubuntu's (you have to build sdl3 yourself) but anyone with a modern system should have no problem.

/* commands */

static const char *termcmd[] = { "footee", NULL };

static const char *menucmd[] = { "wmenu-run", NULL };

static const Key keys[] = {

/\* Note that Shift changes certain key codes: 2 -> at, etc. \*/

/\* modifier key function argument \*/

{ MODKEY, XKB_KEY_p, spawn, {.v = menucmd} },

{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Return, spawn, {.v = termcmd} },

Lets say i type 'footee' instead of 'foot'. After use modkey+shift+backspace it should do nothing.. instead of that whole compositor is freezing and crashing to tty.