ZEKAR's Blog

Why I built my own static site generator

2026-05-24T16:48:45-06:00

Why I built my own static site generator

Since the beginning of this website, I’ve always used some kind of static site generator (SSG). I simply REFUSE to write HTML manually.

Not only that, but each time I write something I would have to update the index with the corresponding date and keep track of everything… Such a pain. That’s why SSG were invented in the first place, I can write a post in a simple markup format (like markdown), and have it converted and structured automatically to HTML.

Using Hugo

Like everyone else, I started out with Hugo, and I really hated it. I started out watching Luke Smith’s tutorials on Hugo (Is it only me that thinks using hugo is completely out of character for Luke Smith?). After a few iterations I started to think it was overly complicated… shortcodes? archetypes? it was too muchy. For me, that felt like the only choice so I stuck with it.

Honestly, I’d much rather use Hugo than a bloated node framework like react or vue… or whatever the hell kids nowadays are using. But still, it’s VERY complex, it has every feature in the world, making it feel bloated. Which is precisely the OPPOSITE of what good software is.

Hugo uses Go templates, which I find unnecessarily hard to read. You need to configure Hugo with a toml file, archetypes, layouts, modules and a lot of things. Just look at the number of directories in the setup I mentioned earlier.

What are archetypes? What are layouts? No idea. I could search for it, but really, I didn’t have the need for that. Features you don’t use have a name: bloat

Using staw

I don’t know why I didn’t search for alternatives earlier. But when I stumbled upon a site that said was “staw powered” (specifically sta.li) and it piqued my interest. It was a minimal static site generator written in go by none other than Anselm R. Garbe, the mind behind suckless.org.

Don’t get me wrong, I think staw is an amazing piece of software. But it didn’t exactly generate what I was looking for. I tried to hack on it for a while but I wasn’t completely satisfied with the result. By the end it was almost unrecognizable (Ship of Theseus ts). I need an RSS/Atom feed to be happy, and a bit more structure in my site. Also… I don’t have multiple sites lol.

The biggest problem I had with staw is that it’s written in Go. Nothing against Go, just that I’m not particularly prolific in it. So I always relied on an LLM to help me out to add and remove features. Undoubtedly, this resulted in a mess of a codebase which made maintaining it kind of a pain. Also, it had a weird template lol.

Creating my own

“If you want it done right, you should just do it yourself”

I thought about making my own static site generator. Why would I? probably a lot of people had already done this and there is a bajillion SSG out there. Surely one does what I want. That’s right, but the main problem would be that I didn’t write it. Sounds narcissistic, I know. But if I wrote the actual program, I would be an expert on how it works, how to add new features and how it works internally.

Take a step back and think for a moment about what does a SSG actually do; transform text. It transforms from Markdown into HTML. And there are already several tools that accomplish this task, notoriously pandoc. I use pandoc for a lot of things (mostly converting markdown to pdf for school work) so I was already familiar on how it worked. Pandoc is “a universal document converter,” so converting Markdown to HTML would be normal work for it.

Pandoc would convert .md files into html. I just need to generate lists for indexes, generate an rss feed with the html content, structure the site. Sounds like a job for a shell script. (Specifically a posix-compliant one)

My requirements were simple enough

Static pages (makes hosting way easier)
Low resource usage (easily accomplished by writing a simple template and simple styling.)
Readable in tools like w3m (Just minimize javascript lol)
RSS/Atom feed (EVERYTHING should provide an RSS feed. Non-negotiable)
A general index with all pages
Subdirectories with their own indexes (for article/post separation)
Dates (my website went way too long without dates)

Most of them are self-explanatory, here are some interesting challenges I solved though.

Feed

You can find the generated feed at atom.xml

What I did was just initialize it with some content and then add every entry for each page. The hardest part was definitely following the very strict standard for a valid atom feed.

cat <<EOF >"$FEED"
<feed xmlns="http://www.w3.org/2005/Atom">
<title>$SITE_TITLE</title>
<link href="$SITE_URL/atom.xml" rel="self" />
<link href="$SITE_URL/" />
<updated>$(date --iso=seconds)</updated>
<author>
<name>$(git config user.name)</name>
</author>
<id>$SITE_URL/</id>
EOF

# This gets executed for each page
append_to_feed() {
    raw_html="$1"
    html_path="$2"
    title="$3"
    date="$4"

    #safe_html=$(xml_escape "$raw_html")
    title=$(printf "%s\n" "$title" | sed 's/&/\&amp;/g; s/</\&lt;/g; s/>/\&gt;/g;')
    safe_html=$(printf "%s\n" "$raw_html" | sed 's/&/\&amp;/g; s/</\&lt;/g; s/>/\&gt;/g;')

    # Append entry to the feed
    cat <<EOF >>"$FEED"
    <entry>
    <title>$title</title>
    <link href="$SITE_URL/$html_path" />
    <id>$SITE_URL/$html_path</id>
    <updated>$date</updated>
    <content type="html">$safe_html</content>
    </entry>
EOF
}

Indexes

I spent a lot of time thinking about how to implement the multiple indexes. My first thought was to, for each index, scan the whole directory for pages, maybe not the best idea, since I will be scanning every file TWICE (for the subdir and the main index).

Then I thought: maybe each subdirectory could maintain its own list and for the main one merge them all. Well, that’s inefficient since I’ll need to sort it for each subdir, then sort it again after merging them. Not ideal. Also, how could I store different lists if I don’t already know how many list I’ll need? temp files? using eval for variable variable names?

I came up with a realization. I can just, for each file I process, add it to the global list, then, when rendering the individual indexes grep for the pattern "href=\"/$dir_name/". This is what I came up with

append_to_list() {
    link_name="$1"
    title="$2"
    date="$3"

    PAGES_LIST="$(
        printf '%s' "$PAGES_LIST"
        printf '%s &mdash; <a href="/%s">%s</a><br/>\n' "$date" "${link_name%.md}.html" "$title"
    )
"
# This newline is important, since subshells don't parse trailing newlines, I can't add it inside the subshell.
# Technically would work without this, but I like pretty HTML if possible.
}

# [...]

for d in "$INPUT"/*/; do
    [ -d "$d" ] || continue
    dir_name=$(basename "$d")
    mkdir -p "$OUTPUT/$dir_name"

    sub_html="$([ -s "$d/index.md" ] && pandoc $PANDOC_FLAGS "$d/index.md" || echo "<h1>$(pretty_name "$dir_name") Index</h1>")"

    sub_list=$(printf '%s\n' "$PAGES_LIST" | grep "href=\"/$dir_name/")

    generate_html \
        "$(printf '%s\n\n%s' "$sub_html" "$sub_list")" \
        "$OUTPUT/$dir_name/index.html" \
        "$(pretty_name "$dir_name") Index" \
        "" 1
done

The final result

If you wanna take a closer look, here’s the code

Usage

You’re EXPECTED to edit the source code, at least for changing the name and URL of your page. If you’re unfamiliar with shell (you should learn!), it’s very intuitive to figure out how to change a couple of variables.

You can have any number of subdirectories (you can nest them if you want, but they won’t appear in the navigation bar). In each subdirectory (and the root), you can add an index.md if you want, it’s not required.

You’re EXPECTED to use git. If you’re not (what are you even doing, man?), the date-generation thingy won’t work (since it uses the date of commits of a specific file to do it)

Any non-markdown files will be copied verbatim (images, documents, stylesheets, etc…)

A template.html is expected in the same directory as the script, with standard html boilerplate

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>{{TITLE}}</title>
    <link href="/style.css" rel="stylesheet">
    <link href="/syntax.css" rel="stylesheet">
</head>
<body>

The script will make sure to close </body> and </html>

Other than that I think everything is pretty self-explanatory

Nix hanging during system rebuild (Solution Included)

2026-01-18T19:51:53-06:00

Nix hanging during system rebuild (Solution Included)

Just a funny story about me and NixOS. To be clear, if you’re looking for a solution for your NixOS, I wouldn’t recommend looking for advice here. The error is so absurd and niche, it’s probably not what you’re looking for.

The error

$ rb # alias of sudo nixos-rebuild switch --flake ...
building the system configuration...
^C

zsh nixos on  main [$!]              took 1h44m36s 
$

Well… actually, there’s no error message. But thanks to starship’s Command Duration module, we can see it took almost two hours… and if I haven’t stopped it manually it’d probably take forever (literally)

No high CPU usage, no high RAM usage, and no high disk usage. Which was the common response on the internet about high rebuild times. So… I didn’t know what to do.

I rolled back to a previous generation and the problem was “solved.” The system could rebuild again! Yay!

But after switching to the new configuration and THEN rebuilding… yeah, the problem wasn’t solved. I tried updating, downgrading, and doing all kinds of shenanigans to my flake.lock. Maybe it was a bad Nix update (I highly doubt they’ll ever release a version of Nix which can’t even rebuild its own system. Probably the most common use of Nix). But no… the problem persisted.

The luckiest error message ever

A few days ago, I was messing around with playerctl, I created some scripts to bind to sxhkd. Yes, not even music listening is free of the ~~blessing~~ curse of shell script automation and hotkey-heavy workflows.

I wanted to show a notification on every song or status change, so I made a little test for that.

#!/bin/sh
#test

playerctl metadata --follow --format "{{status}} {{title}}" | while read -r line; do
    ~/.local/bin/music_status.sh
done

Can you guess how this script was named? Exactly… test. I mean, I was just testing if that worked, so the name made sense in the moment. If you’re familiar with any Unix-based systems, you might be facepalming right now, you see where the error lies.

Ah, the error message, right!

/home/zekar/.local/bin/test: 2: playerctl: not found
/home/zekar/.local/bin/test: 2: playerctl: not found
updating GRUB 2 menu...
activating the configuration...
setting up /etc...
reloading user units for zekar...
restarting sysinit-reactivation.target
the following new units were started: NetworkManager-dispatcher.service
Done. The new configuration is /nix/store/[...]

Luckily, I just recently installed playerctl and the generation I rolled back didn’t have it installed so by PURE LUCK I remembered the test script I made. (The script and rebuilding didn’t even happen around the same time, so… I had no idea they were related!!). If I had playerctl installed from the beginning, I wouldn’t have gotten that error message (like at the top of the post)

Apparently, somewhere during the Nix evaluation, the test binary is called or something like that… Then I asked myself, “Why is it calling my test script???”. Finally, it hit me. THE test COMMAND EXISTS, I WAS PROBABLY OVERRIDING IT!

To be honest, I have no idea how it was able to rebuild if the test command failed so it probably messed some of its conditional logic near the end. I could research it more in depth but probably is not worth it lol.

I changed my script’s name to something else and the problem went away.

Key takeaway: Don’t name your scripts after already existing programs… I mean, it’s obvious, but when its done by accident you don’t even notice (especially, because I almost didn’t remember that test is the same as [, and of course, the use of [ is way more common in scripts and stuff)

Setting Up VimWiki with `when`: My Minimalist Agenda Workflow

2025-05-22T01:40:16-06:00

Setting Up VimWiki with `when`: My Minimalist Agenda Workflow

I haven’t written a blog post in a while, so… yeah, here we are again.

This time, I’m sharing how I’ve set up a minimal personal agenda system using vimwiki and when, a lean calendar application that fits the Unix philosophy—do one thing, and do it well.

⚠️ This isn’t a guide, just me documenting my setup, quirks and all. Nonetheless, read on.

Why `when`?

We’ll be using when instead of something like calcurse. I tried calcurse for a bit but… Meh, its interface isn’t for me. I wanted something simpler, something that plays well with vimwiki.

Directory Layout

Here’s the folder structure for my life/ directory, which I sync via Syncthing:

~/Documents/life/
├── diary/
│   └── 2025-05-21.md
├── calendar/            # Symlinked from $XDG_CONFIG_HOME/when/
│   ├── overrides.wiki
│   └── calendar.wiki
└── scripts/
    └── agenda.sh        # Used to insert `when` output into vimwiki

The goal here is to keep everything related to my notes, schedule, and life in one tidy place. And of course, sync it across devices seamlessly.

Declarative Symlinks with Home Manager

Sure, I could create a symlink manually:

ln -s ~/Documents/life/calendar ~/.config/when

But come on—we’re on NixOS. We don’t do imperative here. Here’s how to make it declarative with home-manager:

{
  home.activation.symlinkWhen = lib.hm.dag.entryAfter [ "writeBoundary" ] ''
    target="$HOME/Documents/life/calendar"
    link="$HOME/.config/when"

    if [ -L "$link" ] || [ -e "$link" ]; then
      rm -rf "$link"
    fi

    ln -s "$target" "$link"
  '';
}

Breakdown

home.activation.symlinkWhen: Custom activation step that runs when you home-manager switch.
lib.hm.dag.entryAfter [ "writeBoundary" ]: Ensures the symlink is created after files are written.
Shell logic:
- Set variables: target="$HOME/Documents/life/calendar" link="$HOME/.config/when"
- If the link (or file) exists, remove it.
- Create the new symlink.

Result: After activation, ~/.config/when is a symlink to your calendar folder.

When Tools Ignore Their Own Man Pages

So, according to when’s man page, config files can live in several places, following the XDG spec:

${WHEN_CONFIG_HOME}/preferences
${XDG_CONFIG_HOME}/when/preferences
$HOME/.config/when/preferences
$HOME/.when/preferences

Great! So I created the file:

touch ~/.config/when/preferences

Then ran:

when

And got this prompt:

You can now set up your calendar. This involves creating a directory ~/.when...

Wait, what?

Maybe it’s because the file is empty? So I went ahead and let when create its stuff the way it wants to:

when
y
nvim

Then moved it manually:

mv ~/.when/* ~/.config/when

Verified contents:

ls ~/.config/when
# calendar  preferences

Tried again:

when
# Still prompts to create ~/.when

Sigh.

Maybe the Environment Variable?

export WHEN_CONFIG_HOME="$HOME/.config/when"
when
# Still no luck

Goodbye XDG

So yeah, despite what the man page says, when doesn’t seem to honor XDG_CONFIG_HOME or WHEN_CONFIG_HOME. Back to messy $HOME we go.

To keep things working, I updated the symlink to point to ~/.when instead:

{
  home.activation.symlinkWhen = lib.hm.dag.entryAfter [ "writeBoundary" ] ''
    target="$HOME/Documents/life/calendar"
    link="$HOME/.when"

    if [ -L "$link" ] || [ -e "$link" ]; then
      rm -rf "$link"
    fi

    ln -s "$target" "$link"
  '';
}

Despite the hiccups, I still love when. It’s minimal, extensible, and scriptable. I just wish its advertised XDG support worked. (If you know a fix—please reach out!)

A Test Event: Does This Actually Work?

Time to see if the setup behaves as expected.

Added this line to calendar:

w=Fri, 12:00 Class with Mr Thompson

Then ran:

when c m

Output:

tomorrow   2025 May 23 12:00 Class with Mr Thompson
Fri        2025 May 30 12:00 Class with Mr Thompson

Perfect.

Integrating `when` with VimWiki

To display this in my vimwiki, I’m adding a == Calendar == section in index.wiki. Then I use a script to inject the output from when.

Here’s the script:

#!/bin/sh

# File to modify
file="../index.wiki"

# Generate calendar output
custom_text="$(when c m)"

# Find line number for '== Calendar =='
line_num=$(grep -n '== Calendar ==' "$file" | cut -d: -f1 | tail -n 1)

if [ -n "$line_num" ]; then
    tmp_file="$(mktemp)"
    head -n "$line_num" "$file" >"$tmp_file"
    echo >>"$tmp_file"
    echo "$custom_text" >>"$tmp_file"
    mv "$tmp_file" "$file"
else
    echo "No line containing '== Calendar ==' found." >&2
    exit 1
fi

After running this, the calendar section in my wiki updates automatically.

Conclusion

That’s it! My little setup for a VimWiki + when calendar integration is complete.

It’s:

Minimal
Scriptable
Easy to sync
Fits into my notes without clutter

I’ll improve it as I go—and if any big changes come, maybe I’ll write a follow-up post.

Btw, being such a simple, useful and underground tool. I might as well do a Rust rewrite. Let’s add it to the TODO list on our VimWiki :::::v

Thoughts after installing KISS Linux

2026-06-10T18:01:12-06:00

Thoughts after installing KISS Linux

I have used NixOS for almost two years. I like that I can safely reinstall and wipe my disks without worrying I might lose important configuration since it’s all in a git repo. However, the uncomfortable truth is that Nix(OS) is extremely complex, both technically and to use.

Of course, Nix is the only real solution to a problem that didn’t need to exist in the first place. (I have planned an article about dynamic/static linking but it isn’t ready yet). What I hate the most about NixOS is that you are absolutely forced to use systemd. Systemd is by far the worst piece of free software on earth

Well yeah, we’re not talking about bad software, this post is, surprisingly, very positive.

What’s KISS Linux

KISS Linux takes the KISS principle (Keep It Simple Stupid) to its logical conclusion. It’s a meta-distribution created by the man himself, Dylan Araps (the guy that created neofetch, and the pure (ba)sh bibles among other things).

A distro really isn’t more than a package manager. What is Arch if not pacman? What is Debian if not apt? What is Fedora if not dnf? Sometimes just a desktop environment on top of it (Of course, the desktop environment is most likely KDE or GNOME, not part of the distribution in and of itself).

KISS, as well, presents its own way of managing packages, which I think is as close to perfection as a package manager can be. It has features that I haven’t seen in other package managers, features that should be basic. And everything around 1000 lines of POSIX shell. Absolutely impressive.

By default you’re given busybox utilities (and init system), the musl C library, and pretty much nothing else. The installation is similar to Arch or Gentoo, in the sense you do everything manually, which makes you understand everything about everything.

Installation

I have to admit, it took me a few days to have a working minimal system. I wanted to do things a little bit differently than I usually do, so I needed to step outside of my comfort zone.

Before installing it on my main production machine(s), I wanted to test it out, not in a VM, but on real hardware. I installed it on a Thinkpad T410 I had lying around and wasn’t using. Also, I used an outdated Arch Linux installation media I had as well, because I didn’t want to flash anything.

Of course, this isn’t a tutorial, I won’t go through all installation steps unless I find them particularly interesting. It’s not much different than installing Arch anyways.

Grub

During the installation process I stumbled upon a bunch of different roadblocks, Grub was the first one of them.

The Thinkpad T410, of course, doesn’t support UEFI. So I’m doing a traditional BIOS installation. After running grub-install and no errors reported I confidently rebooted my PC, not expecting it to boot (since I don’t have anything), but at least I expected to see the grub menu.

Sadly, this was the least satisfying solution of this whole process. After several hours of trying different things, manually creating grub.cfg, using grub-mkconfig, everything, still failed. Even BEFORE it had read the configuration file. To this day I’m unaware of any real solutions or even what was the root of the problem. What I ended up doing was running the grub-install present in the ARCHISO, not in the chrooted environment. It worked without problems…

Initramfs

In KISS fashion, I didn’t want to use scripts like mkinitcpio or whatever. I wanted the true experience of making my own initramfs, honestly, this was the part I enjoyed the most about this installation. Of course, this is not KISS-specific, but I was already with the “KISS mindset” so I might as well do it.

Doing your own initramfs is literally, selecting a directory to work with, and creating your minimal filesystem. This filesystem should have installed all the necessary utilities to do whatever it is that you want to do before booting the system. For me, this includes busybox for regular unix utilities, and cryptsetup for actually decrypting the disk.

Remember, if you’re installing busybox in an initramfs, make sure all symlinks are relative and not absolute. I made a few mistakes that forced me to start over, and ALWAYS forgot that.

In your initramfs you need an init script, this script will be the first thing your kernel runs. Use this script to mount necessary filesystems (proc, sysfs, devtmpfs & tmpfs). Without these filesystems mounted the system can’t function properly.

What gave me problems here was kernel modules. Since this was only a installation and there were various things that could go wrong, I was hesitant to compile my kernel before I had a functional system. So I lazily copied the vmlinuz image present in the archiso and stopped worrying about it. The problem was that it didn’t have the modules for decrypting the drive builtin, so I needed to modprobe them and copy them into the initramfs. With the correct structure and stuff.

After that was sorted out, I finally found myself booted into a minimal kiss linux and I could stop relying on the live ISO (or so I thought)

Kernel

Of course, I needed to compile my own kernel if I wanted to be a cool kid, so I did. (And using the arch kernel was a temporary solution, as I didn’t want to be loading kernel modules manually all the time, nor did I want to create scripts that do that. Loading kernel modules is a lot like dynamic linking so I wanted everything (or at least almost everything) to be built into the kernel itself).

I thought that running make defconfig would give me a starting point of functional configuration that will apply to roughly all machines. That wasn’t the case, at least for me. The kernel didn’t boot with the default configuration. It was missing a lot of essential modules that really should be the defaults. Mostly those about cryptography.

I had to load the i915 driver for my integrated gpu to work properly and tinker with a few related settings to get graphics working. But eventually I got it. If your graphics aren’t working properly and you want to boot into your system, try adding nomodeset as a kernel parameter in your bootloader, this worked for me while I tried to get graphics working properly.

However, after the graphics loaded properly now I had a problem… The TTY didn’t have proper colors…

I KNOW IT’S A NITPICK, I WON’T BE USING THE TTY REGULARLY ANYWAYS

After (again) several hours of trying different configurations, different kernel modules etc… I finally got it. It wasn’t a kernel problem, it was a grub problem. What I did was insmod video modules (vbe, vga, font, gfxterm). Configure grub to use graphics instead of the fallback VESA video and in your kernel parameters add vga=current. Not only your colors are fixed, but your bootloader looks pretty, as well.

After installation

I’ve been using it, not as my daily driver, but as a “playground” where I can try certain things once in a while, and it hasn’t been that hard to do what I want. The upstream repos are tiny, which encourages you to create your own repo, which I did after a few hours of installing it.

The first thing I packaged was zsh. The community repo has zsh packaged but… is it broken?? For some reason $(command substitution) hangs forever. So I packaged it myself. I’m not entirely sure, but my guess is a musl compatibility problem. When I needed to package something the Alpine repos have been of great use to me, since they already have patches for making software work on musl.

I just looked at Alpine’s APKBUILD, downloaded the patches and translated everything into kiss’ build system, and I had zsh working like a charm in no time.

I packaged a few things after zsh, if upstream provided statically-linked binaries I just downloaded them and copied them, I might be a purist about a lot of things, but I’m not a “compile everything” purist. If upstream provides a perfectly working static binary, I just save a lot of time by using it, not just compiling, but in crafting a build script as well.

I don’t mind compiling most of my software, but if I can avoid it, I will. However, if there’s one thing I will DEFINITELY NOT COMPILE, is a web browser.

Installing Nix in Kiss

If you want to use proprietary software or bloated software on Kiss you’re in a tough spot. Most, if not all, proprietary software (and upstream binaries of free software) are dynamically linked against glibc, which Kiss Linux doesn’t use. With free software you can get away with it by recompiling it and linking it against musl (at which point you might as well statically link it).

The only other solution would be using an alternative packaging system/manager. Options are flatpak, appimages and… docker?? (I guess). Of course, you read the subtitle, what I went with was nix. Honestly because I’m way more familiar with nix and is the best (but still not perfect) solution for dependency linked dynamic hell.

I could package nix as a kiss package; I KNOW it’s (probably) possible. But honestly, nix being such a massive thing (build users, daemon, need to load environment variables, creating the /nix/store, etc…) I really didn’t want to do that. First I thought to lazily copy the upstream installation script into the build script, of course that wasn’t going to work because kiss runs that script in isolation, so it wouldn’t install anything. I had to do everything manually. But I didn’t want to lol. Maybe later I’ll actually do it.

As expected, the installation script provided by nixos.org wasn’t portable at all. It had a hard dependency on sudo, non-standard cp options. And another problem that I didn’t know what was causing it. The first fix was symlinking doas to sudo, and thhose parts of the script worked. Then, I used kiss’ alternatives system to temporarily change busybox’s cp to gnu’s cp. At the end of the script it said something along the lines of

Remember to add this to your profile so the environment variables work and nix can do its thing
.
(Obviously not the exact words but you get the idea)

Yes, just a period. I’m guessing the script was hardcoded to add a . and then a path to source required environment variables, but something went wrong. What went wrong? honestly, no idea.

Anyways I added the scripts inside ~/.nix-profile/etc/profile.d/* to my shell profile, and nix was working flawlessly.

After installing Nix, I already have everything I should need for a functional system. If for some reason I can’t do something with regular kiss, I have Nix to use as a fallback.

Conclusion

Surprisingly, installing Kiss Linux was a really good experience overall, I got to learn a lot about the system’s internals that I couldn’t have learned otherwise. Compiling all your software isn’t that bad, as long as you install mostly minimal software, (which you should be doing already). I might switch my production machines to Kiss, but I will have to test it more days to see if I completely like it.

Also, I need to figure out a way for remote building of packages, so I can use my homelab to compile everything instead of choking my poor thinkpad.

Making a script for declarative packages and services so I have the exact same git-managed setup in every machine shouldn’t be that hard. Once I have that I will happily move all my machines to Kiss. Or perhaps I will try oasis?? I don’t know at this point.

The Problem With "Encrypted" Email Providers

2026-05-31T17:07:09-06:00

The Problem With “Encrypted” Email Providers

E-mail, for better or worse is one of the most widely used communication methods over the internet. Even though it has its fair share of problems. It’s way better than using something like Discord or Instagram or whatever else kids nowadays are using.

Why email is was cool

Decentralization: You don’t go to email.com to create an account, you use whatever provider you want to use. You have choice, you can even host your own
Simple: By default, email is just plaintext. Simple, and readable. If you’re sending HTML e-mail, you’re doing it wrong.
Openness: The foundation for email is IMAP and SMTP. You can even use curl to read email. You don’t need a web browser. Just need a clients that can understand both protocols and you’re set.

Why email sucks now

Gmail: EVERYONE uses gmail. In terms of setup, gmail is tremendous hassle, you need to configure extra things to make your e-mail client actually work like an e-mail client. Thankfully g-mail does lets you use IMAP & SMTP, but its not as simple as it should. Naturally, every effort is made to keep you inside their webapp. Because e-mail is one of the few (the only?) decentralized technology left in widespread used, the fact that everyone defaults to Gmail destroys its greatest superpower.
HTML: HTML mail is stupid (as stated above). It introduces security risk, results in larger messages, and renders unreadably by some clients, and more. No normal person sends HTML mail; it is the exclusive domain of spammers and automated newsletters. ¹

Why “Encrypted” Email Providers are Problematic

When you first start worrying about privacy, you will hear two names being thrown around constantly: Tuta Mail & Proton Mail (more obviously exist, but these are the most common ones). Using this services might give you a false sense of security since they will only work as advertised if you use them correctly.

E2EE should be done at the client level, not a the provider level.

The very definition of E2EE is that no plaintext leaves your device, your messages are never read by the server, EVER. However, the way this services work is incompatible with the interoperability of e-mail.

Imagine you send a E2EE message to a g-mail user; How would they even read that? They don’t use proton, they can’t decrypt the message. For standard email to go through, it has to be send as plaintext over the wire. Then what’s the point of encrypting it in the first place? (To clarity: Proton doesn’t actually encrypt messages to external providers to then decrypt them, that would be dumb) (You can configure a symmetric passphrase, tho)

Now imagine two Proton Mail users communicating with each other. Since both are using the same client, they can understand each other and the encryption is actually useful. However, you need to use the clients provided by the services, you can’t bring your own. Technically is possible to setup a normal client with Proton Mail, but its a hassle. To my understanding is not possible to do the same with Tuta Mail.

A big problem with web apps is that you’re trusting the server to deliver clean JavaScript every time you hit refresh. If a government forces Proton to server a malicious JS payload to one specific user, the user most likely won’t even notice its browser is handing over the decrypted keys. Local clients don’t suffer from this dynamic payload vulnerability.

Using these services is better than using any other “normal” provider.

To be fair, this article isn’t complete hate to this companies. The fact that people are concerned enough about privacy that this companies can even exist, is a net positive. If you don’t plan on using a normal email client there’s no issue with using this services.

A thing I always like to remind myself, is what’s important, the reason I started using mainly free software for things. Privacy, freedom, control. Reducing bloat, customizability, performance, minimalism, efficiency are just lucky side effects. Yes, I care about minimal software, following the suckless & unix philosophies and everything. But the most important thing of all, is and always will be privacy.

The self-hosting trap

Some privacy advocates propose hosting your own email server. While I find this to be a worthwhile endeavor, it isn’t actually great for privacy, depending on your threat model.

Imagine you use your own email server to talk to two different people. You want to ensure they can’t pin down your exact identity, so you give them different aliases: foo@zekar.xyz and bar@zekar.xyz. Because that domain name is so unique, it takes zero effort to figure out that any *@zekar.xyz address belongs to the exact same person. Furthermore, if your registrar doesn’t mask your data, your real name might be tied directly to the domain registration.

I only recommend hosting your own mail server if you want people to know it’s you, and if you have the immense time and resources required to maintain it. Running a mail server is easily one of the most demanding services you can self-host due to IP reputation and spam filtering.

The real solution

What I recommend is just using cock.li or similar services.

Simply because they don’t ask for personally identifiable information at registration. Just a username and a password and nothing else. For some reason, that’s very hard to find nowadays. Of course, they support the traditional protocols, IMAP and SMTP (even the old POP!)

How can you trust such a ridiculous name?

You can’t. Cock.li doesn’t read or scan your e-mail content in any way, but it’s possible for any e-mail provider to read your e-mail, so you’ll just have to take our word for it. No “encrypted e-mail” provider is preventing this: even if they encrypt incoming mail before storing it, the provider still receives the e-mail in plaintext first, meaning you’re only protected if you assume no one was reading or copying the e-mail as it came in.

Taken from the cock.li frontpage

This ties back to my earlier point. The same trust to place upon Proton or Tuta to encrypt your emails before they read them, is the same trust you place upon cock.li to not read them.

However this trust shouldn’t be necessary.

The real solution

The only way to ensure your emails are private, regardless of which provider you use, is to get yourself a GPG key and encrypt (and sign) your messages locally on your client.

If you’re wondering: no, this doesn’t mean you have to copy and paste encrypted data manually. Most clients handle encryption natively. Inconvenient? Actually not that much, just keep your key safe, and share it with everyone you wish.

The catch

The only problem with encrypting your mail is the same problem of every private communication method. Try to convince your normie friends to encrypt their mail? Good luck. (Try to convince them to even use e-mail instead of discord lol)

http://david.woodhou.se/email.html ↩︎

My take on perfectionism

2025-03-21T17:19:47Z

My take on perfectionism

The main reason to build this website is to share my ideas, all of them, even those I won’t dare to share in person. This one, goes into the latter group.

The thing I’ve struggled most in my life is perfection itself, I always try to be the best version of myself, and the best version of myself, would be also the perfect version of myself.

Is Perfection Attainable?

Perfection is often defined as the state of being complete and correct in every way.¹. While true perfection is imposisible for a human to achieve, I believe in striving to be as close to it as possible.

But here’s my bold take:

We Should All Strive for Perfection

Yes, you read that right. Everyone should try to be perfect. But before you dismiss this as unrealistic, let me explain what I mean.

Perfection isn’t just about excelling in one area; it’s about balance. I call this holistic perfection as opposed to superficial perfection, and understanding the difference is crucial

Holistic perfection vs superficial perfection

Holistic perfection is about striving to improve in every meaningful area of life, not just one. Many people chase perfection in a limited sense, and this can be damaging and frustrating. Let’s look at two hypothetical students to illustrate the difference.

The Trap of Superficial Perfection

Imagine a student who is at the top of their class. They dedicate all their energy to being academically perfect but neglect their relationships, emotions, and personal growth. One day, during an ungraded classroom activity, they make a mistake. Their classmates don’t react, they never built meaningful connections with them. The student is devastated. Their self-worth crumbles because their entire identity was built around being “the best” in school.

The Power of Holistic Perfection

Now, picture another student, also top of their class, but instead of fixating solely on academics, they strive for holistic perfection. They work hard in school, but they also invest in friendships, emotional resilience, and self-improvement. During the same classroom activity, they make the same mistake. But instead of feeling crushed, they shake it off. Why? Because school isn’t their whole world. They know that understanding the truth of not being perfect is closer to perfection, than lying to themselves to make them think they are perfect. They know that striving for perfection also means being emotionally balanced and adaptable

Possible Criticism & Rebuttals

I get it, saying that everyone should try to be perfect sounds extreme. You might be thinking:

“‘Perfect’ people are annoying/irritating/boring.”
“Striving for perfection is exhausting.”
“Failure is natural, why fight it?”
“Being perfect in everything is unrealistic.”

Perfect people are annoying.

It’s true, people obsessed with perfection can be irritating. They seek validation and often lack real social skills.

But someone striving for holistic perfection? They aim to be perfect in how they communicate, how they treat others, and how they carry themselves. They don’t need to boast or seek approval. They remain humble, because humility is closer to true perfection than arrogance. Someone that’s perfect and not annoying is more perfect than someone that’s perfect and annoying.

Striving for perfection is exhausting.

Superficial perfection is exhausting. It demands constant external validation, making people feel like they must always prove something.

Holistic perfection, however, is liberating. Instead of obsessing over a single aspect of life, it encourages balance. You’re trying to be the absolute best at everything; everything, of course, includes not sacrificing well-being, caring about your mental health.

Failure is natural, why fight it?

Yes, failure is inevitable, and we should try to avoid it as much as possible. However, someone that confronts failures gracefully is more perfect that someone that breaks when confronted to it.

Trying to be holistically perfect includes being perfect in how you handle failure.

Being perfect in everyting is unrealistic.

Agreed! But that’s not the point. The goal is to try to reach perfection, because, as I said before, being perfect is impossible. Trying to be close to perfection is the main idea here.

My experience with perfectionism.

Now, let’s get personal. I have always been a perfectionist, for as long as I can remember. I don’t know the exact cause of this, but if has often led to intense stress when I fail to meet my own unrealistic standards. Whenever I feel frustrated by my inability to achieve perfection, I remind myself of holistic perfection, after all, a truly perfect person wouldn’t become frustrated over their imperfections.

That’s why I wanted to write this. This thought has been on my mind for a while, and it has genuinely helped me. I don’t want to sound arrogant, but deep down, I’ve always felt somewhat superior to others. Maybe that’s why the usual advice about perfectionism never resonated with me.

“Everyone makes mistakes.”
“Yes… everyone but me.”

The concept of holistic perfection helped me reconcile my flaws with that subconscious sense of superiority. Now I strive to be humble because, after all, wouldn’t someone truly “perfect” be humble? Thanks to this shift in mindset, I no longer feel as much pressure from myself, and I genuinely believe I’ve become a better person.

https://dictionary.cambridge.org/dictionary/english/perfection↩︎

Why you shouldn't use the fish shell

2025-03-20T17:58:26Z

Why you shouldn’t use the fish shell

The POSIX standard is a set of rules a UNIX-based operating system should follow. However, this isn’t always the case. While it’s perfectly fine to extend the POSIX standard to add more features and improve functionality –as seen in bash and zsh– there’s a third very popular shell that that has gained significant attention: Fish

The Friendly Interactive SHell

fish is a smart and user-friendly command line shell for Linux, macOS, and the rest of the family.[^1]

Fish is often marketed as a user-friendly shell, and it does offer some appealing features for interactive use. However, its design choices and lack of POSIX compliance make it a poor choice for scripting and not a very good one for interactive use.

Fish vs POSIX

Fish’s lack of POSIX compliance is presented as one of its best features, however, personally is the most significant drawback. This means scripts written for Fish may not run correctly on other shells, and vice versa. This can be a major issue if you need to write portable scripts that should run on a variety of systems.

Other shells vs POSIX

bash and zsh are not strictly POSIX-compliant shells because they extend the POSIX standard with additional functionality that isn’t part of the specification. While they are largely compatible with POSIX, their extra features can lead to scripts that don’t work in strictly POSIX-compliant environments. This is why I always recommend writing scripts in POSIX-compliant shell syntax whenever possible. Scripts written in POSIX-compliant shell can run on virtually any UNIX-like system, from macOS to OpenBSD to Linux (every sane OS—Windows not included!).

Some people (especially soydev sysadmins) like to write #!/bin/bash scripts, this, clearly, is an skill issue, just write #!/bin/sh and get good. This is the exact same problem.

Bash	Zsh	POSIX	Fish
Can run bash and POSIX scripts.	Can run bash, zsh and POSIX scripts	Can only run POSIX-compliant scripts. ensuring maximum portability	Can only run Fish scripts, it doesn’t even run POSIX scripts

Why POSIX Compliance Matters

POSIX compliance ensures that your scripts will work across different UNIX-like systems without modification. While shells like bash and zsh offer additional features that can make interactive use more enjoyable, relying on these extensions for scripting will lead to compatibility issues. Fish, takes this problem to the extreme by just abandoning POSIX compliance altogether, making it a poor choice for scripting and a questionable one for interactive environments (Just use zsh!!).

Conclusion

If I had to summarize this post in a single phrase, it would be ‘skill issue’. [^1]: https://fishshell.com/

The (not-so-problematic) Problem of Evil

2025-07-08T17:18:49-06:00

The (not-so-problematic) Problem of Evil

I.I The problem of Evil

One of the most classical arguments against any religion with the definition of a tri-omni God is The Problem of Evil. Which states that “If God is all-good and all-powerful, why is there so much evil?”. This problem is so big and so well-known that the arguments against this has gained their own name, the so called theodicies. ¹

I.II Theodicies

A theodicy meaning ‘vindication of God’, from Ancient Greek θεός theos, “god” and δίκη dikē, “justice”) is an argument with the attempt to reconcile an all-powerful all-good God’s existence with evil’s existence.

Free Will

God thinks (and if God thinks something it must be true) that free will is more important than creating perfect loving creatures that don’t disobey Him at all. If he programmed us to just love each others without the free will to not do it, the love we share wouldn’t be true love, since we were forced to do so.

Soul-Making Theodicy & Greater Good Theodicy

I really find these theodicies to be too similar to just put them in a different category

Evil and suffering are necessary for moral and spiritual growth. Life is a soul-making journey where hardships help develop virtues like courage, compassion and resilience. A painless world would produce morally immature being. God allows evil to bring about a greater good that couldn’t happen otherwise.

Punishment Theodicy

Suffering and evil are divine punishment for sin, caused by the original sin that we humans, have. God is just, and evil is the result of human rebellion. All suffering is deserved, either as a consequence or as discipline.

All of these theodicies have a million rebuttals and counter-rebuttals which are outside the scope of this article. However, they’re here just to demonstrate the importance and weight this problem has.

I.III The Argument from Morality

One of the most popular arguments for the existence of God (especially in Christian apologetics) is called the Argument from Morality. It basically claims that objective morality can only exist if God exists. So if you believe things like murder, rape, or slavery are really wrong (not just personal preference), then, the argument goes, you’re implicitly relying on God’s existence.

If God does not exist, then objective morality does not exist. But objective morality does exist. Therefore, God exists.

The Core of the Argument:

It usually goes something like this:

If God doesn’t exist, then objective moral values and duties don’t exist.
But objective moral values and duties do exist.
Therefore, God exists.

The idea is that moral laws require a moral lawgiver, a transcendent source outside of human opinion. According to this view, just like physical laws point to a lawmaker, moral laws must come from God.

Christian apologists like William Lane Craig lean on this argument heavily. They claim that atheistic or naturalistic worldviews can’t account for why anything is objectively right or wrong. At best, they say, you get cultural norms, evolutionary instincts, or personal preferences; not real, binding moral truths.

The argument dodges the Euthyphro dilemma ². Is something good because God commands it, or does God command it because it’s good? Either morality comes from the nature of God, or it exists independently of God (which makes the argument unfeasible). Christian philosophers often resolve this dilemma by claiming that morality is grounded in God’s unchanging nature, which is perfectly good. In this view, God neither arbitrarily invents morality, nor is He subject to it; rather, His nature is the standard.

Of course, the first option is what most Christians believe, morality exists just because God exists.

II The logical conclusion

So let’s put the pieces together: Many Christians claim God is the source of morality. Also, we find pain and suffering in the world and there are several theodicies to fix this problem, however the need for these theodicies is itself a sign of the problem’s weight.

I speak of The Problem of Evil and theodicies, but this also comes linked with another problem, which I think its solved by the same explanation. I’m talking of disturbing things not just happening, but endorsed by God in the Bible.

To name a few examples:

Morally Problematic Acts Endorsed by God in the Bible.

“You may buy male and female slaves from the nations around you… They will become your property… You can bequeath them to your children as inherited property.”

Leviticus 25:44-46

“A man may beat his slave with a rod; as long as the slave doesn’t die immediately, there’s no punishment.”

Exodus 21:20-21

Both of these verses don’t just acknowledge the existence of slavery. They regulate and legitimize it, even the violent abuse of slaves, without ever condemning the institution. God had the opportunity (multiple times) to condemn explicitly (if that was His will), and yet, he didn’t.

“Now go and strike Amalek and devote to destruction all that they have. Do not spare them, but kill both man and woman, child and infant, ox and sheep, camel and donkey.”

1 Samuel 15:2-3

This is not a military strike, it’s a divine command to exterminate an entire population, including infants and animals. Later, Saul is punished for not killing enough. (1 Samuel 15:9-11)

“If a man meets a virgin who is not betrothed, and seizes her and lies with her… he shall pay the father fifty shekels of silver, and she shall be his wife.”

Deuteronomy 22:28-29

The punishment for the rapist is to marry his victim, effectively binding her to a lifetime with her abuser, with no concern for her consent or traume.

After David commits adultery with Bathsheba and murders her husband, God punishes David by killing their child.

2 Samuel 12:13-18

An innocent child dies for someone else’s sin, raising obvious questions about justice and divine fairness.

Taking all the points discussed previously, we get this conclusion:

God isn’t just moral; he defines morality. So if God commands he death of children, the enslavement of peoples, or eternal torment; those acts, by definition, are good.

III. But Doesn’t God Give Us a Moral Compass?

“They show that the work of the law is written on their hearts, while their conscience also bears witness, and their conflicting thoughts accuse or even excuse them”

Romans 2:15

This verse changes everything, God has written the law on our hearts, most Christians would argue that’s the meaning of this verse. Our moral intuitions come from God, that’s the “law written on the heart.”

If that’s true, how can those same intuitions scream that slavery or genocide is wrong when clearly God, is all for it?

Who’s wrong? Us or God?

Well, God can’t be wrong, God can’t lie (Hebrews 6:18) so we MUST be wrong about some things, these things can include acts that God endorses in the Bible and we find them reprehensible.

IV. Apologists Explaining the Horrific

Many Christian apologists are aware that some of God’s commands in the Bible seem deeply immoral to modern readers. Instead of acknowledging this moral tension, they often try to reinterpret, downplay, or sanitize the verses to protect God’s image.

IV.I Reinterpretation Through Language

Apologists argue that we’re misreading the original Hebew or Greek. A famous example is Deuteronomy 22:28-29, which many take as a law requiring rape victim to marry her rapist. Apologists claim the Hebrew word translated “seized” doesn’t necessarily imply force, and therefore, it’s not rape. But even if that’s true, the passage still mandates forced lifelong marriage after a premarital sexual encounter, a punishment that clearly harms the woman more than the man.

So the “softened” interpretation is morally disturbing, just slightly less so.

IV.II “It was a Different Time” Defense

This line of reasoning claims that God was simply working within an ancient cultural norms ;that slavery, genocide, or patriarchy were regrettable but necessary due to the time period. But that implies that an all-powerful, all-good Gas somehow limited by the morality of Iron Age tribes; unable to command something better or set a moral example.

If God the moral authority, or is He taking moral cues from Bronze Age norms?

IV.III Greater Good Rationalizations

Some claim these morally disturbing actions served a greater divine purpose we can’t fully understand. But that’s exactly the kind of reasonins Christians reject when it’s used to excuse real-world evil. If a dictator kills children for a “greater cause,” we call that evil; not mysterious goodness.

If these rationalizations were applied to any other being, Christians would be horrified. But because it’s God, they twist themselves into knots trying to justify what they’d never accept from a human.

V. The Real Problem: Christians Don’t Want to Say It

This is the core issue. Most Christians do not want to admit the full implications of their own theology.

If God defines morality, then anything He command is, by definition, good; no matter how repugnant it seems to human conscience. That includes:

Slavery
Genocide
Eternal torture
Killing infants
Focring marriage after rape

The consisten Christian response (if take seriously) would be to say:

“Even though my conscience is repulsed by this, I submit to God’s authority, because my moral intuitions are fallible and God’s will is perfect.”

But almost no one actually says that.

Instead, Christians do everything they can to avoid saying what their theology requires. They reinterpret, dodge, or dilute the text to protect their moral instincts. This creates a bizarre situation:

They believe morality comes from God.
They morally reject some things God does or commands.
Yet they refuse to admit that either God is wrong or their theology is flawed.

They want to preserve both God’s moral perfection and their own sense of justice; even when the two clash. That tension is never resolved. It’s just papered over.

VI. Conclusion: The Cost of Consistency

Here’s the uncomfortable truth:

You can resolve the Problem of Evil if you’re willing to let God define morality. But that leads to a horrifying conclusion: anything God commands (even genocide, slavery, or child killing) is morally right.

The only alternative is to say that some things God did or commanded in the Bible were actually wrong; that would mean God is not the source of morality, and the Argument from Morality collapses.

So you’re left with a choice:

Submit your moral compass to God, even when it revolts you.
Or trust your moral compass, and admit that God, as described in some parts of Scripture, might not be perfectly good.

I can’t think of a rationalization of having it both ways.

You can have a God who defines good and evil. Or you can have a moral compass you trust. But I’m not sure you can have both.

https://en.wikipedia.org/wiki/Theodicy↩︎
https://www.str.org/w/euthyphro-s-dilemma-1↩︎

Beyond Infallibility: A Historical-Critical Examination

2026-06-01T00:51:51-06:00

Beyond Infallibility: A Historical-Critical Examination

Preamble

This is probably the longest and most well-researched article in this page. This was actually a final project for school, hence the different tone compared to the rest of the pages here. I’m sincerely proud of my work and I wanted to share this here. This was the result of what I’m estimating around a month of daily research and reading.

Also, this was originally written in markdown to be compiled to latex to be compiled to PDF and deliver the assignment, of course I can easily copy everything to my site for it to be compiled to HTML without issues, thanks pandoc.

Introduction

In this paper we will explore the tension between the theological claim of biblical infallibility and the empirical evidence derived from the study of ancient manuscripts and historical records. The Bible, while it remains a profound root of cultural heritage, its status as a “perfect” historical document is incompatible with rigorous scholarly scrutiny. This analysis will focus on three primary areas of evidence: first, we will focus on textual integrity, demonstrating how the absence of original autographs and the presence of significant interpolations, such as the Pericope Adulterae (John 7:53–8:11) and the longer ending of Mark (16:9–20), reveal a fluid transmission history; second, historical accuracy, exploring conflicts between biblical narratives and external secular records, exemplified by the incongruity surrounding the Census of Quirinius and the lack of evidence for the Exodus; and third, internal consistency, highlighting conflicts in genealogies, resurrection accounts, and the evolving Christology that suggest a developmental rather than static theological trajectory.

Biblical infallibility is the assertion that the Scriptures are without error in all matters, including history, science, and theology and it has been a cornerstone of Christian orthodoxy. For many believers, this doctrine implies that the biblical text, in its original autographs, represents a divinely preserved and mechanically dictated record of divine revelation, immune to the corruptions of human transmission or the limitations of historical context. However, the applications of modern historical methods, textual criticism, and archaeology over the last centuries has fundamentally challenged this premise.

Methodology

To rigorously evaluate the claim of biblical infallibility, this paper employs the historical-critical method, a scholarly framework that treats biblical texts as human documents produced within specific historical, cultural, and literary contexts. Unlike traditional dogmatic approaches that begin with the assumption of divine perfection, this methodology prioritizes empirical evidence, textual analysis, and comparative history to reconstruct the origins and development of the biblical canon. The analysis is structured around three primary pillars of investigation: Textual Criticism, Historical-Archaeological Correlation, and Literary-Redaction Criticism.

It is acknowledged that the historical-critical method cannot prove or disprove theological truths (e.g., the resurrection as a supernatural event). Instead, this paper limits its scope to historical and textual verifiability. The goal is not to dismiss the Bible’s religious value but to demonstrate that its status as an “infallible” historical record is incompatible with the empirical evidence of textual variance, historical discrepancy, and literary development. By adhering to these rigorous methodologies, the paper aims to provide an objective, evidence-based assessment of the biblical text’s integrity.

Textual Criticism

Textual criticism treats the Bible as a product transmitted through human agents across centuries rather than a single, immutable artifact. Manuscripts were copied by scribes working in diverse contexts (monasteries, scriptoria, and later by professional copyists), each bringing different training, regional practices, and theological tendencies to the task. As a result, the surviving manuscript tradition shows variation at virtually every level: single-letter differences, word-order shifts, omitted or added phrases, harmonizing adjustments, and larger interpolations. These variants are not merely clerical noise: they shape readings and sometimes theological emphases, demonstrating that the biblical text as we have it is the product of ongoing human activity, copying, correcting, glossing, and occasionally composing, rather than a perfectly transmitted original (Metzger and Ehrman 2005; Epp and Fee 2015).

In the early Church, most manuscripts were produced by individual Christians who desired to provide their community with a copy of the books of the New Testament. Because of this, the demand for more production often outweighed the accuracy of the copies (Metzger and Ehrman 2005).

The absence of Autographs

The Bible is a collection of very old books, books written at a time when the technology and materials for writing were insufficient compared to what we have today. The earliest manuscripts we have of the old testament were written on various materials such as papyrus and animal skin. These manuscripts were unrelentingly copied manually by scribes for generations.

One remarkable example of the destruction of manuscripts is the collapse of the the Library of Alexandria, which enveloped a great collection of manuscripts from different cultures. The library met its demise through conflicts culminating in its destruction, including potentially original Bible manuscripts. (Lawrence 2024)

Regarding the scale of variation, modern estimates of textual variants in the New Testament manuscript tradition vary widely depending on counting method. Conservative tallies long cited hundreds of thousands of variants; major recent cataloguing projects place variant readings well over 400,000 when every orthographic, word-order, and substantive variant is counted. Even when a large portion of variants are minor (spelling, word order), a significant number are substantive with implications for meaning, citation, or theology. (Gurry 2016)

Case Study 1: The Pericope Adulterae (John 7:53-8:11)

The Pericope Adulterae recounts an episode in which religious leaders bring a woman accused of adultery before Jesus, intending to test him. They remind him that the Law of Moses prescribes stoning for such an offence and ask whether she should be punished. Jesus initially responds by stooping to write on the ground (or by writing with his finger); after a moment he replies, “Let anyone among you who is without sin be the first to throw a stone at her.” Confronted by this challenge, the accusers depart one by one, beginning with the oldest; when only Jesus and the woman remain, he tells her that he does not condemn her and instructs her to “go and sin no more.” The scene powerfully contrasts judgmental legalism with mercy and calls attention to self-examination and forgiveness.

The story of the woman caught in adultery, known as the Pericope Adulterae, stands as one of the most famous and well-documented examples of a later interpolation in the New Testament. While the narrative of Jesus forgiving a woman and challenging her accusers to cast the first stone is deeply embedded in Christian tradition and liturgy, textual evidence overwhelmingly suggests that this passage was not part of the original Gospel of John. Its inclusion in modern Bibles is a testament to its theological value rather than its historical authenticity as a Johannine composition.

Manuscript Evidence

The strongest case challenging the originality of John 7:53–8:11 centers on its absence from the earliest and most carefully transmitted Greek witnesses. Two near-contemporary papyri, P66 and P75, both dated to around the early third century, do not include the episode; these codices are among the oldest surviving witnesses to John and are particularly valuable for reconstructing the text as it circulated in antiquity.¹ ² Equally significant is the omission of the pericope from two major fourth-century uncial manuscripts,³ Codex Sinaiticus and Codex Vaticanus, manuscripts that represent authoritative Alexandrian lines of transmission and are heavily weighted in modern critical editions.⁴ ⁵

Textual critics have long treated this pattern of absence in early, high-quality witnesses as decisive evidence against the passage’s original place in John. According to Metzger and Ehrman (2005), the cumulative manuscript and patristic evidence points strongly toward a non‑Johannine origin. The narrative first appears in later, less uniform transmission streams; one of the earliest manuscripts that does include the story within John is the bilingual Codex Bezae, which reflects a Western textual tradition known for variant and sometimes expanded readings.⁶ Taken together, these transmission facts suggest the episode entered the Johannine corpus at a later stage in the manuscript tradition rather than forming part of the Gospel’s original composition.

Stylistic and Linguistic Anomalies

Scholars who examine style and language beyond the surviving manuscripts find that the Pericope Adulterae does not sit comfortably within the rest of John’s Gospel. Its diction and syntactic patterns stand out from John’s usual manner of expression. Many lexical items and phrasings present in this episode are either extremely rare or entirely absent elsewhere in John, yet they occur with relative frequency in the Synoptic tradition.⁷

Wallace (2013) argues that the passage displays vocabulary, grammatical tendencies, and thematic motifs more typical of Luke and proposes it could result from the conflation of two earlier narratives, one traceable to Papias and the Didaskalia and another attested in Didymus and the so‑called Gospel of the Hebrews. Ehrman (2005) observes that the Lukan traits ascribed to the Pericope Adulterae are concentrated in material related to the first of those sources.

The passage’s word choices align unevenly with John’s usual lexicon and resonate instead with words found in Luke and other non‑Johannine traditions. Syntactic variance, sentence length, clause linkage, and rhetorical devices in the episode contrast with Johannine norms, suggesting either a different authorial hand or layers of redaction. The textual evidence may reflect the merging of independent anecdotal strands, a scenario that helps explain why early church writers and manuscripts vary in including or positioning the episode. Liturgical and theological shaping. Variation in vocabulary and emphasis could indicate adaptation for local liturgical use or theological harmonization with material circulating in communities influenced by Luke and other second‑generation sources. These converging observations support treating the Pericope Adulterae as a text with a complex transmission history rather than as an integral, original Johannine composition.

Case Study 2: The ending of Mark (Mark 16:9-20)

The Gospel of Mark in its earliest and most reliable Greek witnesses ends abruptly at 16:8, where the women leave the tomb “for terror and amazement had seized them, and they said nothing to anyone, for they were afraid.” This stark termination contrasts with a later tradition that continues the narrative in verses 9–20. That longer ending is absent from Codex Sinaiticus and Codex Vaticanus and from several early versions and patristic citations, while it appears in the majority of later Byzantine manuscripts and in many liturgical texts. Textual scholars therefore distinguish between the shorter ending that concludes at 16:8, the longer ending (16:9–20) present in most later Greek manuscripts, and an even briefer “shorter ending” attested sporadically. The cumulative external and internal indicators have led many critical editors to regard the longer ending as a subsequent addition rather than the original conclusion of Mark’s Gospel Metzger (1987) Robison (2008) Wallace (2008).

Internal stylistic evidence supports the judgment that 16:9–20 is non‑Markan. The vocabulary, grammatical constructions, and rhetorical pacing of the verses differ from Mark’s characteristic diction, and the narrative link from verse 8 to verse 9 lacks smooth cohesion. The longer ending incorporates traditions and motifs that resonate with Luke, John, and Acts, such as specific resurrection appearances, commissioning language, and a catalogue of signs following believers. These features are consistent with a harmonizing editor drawing on other Gospel traditions to supply a fuller post‑resurrection account for readers acquainted with the wider narrative corpus Metzger (1987) Black (2008).

Scholars have proposed multiple, not mutually exclusive motivations for adding the longer ending. Pastoral and liturgical concerns likely played a role: communities and lectors uneasy with Mark’s suspenseful, unresolved close may have preferred a more explicit series of appearances and an apostolic commission to read in worship. Harmonization and canonical complementation represent another motive, whereby scribes familiar with the resurrection narratives elsewhere sought to align Mark’s ending with the broader Gospel tradition. Doctrinal and apologetic impulses also offer explanation; by appending signs and commission material the supplement buttressed apostolic authority and the church’s missionary identity, thereby neutralizing theological unease generated by an abrupt, enigmatic finale Metzger (1987) Black (2008) Stein (2008).

An additional piece of manuscript evidence relevant to the transmission history is Codex Bobbiensis. This fifth‑century Latin codex contains a version of Mark that places the longer ending after verse 16:8 but omits some of the material found in the full longer ending, reflecting the variety of ways communities treated Mark’s conclusion. Codex Bobbiensis thus provides an important witness to the mosaic of early reception attitudes: some communities expanded Mark selectively, others preserved an abrupt close, and yet others supplied various shorter or longer supplements. The diversity represented by witnesses such as Codex Bobbiensis strengthens the view that the extended ending is a later, composite development arising in multiple textual traditions rather than a uniform, original Johannine-style conclusion.

Taken together, manuscript distribution, internal linguistic markers, and the plausible socioreligious motives for supplementation render the hypothesis of a later addition historically probable. This conclusion does not negate the devotional and theological functions the longer ending served in later Christian practice, but it does prompt careful distinction between Mark’s earliest attainable form and the accretions that entered the Gospel as it was transmitted and used across different early communities.

The Role of Scribes:

Scribes sometimes made deliberate changes to biblical texts to clarify theology or to correct what they perceived as errors. They harmonized parallel passages by altering wording to match other Gospels, smoothed abrupt or awkward transitions, and added explanatory glosses that later became integrated into the main text. At times they expanded narratives to supply needed doctrinal affirmations such as explicit resurrection appearances, apostolic commissioning, or signs validating authority. Other intentional interventions included correcting perceived theological problems by changing tense, person, or key terms to avoid apparent contradiction with creedal convictions, and emending what they judged to be historical or geographical mistakes to align the text with received tradition. These kinds of alterations are attested across diverse manuscript families and are detectable through patterns of vocabulary, style, and the distribution of variants in early witnesses. (Metzger and Ehrman 2005)

The Clash with History

The relationship between biblical narratives and external historical evidence is complex and often contested; while scripture preserves theological memory and communal identity, archaeological, epigraphic, and historiographical data sometimes conflict with the literal reading of those texts. Examining specific cases illustrates how scholars weigh material remains and nonbiblical records against literary claims, how those discrepancies inform historical reconstruction, and how interpretive models distinguish between theological shaping and potential historical cores within the biblical tradition.

The Exodus and Conquest Narratives

Ancient Israel’s foundational accounts of a mass departure from Egypt and a subsequent rapid conquest of Canaan are presented with narrative certainty in the Torah and Joshua, but they run into substantial challenges when measured against archaeological and demographic data. The biblical timetable and population figures imply a migration and sojourn that would have involved on the order of a million to two million people moving through and temporarily settling the Sinai.⁸ Archaeological surveys and excavations across the Sinai peninsula have not recovered the kinds of sustained, widespread campsite evidence, refuse concentrations, or infrastructural remains that such a prolonged, large‑scale migration would be expected to leave behind. Moreover, material culture trends in Late Bronze Age Canaan⁹ show no synchronous, abrupt demographic displacement compatible with the swift, totalizing military takeover described in Joshua; instead, regional continuity and complex patterns of local development and collapse better characterize the archaeological record Finkelstein and Silberman (2001) Garrett (2004).

Textual and interdisciplinary scholarship therefore often treats the biblical Exodus and conquest accounts as theological‑national origin narratives rather than straightforward historical reportage. Some researchers propose models in which smaller migrations, social memory, and the literary shaping of diverse tribal traditions were later woven into a cohesive national myth that served theological and identity functions for emerging Israelite communities. Others suggest that episodes preserved in the texts may have distant historical cores—localized expulsions, boundary conflicts, or migrations—that were later magnified and retold in grand scale. These interpretive frameworks account for the mismatch between large biblical demographic claims and the archaeological silence for mass movement in the Sinai and immediate, wholesale conquest of Canaanite cities Finkelstein and Silberman (2001) Miller and Hayes (2009).

The Census of Quirinius

The Gospel of Luke reports that Jesus was born during a census under Quirinius, governor of Syria, a detail that has long posed chronological difficulty when compared with external Roman sources. Luke’s narrative places a population registration at the time of Jesus’ birth, associating it with Quirinius’s administrative action; however, Roman records and the historian Josephus situate Quirinius’s well‑attested census in Judea to the year 6 CE, an event that took place decades after the reign of Herod the Great and the traditional timeframe assigned to Jesus’ birth. This chronological discrepancy creates tension between Luke’s chronological markers and independent historical data about Roman provincial administration and the dating of Herod’s death Meier (1991) Ehrman (2012).

Scholars have advanced several strategies to reconcile or explain the disjunction. Some attempts harmonize the accounts by hypothesizing an earlier, less well‑attested census or an earlier administrative role for Quirinius, though documentary evidence for such an action is thin and contested. Other scholars treat Luke’s reference as theologically motivated historiography, where Roman administrative terminology is used anachronistically or loosely to frame a theological message about imperial involvement in the nativity story. Still other interpreters propose that Luke conflated memories of separate events or incorporated a known later event into the nativity narrative for narrative or theological ends. These approaches underline how careful comparison of biblical narrative claims with external epigraphic and historiographical evidence can reveal tensions and invite nuanced readings that separate theological aims from strict chronological reporting Meier (1991) Ehrman (2012).

Internal Inconsistencies: Contradictions and Development

The internal fabric of the New Testament contains tensions that reveal divergent traditions, editorial activity, and theological development. Examining genealogies, resurrection accounts, and chronologies exposes concrete contradictions in names, sequences, and events. Tracing how Christological expression intensifies from the Synoptics to John demonstrates theological elaboration across communities and generations. Finally, the literary relationships among the Synoptics indicate active use, adaptation, and redaction of earlier sources by later evangelists rather than verbatim reportage.

Contradictory Accounts

The genealogical presentations in Matthew and Luke differ substantially in structure, purpose, and content. Matthew traces Jesus’ ancestry from Abraham through David’s son Solomon to Joseph in a royal, legal line that emphasizes fulfillment of Jewish messianic expectations, arranging the genealogy in three sets of fourteen generations; Luke, by contrast, traces a markedly different sequence backward from Jesus to Adam via David’s son Nathan and names different men as Joseph’s father, creating an apparent contradiction in the paternal line ascribed to Jesus. Scholarly solutions range from typological and legal interpretations such as levirate marriage or royal/legal genealogy to the conclusion that the evangelists preserved competing traditions with different theological agendas rather than a single harmonizable biography (Hooker 1993; Meier 1991).

The resurrection narratives likewise display significant divergence in who visited the tomb, what they witnessed there, and the order of post‑resurrection appearances. Mark’s shorter ending stops at silence and fear with the women fleeing the tomb; Matthew presents an angelic appearance, an earthquake, and Jesus’ appearance to the disciples in Galilee; Luke emphasizes Emmaus¹⁰ and Jerusalem appearances with a different cast of witnesses and a distinctive portrayal of the risen body; John foregrounds personal encounters such as Mary Magdalene’s recognition and Thomas’s confession of belief. These differences include variation in the number and identity of women at the tomb, the presence or absence of angels, the location of appearances, and the initial reactions of witnesses. The cumulative pattern suggests independent narrative streams and theological emphases shaped by distinct community memories and purposes rather than a single, uniform eyewitness chronology Kenny (2004).

Chronological claims also generate internal tension, most notably the expression “three days and three nights” and the widely attested Friday crucifixion to resurrection on Sunday. Some first‑century interpreters understood idiomatic Sabbath counting that allowed part‑day counts to satisfy the phrase while others note that Jesus’ own sayings and Passion chronologies differ in Gospel testimony in ways that require interpretive smoothing. The divergent temporal markers highlight how gospel authors framed events according to theological typology, liturgical reckoning, and communal memory, producing narratives that are not strictly harmonized in chronological detail (Wright 2003).

The Development of Christology

Mark portrays Jesus primarily as the suffering Messiah and Son of Man, a figure who embodies the paradox of a messianic vocation bound up with suffering, rejection, and a tendency toward secrecy concerning his identity and mission. Mark’s emphasis on human suffering, Jesus’ emotive responses, and the motif often called the “Messianic Secret” give priority to an ambiguous, ambivalent christological presentation that yields to confession only gradually within the narrative (Hooker 1991).

Matthew and Luke present an expanded christology that incorporates infancy narratives, prophetic fulfillment formulas, and more overt claims to Jesus’ lordship. Both evangelists include birth narratives that signal divine initiative in Jesus’ origins and deploy scriptural fulfillment to locate Jesus within Israel’s salvation history; their portrayals of Jesus move toward clearer recognition of divine status and theological significance while retaining narrative continuity with Markan material. The emphasis on fulfillment and the inclusion of infancy material mark a theological intensification relative to Mark (Safrai 1990; Porter 1997).

John advances christology further by opening with a high christological prologue that identifies Jesus with the preexistent Logos, employs explicit “I AM” sayings that echo divine self‑designation in Hebrew scripture, and stages extended discourses that assert unique ontological claims. The Johannine Jesus functions as both revealer and revelation, and the language of preexistence and ontological unity with the Father exemplify a developed theological language that presupposes reflection beyond the earliest Synoptic strata. The gradient from Mark’s messianic suffering figure to John’s preexistent Logos indicates theological evolution within early Christian communities rather than a static, fully articulated christology from the outset (Brown 1970; Barrett 1978).

The Synoptic Problem

Markan Priority, the dominant solution to the Synoptic Problem, holds that Mark was written first and that Matthew and Luke used Mark as a principal source while also drawing on additional material unique to them. Literary analysis shows extensive verbatim agreement between Matthew, Luke, and Mark, often with Matthew and Luke improving grammar, clarifying awkward features, or smoothing theological tensions in Mark’s narrative; such editorial behavior points to authors who actively composed and adapted existing texts for their own communities rather than serving as neutral recorders of independent eyewitness testimony. The double‑source hypothesis that supplements Mark with a hypothetical sayings source, Q, for material common to Matthew and Luke but absent in Mark further underscores the composite and editorial nature of the canonical Gospels (Goodacre 2001).

The implications of Markan Priority and editorial adaptation are significant for historical reconstruction. If evangelists worked as redactors who shaped, arranged, and augmented sources to address theological and pastoral concerns, then differing portraits of Jesus and variant event sequences reflect editorial choices and community memory as much as historical reminiscence. Recognizing the Gospels as theological narratives fashioned from earlier traditions explains why internal contradictions and developmental trajectories appear within the corpus and why scholars must employ careful source criticism, form criticism, and redaction criticism when attempting to recover historical foundations beneath the theological layers (Rankin 2002; Hooker 1991).

Theological Implications

Distinguishing “Inerrancy” from “Infallibility”

Debates about how to preserve doctrinal confidence in scripture often hinge on redefining terms so that older claims of verbal inerrancy are narrowed to a claim about spiritual authority rather than literal historical or scientific accuracy. Some contemporary theologians and confessional traditions explicitly confine inerrancy to “matters of faith and morals,” thereby allowing for historical, chronological, and scientific discrepancies without conceding the Bible’s authority for doctrine and ethical teaching. This conciliatory move seeks to protect ecclesial teaching while acknowledging the complex compositional history and the presence of demonstrable errors and divergent traditions in the text (Metzger and Ehrman 2005; Ehrman 2005).

A stronger historical claim is that the evidential record undermines even a robust form of infallibility when that term is taken to imply reliable historical reportage. The presence of demonstrable chronological contradictions, divergent genealogies, conflicting resurrection sequences, and clear signs of editorial alteration for theological or liturgical reasons indicates that the texts do not consistently function as historically infallible chronicles. Treating the Bible as infallible in spiritual or moral instruction while acknowledging historical fallibility is a coherent theological stance, but the empirical evidence motivates scholars to distinguish carefully between theological authority and empirical historicity (Metzger 1987).

The Human Element

The biblical corpus is the product of multiple human authors and communities writing across centuries, each bringing particular perspectives, social locations, rhetorical aims, and theological agendas. These human dimensions account for variant traditions, editorial harmonizations, and occasional historical inaccuracies; recognizing them does not necessitate dismissing the texts’ religious significance, but it does require that interpreters attend to authorial intents, redactional processes, and the limits of individual and communal knowledge in antiquity. As Ehrman (2005) argued, scribes and authors sometimes altered texts deliberately to clarify doctrine or to resolve perceived problems, which demonstrates both the human agency shaping the text and the theological stakes that motivated interventions.

Acknowledging the Bible’s human provenance invites methodological humility and a distinction between confessional readings and historical‑critical inquiry. It allows theological reflection to draw on the texts’ moral and spiritual resources while permitting historians and textual critics to map how beliefs developed, how traditions were transmitted and adapted, and how communities used scripture to negotiate identity and doctrine. This dual approach respects religious conviction without obscuring the evident human processes that produced the canonical texts (Metzger and Ehrman 2005; Ehrman 2005).

Conclusion

The evidence surveyed shows that the Bible contains significant tensions with external historical data, internal contradictions, and clear signs of theological development and scribal intervention. These features collectively challenge simple claims of literal inerrancy and support understanding the corpus as a product of layered composition, transmission, and communal use.

Three interlocking pillars ground this assessment. Textual evidence from manuscript traditions reveals additions, omissions, and deliberate alterations exemplified by the Pericope Adulterae and the endings of Mark, which demonstrate how scribes and communities shaped the text over time. Historical comparison exposes mismatches between narrative claims and archaeological or historiographical data, as with the Exodus/conquest traditions and the Quirinius census, underscoring limits to straightforward historicism. Internal consistency issues, including divergent genealogies, variant resurrection accounts, and evolving christological language across the Gospels, indicate theological development rather than a single, unchanging revelation.

Approaching the Bible as a complex library of human religious experience preserves its moral and spiritual resources while acknowledging the human processes that produced and transmitted these writings. This perspective honors both the texts’ lived role in faith communities and the evidential realities revealed by critical scholarship.

Scholars, clergy, and readers should engage scripture with historical‑critical tools alongside theological reflection. Combining source, form, redaction, and manuscript criticism with archaeological and historiographical comparison will yield a more accurate and nuanced understanding of the Bible’s origins, development, and ongoing significance.

Bibliography

Barrett, C. K. 1978. The Gospel According to St John. London: SPCK.

Black, David Alan. 2008. “Perspectives on the Ending of Mark: Four Views.” In, edited by David Alan Black. Nashville: B & H Academic.

Brown, Raymond E. 1970. The Gospel According to John (i-XII). Garden City: Doubleday.

———. 1994. The Death of the Messiah, Volume 2. New York: Anchor Bible.

Ehrman, Bart D. 2005. Misquoting Jesus: The Story Behind Who Changed the Bible and Why. San Francisco: HarperSanFrancisco.

———. 2012. Did Jesus Exist? The Historical Argument for Jesus of Nazareth. New York: HarperOne.

Epp, Eldon J., and Gordon D. Fee. 2015. Studies in the Theory and Method of New Testament Textual Criticism. Eugene, OR: Wipf; Stock.

Finkelstein, Israel, and Neil Asher Silberman. 2001. The Bible Unearthed: Archaeology’s New Vision of Ancient Israel and the Origin of Its Sacred Texts. New York: Free Press.

Garrett, Stephen. 2004. Unearthing the Bible: Archaeological Discoveries Relating to the Old Testament. Cambridge: Cambridge University Press.

Goodacre, Mark. 2001. The Synoptic Problem: A Way Through the Maze. London: T&T Clark.

Gurry, Peter J. 2016. “The Number of Variants in the Greek New Testament: A Proposed Estimte.”

Hooker, Morna D. 1991. Jesus and the Servant. London: SCM Press.

———. 1993. The Gospel According to Saint Mark. London: Black’s New Testament Commentaries.

Kenny, Anthony. 2004. Resurrection: What It Means for Us. New Haven: Yale University Press.

Lawrence, Mia. 2024. “Where Are the Original Bible Manuscripts?” 2024. https://www.freebiblestudyhub.com/archives/4299.

Meier, John P. 1991. A Marginal Jew: Rethinking the Historical Jesus, Volume 1. New York: Doubleday.

Metzger, Bruce M. 1987. A Textual Commentary on the Greek New Testament. London: United Bible Societies.

Metzger, Bruce M., and Bart D. Ehrman. 2005. The Text of the New Testament: Its Transmission, Corruption, and Restoration. 4th ed. New York: Oxford University Press.

Miller, J. Maxwell, and John H. Hayes. 2009. A History of Ancient Israel and Judah. Louisville: Westminster John Knox Press.

Porter, Stanley E. 1997. The Literary Function of Possessive Pronouns in the Gospel of Matthew. New York: Peter Lang.

Rankin, H. O. 2002. Redaction Criticism and the Gospels. Atlanta: Scholars Press.

Robison, John W. 2008. The Text of Mark: A Study of the Endings. Atlanta: Scholars Press.

Safrai, Shmuel. 1990. The Literature of the Sages, Second Temple and Apocalyptic Periods. Grand Rapids: Eerdmans.

Stein, Robert H. 2008. “The Ending of Mark.” Bulletin for Biblical Research 18 (1): 79–100.

Wallace, Daniel B. 2008. Reexamining the Textual Evidence for the Ending of Mark. Fearn: Paternoster Press.

———. 2013. “Where Is the Story of the Woman Caught in Adultery Really From?” 2013. https://danielbwallace.com/2013/06/26/where-is-the-story-of-the-woman-caught-in-adultery-really-from/.

Wright, N. T. 2003. The Resurrection of the Son of God. Minneapolis: Fortress Press.

Early third-century papyrus manuscript (P66) of the Gospel of John; a principal early witness for establishing textual readings in John.↩︎
Early third-century papyrus (P75) containing substantial portions of Luke and John; closely aligned with Codex Vaticanus and important for the Alexandrian text tradition.↩︎
An uncial codex is a manuscript written in a majuscule, all-capital script used from the third to eighth centuries; codices allowed writing on both sides of leaves and facilitated reference to discrete passages.↩︎
Fourth-century parchment codex containing most of the Christian Bible; a principal Alexandrian witness with significant authority in textual criticism.↩︎
Fourth-century parchment codex (Vat. gr. 1209); a foundational Alexandrian witness for both the Septuagint and New Testament texts.↩︎
Fifth-century bilingual Greek–Latin codex notable for its Western text-type readings and for preserving variant traditions of the Gospels and Acts.↩︎
The Synoptic Gospels (Matthew, Mark, and Luke) are called “synoptic” because they can be viewed together in parallel and share extensive overlap in content and sequence; their interrelationships are central to critical study of the Gospels and to reconstructing early Jesus traditions.↩︎
The Sinai peninsula is the triangular desert landbridge between Africa and Asia where the biblical narrative places the Israelites’ wandering; archaeologically it is challenging terrain for preservation of ephemeral nomadic campsites.↩︎
The Late Bronze Age (c. 1550–1200 BCE) is the archaeological period conventionally associated with the late Egyptian Empire and the historical horizon often connected to the Exodus and the early Israelite settlement in Canaan.↩︎
Emmaus is the village to which Luke narrates two disciples traveling when they encounter the risen Jesus; it functions as a key locale in Luke’s resurrection narrative.↩︎

ZEKAR's Blog

Why I built my own static site generator

Why I built my own static site generator

Using Hugo

Using staw

Creating my own

My requirements were simple enough

Feed

Indexes

The final result

Usage

Nix hanging during system rebuild (Solution Included)

Nix hanging during system rebuild (Solution Included)

The error

The luckiest error message ever

Setting Up VimWiki with `when`: My Minimalist Agenda Workflow

Setting Up VimWiki with when: My Minimalist Agenda Workflow

Why when?

Directory Layout

Declarative Symlinks with Home Manager

Breakdown

When Tools Ignore Their Own Man Pages

Maybe the Environment Variable?

Goodbye XDG

A Test Event: Does This Actually Work?

Integrating when with VimWiki

Conclusion

Thoughts after installing KISS Linux

Thoughts after installing KISS Linux

What’s KISS Linux

Installation

Grub

Initramfs

Kernel

After installation

Installing Nix in Kiss

Conclusion

The Problem With "Encrypted" Email Providers

The Problem With “Encrypted” Email Providers

Why email is was cool

Why email sucks now

Why “Encrypted” Email Providers are Problematic

E2EE should be done at the client level, not a the provider level.

Using these services is better than using any other “normal” provider.

The self-hosting trap

The real solution

How can you trust such a ridiculous name?

The real solution

The catch

My take on perfectionism

My take on perfectionism

Is Perfection Attainable?

We Should All Strive for Perfection

Holistic perfection vs superficial perfection

The Trap of Superficial Perfection

The Power of Holistic Perfection

Possible Criticism & Rebuttals

Perfect people are annoying.

Striving for perfection is exhausting.

Failure is natural, why fight it?

Being perfect in everyting is unrealistic.

My experience with perfectionism.

Why you shouldn't use the fish shell

Why you shouldn’t use the fish shell

The Friendly Interactive SHell

Fish vs POSIX

Other shells vs POSIX

Why POSIX Compliance Matters

Conclusion

The (not-so-problematic) Problem of Evil

The (not-so-problematic) Problem of Evil

I.I The problem of Evil

I.II Theodicies

Free Will

Soul-Making Theodicy & Greater Good Theodicy

Punishment Theodicy

I.III The Argument from Morality

The Core of the Argument:

II The logical conclusion

Morally Problematic Acts Endorsed by God in the Bible.

Setting Up VimWiki with `when`: My Minimalist Agenda Workflow

Why `when`?

Integrating `when` with VimWiki