From 68b1042c9711b5898764d2b0d889d6bf39f8d45b Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sun, 31 Aug 2025 15:50:22 +0300 Subject: Update content for html --- about/showcase.html | 559 +++++++++++++++++++++++++++++++++------------------- 1 file changed, 358 insertions(+), 201 deletions(-) diff --git a/about/showcase.html b/about/showcase.html index dae182b3..546015b1 100644 --- a/about/showcase.html +++ b/about/showcase.html @@ -23,35 +23,69 @@
  • Project Showcase
  • ⇢ Overall Statistics
  • ⇢ Projects
    • +
  • ⇢ ⇢ hexai
    • +
  • Hexai
    • +
  • ⇢ ⇢ conf
  • ⇢ ⇢ rexfiles
    • +
  • ⇢ ⇢ hxcode
    • +
  • HxCode
  • ⇢ ⇢ totalrecall
    • +
  • totalrecall - Bulgarian Anki Flashcard Generator
  • ⇢ ⇢ gitsyncer
    • +
  • GitSyncer
  • ⇢ ⇢ timr
    • +
  • timr
  • ⇢ ⇢ tasksamurai
    • +
  • Task Samurai
  • ⇢ ⇢ ior
    • +
  • I/O Riot NG (aka ior)
  • ⇢ ⇢ dtail
  • ⇢ ⇢ wireguardmeshgenerator
    • +
  • WireGuard Mesh Generator
  • ⇢ ⇢ foostats
    • +
  • foostats
  • ⇢ ⇢ ds-sim
    • +
  • DS-Sim
  • ⇢ ⇢ sillybench
    • +
  • Silly Benchmark
  • ⇢ ⇢ gos
    • +
  • Gos (Go Social Media)
  • ⇢ ⇢ rcm
    • +
  • rcm
  • ⇢ ⇢ gemtexter
  • ⇢ ⇢ docker-gpodder-sync-server
  • ⇢ ⇢ docker-radicale-server
  • ⇢ ⇢ quicklogger
    • +
  • Quick logger
  • ⇢ ⇢ terraform
    • +
  • Terraform
  • ⇢ ⇢ docker-anki-sync-server
  • ⇢ ⇢ gogios
    • +
  • Gogios
  • ⇢ ⇢ gorum
    • +
  • Gorum
  • ⇢ ⇢ guprecords
    • +
  • guprecords - Global uptime records
  • ⇢ ⇢ randomjournalpage
    • +
  • Read a random journal
  • ⇢ ⇢ sway-autorotate
    • +
  • sway-autorotate
  • ⇢ ⇢ algorithms
  • ⇢ ⇢ geheim
    • +
  • geheim.rb
  • ⇢ ⇢ foo.zone
  • ⇢ ⇢ perl-c-fibonacci
  • ⇢ ⇢ ioriot
    • +
  • I/O Riot
    • +
  • ⇢ Overview
    • +
  • ⇢ Benefits
    • +
  • Send in patches
    • +
  • How to install I/O Riot
    • +
  • How to use I/O Riot
    • +
  • Appendix
    • +
  • ⇢ Supported file systems
    • +
  • ⇢ Supported syscalls
    • +
  • ⇢ Source code documentation
  • ⇢ ⇢ photoalbum
  • ⇢ ⇢ staticfarm-apache-handlers
  • ⇢ ⇢ dyndns
    • @@ -83,18 +117,65 @@

    Overall Statistics




    Projects



    +

    hexai


    +
    +
    +
    +hexai screenshot
    +
    +

    Hexai


    +
    +View on Codeberg
    +View on GitHub
    +
    +---
    +
    +

    conf


    +
    +
    +
    +Certainly! However, the provided description ("Bapdidu di du di du dap dap dap!") does not contain any technical or contextual information about the "Jupdidu" project. To give a meaningful summary, I would need details such as the project's purpose, its main features, how it is implemented, and its architecture.
    +
    +If you can provide a README, project documentation, or a brief description of what Jupdidu does, I can summarize it clearly and concisely, focusing on its functionality, usefulness, and technical implementation. Please share more information or context about the project!
    +
    +View on Codeberg
    +View on GitHub
    +
    +---
    +

    rexfiles





    -Based on my analysis of the codebase, **rexfiles** is a comprehensive infrastructure automation and configuration management project built with the Rex framework (a Perl-based alternative to Ansible, Puppet, or Chef). The project provides structured automation for managing multiple aspects of a personal infrastructure, including dotfiles, server configurations, and application deployments.
    -
    -The project consists of three main components: **dotfiles** management for personal development environment configuration (bash, fish shell, helix editor, tmux, etc.), **frontends** for managing production OpenBSD servers with services like DNS (nsd), web servers (httpd), mail (OpenSMTPD), SSL certificates (ACME), and monitoring systems, and **babylon5** containing Docker container startup scripts for self-hosted applications. The implementation leverages Rex's declarative syntax to define tasks for package installation, file management, service configuration, and system state management, with templates for configuration files and support for multiple operating systems (OpenBSD, FreeBSD, Fedora Linux, Termux). This approach provides a KISS (Keep It Simple, Stupid) alternative to more complex configuration management tools while maintaining the ability to manage both local development environments and production infrastructure consistently.
    +Jupdidu
    +=======

    View on Codeberg
    View on GitHub

    ---

    +

    hxcode


    +
    +
    +
    +

    HxCode


    +
    +View on Codeberg
    +View on GitHub
    +
    +---
    +

    totalrecall





    -GitSyncer is a cross-platform repository synchronization tool that automatically keeps Git repositories in sync across multiple hosting platforms like GitHub, Codeberg, and private SSH servers. It solves the common problem of maintaining consistent code across different Git hosting services by cloning repositories, adding all configured platforms as remotes, and continuously merging and pushing changes bidirectionally while handling branch creation and conflict detection.
    -
    -The tool is implemented in Go with a clean architecture that supports both individual repository syncing and bulk operations for public repositories. Key features include automatic repository creation, SSH backup locations for private servers, branch exclusion patterns, and an opt-in backup mode for resilient offline backups. It uses a JSON configuration file to define organizations and repositories, employs safe merge strategies that never delete branches, and provides comprehensive error handling for merge conflicts and missing repositories.
    +

    GitSyncer



    View on Codeberg
    View on GitHub
    @@ -179,15 +274,13 @@
  • 📈 Lines of Code: 873
  • 📄 Lines of Documentation: 137
  • 📅 Development Period: 2025-06-25 to 2025-07-19
    • -
  • 🔥 Recent Activity: 64.0 days (avg. age of last 42 commits)
    • +
  • 🔥 Recent Activity: 64.1 days (avg. age of last 42 commits)
  • ⚖️ License: BSD-2-Clause
  • 🏷️ Latest Release: v0.0.0 (2025-06-29)
  • 🎵 Vibe-Coded: This project has been vibe coded


    • -timr is a minimalist command-line time tracking tool written in Go that provides a simple stopwatch-style timer for tracking work sessions. It offers commands to start, stop, reset, and check the status of the timer, with all state persisted across sessions in ~/.config/timr/.timr_state. The tool is particularly useful for developers and professionals who need to track time spent on tasks without the overhead of complex time-tracking applications.
    -
    -The project is implemented using a clean modular architecture with the CLI entry point in /cmd/timr/main.go, core timer logic in /internal/timer/, and an interactive TUI mode powered by Bubble Tea in /internal/live/. Key features include persistent state across sessions, shell prompt integration for displaying timer status, raw output modes for scripting, and a full-screen live timer interface with keyboard controls. The tool maintains atomic state updates and handles unexpected exits gracefully by immediately persisting state changes.
    +

    timr



    View on Codeberg
    View on GitHub
    @@ -203,7 +296,7 @@
  • 📈 Lines of Code: 6160
  • 📄 Lines of Documentation: 162
  • 📅 Development Period: 2025-06-19 to 2025-07-12
    • -
  • 🔥 Recent Activity: 65.8 days (avg. age of last 42 commits)
    • +
  • 🔥 Recent Activity: 65.9 days (avg. age of last 42 commits)
  • ⚖️ License: BSD-2-Clause
  • 🏷️ Latest Release: v0.9.2 (2025-07-02)
  • 🎵 Vibe-Coded: This project has been vibe coded
    • @@ -211,11 +304,7 @@
    tasksamurai screenshot

    -TaskSamurai is a fast terminal user interface (TUI) for Taskwarrior written in Go that provides a keyboard-driven table interface for task management. It acts as a visual frontend to the Taskwarrior command-line tool, displaying tasks in a table format where users can perform operations like adding, completing, starting, and annotating tasks through hotkeys without leaving their keyboard. The application was created to provide a faster alternative to existing Python-based UIs while exploring the Bubble Tea framework for Go terminal applications.
    -
    -tasksamurai screenshot
    -
    -The implementation follows a clean architecture with clear separation of concerns: the internal/task/ package handles all Taskwarrior CLI integration by executing task commands and parsing JSON responses, while internal/ui/ manages the terminal interface using Bubble Tea's message-driven architecture. The custom table widget in internal/atable/ provides efficient rendering for large task lists, and the entire system maintains real-time synchronization with Taskwarrior by automatically refreshing the display after each operation. The application supports all standard Taskwarrior filters as command-line arguments and includes features like regex search, customizable themes, and even a "disco mode" that changes colors dynamically.
    +

    Task Samurai



    View on Codeberg
    View on GitHub
    @@ -239,13 +328,7 @@
    ior screenshot

    -Based on my analysis of the codebase, here's a comprehensive summary of the I/O Riot NG (ior) project:
    -
    -ior screenshot
    -
    -**I/O Riot NG** is a Linux-based performance monitoring tool that uses eBPF (extended Berkeley Packet Filter) to trace synchronous I/O system calls and analyze their execution times. This tool is particularly valuable for system performance analysis, allowing developers and system administrators to visualize I/O bottlenecks through detailed flamegraphs. It serves as a modern successor to the original I/O Riot project, migrating from SystemTap/C to a Go/C/BPF implementation for better performance and maintainability.
    -
    -The architecture combines kernel-level tracing with user-space analysis: eBPF programs (internal/c/ior.bpf.c) attach to kernel tracepoints to capture syscall entry/exit events, which are then processed by a Go-based event loop (internal/eventloop.go) that correlates enter/exit pairs, tracks file descriptors, and measures timing. The tool can operate in real-time mode for live monitoring or post-processing mode to generate flamegraphs from previously collected data using the Inferno flamegraph library. Key features include filtering capabilities for specific processes or file patterns, comprehensive statistics collection, and support for various I/O syscalls like open, read, write, close, and dup operations.
    +

    I/O Riot NG (aka ior)



    View on Codeberg
    View on GitHub
    @@ -269,11 +352,8 @@
    dtail screenshot

    -DTail is a distributed log processing system written in Go that allows DevOps engineers to tail, cat, and grep log files across thousands of servers concurrently. It provides secure access through SSH authentication and respects UNIX file system permissions, making it ideal for enterprise environments where log analysis needs to scale horizontally across large server fleets. The tool supports advanced features like compressed file handling (gzip/zstd) and distributed MapReduce aggregations for complex log analytics.
    -
    -dtail screenshot
    -
    -The system uses a client-server architecture where dtail servers run on target machines (listening on port 2222) and clients connect to multiple servers simultaneously. It can also operate in serverless mode for local operations. The implementation leverages SSH for secure communication, includes sophisticated connection throttling and resource management, and provides specialized tools (dcat, dgrep, dmap) for different log processing tasks. The MapReduce functionality supports SQL-like queries with server-side local aggregation and client-side final aggregation, enabling powerful distributed analytics across log data.
    +DTail
    +=====

    View on Codeberg
    View on GitHub
    @@ -294,9 +374,7 @@
  • 🏷️ Latest Release: v1.0.0 (2025-05-11)


    • -WireGuard Mesh Generator is a Ruby-based automation tool that simplifies the creation and management of WireGuard mesh VPN networks across multiple hosts. It automatically generates WireGuard configuration files for each node in the mesh, handles cryptographic key generation and management (including public/private keys and preshared keys), and provides automated deployment to remote machines via SSH/SCP. The tool is particularly useful for setting up secure, encrypted mesh networks between multiple servers or devices, eliminating the manual overhead of configuring WireGuard connections between every pair of nodes.
    -
    -The implementation uses a YAML configuration file to define the network topology, including host details, SSH credentials, and network addressing schemes. It supports mixed operating systems (FreeBSD, Linux, OpenBSD) with OS-specific configuration handling, intelligently determines network connectivity patterns (LAN vs internet-facing hosts), and includes features like NAT traversal detection and persistent keepalive configuration. The tool provides a complete workflow from key generation to deployment, making it ideal for infrastructure automation and maintaining consistent WireGuard mesh networks across diverse environments.
    +

    WireGuard Mesh Generator



    View on Codeberg
    View on GitHub
    @@ -317,9 +395,7 @@
  • 🏷️ Latest Release: v0.1.0 (2025-07-12)


    • -Based on the README and project structure, **foostats** is a privacy-respecting web analytics tool written in Perl specifically designed for OpenBSD systems. It processes both traditional HTTP/HTTPS logs and Gemini protocol logs to generate comprehensive traffic statistics while maintaining visitor privacy through SHA3-512 IP hashing. The tool is built for the foo.zone ecosystem and similar sites that need analytics without compromising user privacy.
    -
    -The project implements a modular architecture with seven core components: FileHelper for I/O operations, DateHelper for date management, Logreader for log parsing, Filter for security filtering, Aggregator for statistics collection, FileOutputter for compressed JSON storage, Replicator for multi-node data sharing, Merger for combining statistics, and Reporter for generating human-readable Gemtext reports. It supports distributed deployments with replication between partner nodes and includes security features like suspicious request filtering based on configurable patterns (blocking common attack vectors like WordPress admin paths and PHP files).
    +

    foostats



    View on Codeberg
    View on GitHub
    @@ -335,7 +411,7 @@
  • 📈 Lines of Code: 25762
  • 📄 Lines of Documentation: 3101
  • 📅 Development Period: 2008-05-15 to 2025-06-27
    • -
  • 🔥 Recent Activity: 138.0 days (avg. age of last 42 commits)
    • +
  • 🔥 Recent Activity: 138.1 days (avg. age of last 42 commits)
  • ⚖️ License: Custom License
  • 🧪 Status: Experimental (no releases yet)
  • 🤖 AI-Assisted: This project was partially created with the help of generative AI
    • @@ -343,9 +419,7 @@
    ds-sim screenshot

    -DS-Sim is an open-source Java-based simulator for distributed systems that provides a comprehensive environment for learning and experimenting with distributed algorithms. It features protocol simulation, event handling, and implementations of time concepts like Lamport and Vector timestamps. The simulator includes an interactive Swing GUI and comprehensive logging capabilities, making it particularly valuable for educational purposes and distributed systems research.
    -
    -The project is built on an event-driven architecture with clear component separation. At its core, VSSimulator drives the simulation loop with VSTaskManager executing time-ordered tasks, while VSAbstractProcess provides the foundation for simulation processes. The framework supports pluggable protocols through VSAbstractProtocol base classes, includes sophisticated time management with multiple clock types, and uses VSMessage objects for network communication simulation. The Maven-based architecture follows standard Java conventions and includes 141 unit tests covering core components like Two-Phase Commit, Berkeley Time synchronization, and PingPong protocols.
    +

    DS-Sim



    View on Codeberg
    View on GitHub
    @@ -366,9 +440,7 @@
  • 🧪 Status: Experimental (no releases yet)


    • -**SillyBench** is a simple Go benchmarking project designed to compare CPU performance between FreeBSD and Linux Bhyve VM environments. The project implements basic mathematical operations (integer multiplication and floating-point arithmetic) to measure computational performance differences across different operating systems and virtualization setups.
    -
    -The implementation is minimal and focused, consisting of a basic Go module with two CPU-intensive benchmark functions: BenchmarkCPUSilly1 performs simple integer squaring operations, while BenchmarkCPUSilly2 executes more complex floating-point calculations involving addition, multiplication, and division. The project includes a simple shell script (run.sh) that executes the benchmarks using Go's built-in testing framework, making it easy to run consistent performance comparisons across different systems.
    +

    Silly Benchmark



    View on Codeberg
    View on GitHub
    @@ -391,11 +463,7 @@
    gos screenshot

    -Gos is a command-line social media scheduling tool written in Go that serves as a self-hosted replacement for Buffer.com. It allows users to create, queue, and schedule posts across multiple platforms (currently Mastodon, LinkedIn, and a "Noop" tracker platform) using a simple file-based approach. Users compose posts as text files in a designated directory (~/.gosdir), and can control posting behavior through filename tags (e.g., share:mastodon, prio, now) or inline tags within the content.
    -
    -gos screenshot
    -
    -The tool is architected around a file-based queueing system where posts progress through lifecycle stages: .txt files are processed into platform-specific queues (.queued files), then marked as .posted after successful publishing. It features intelligent scheduling based on configurable targets (posts per week), pause periods between posts, priority handling, and OAuth2 authentication for LinkedIn. The system includes pause functionality for vacations, dry-run mode for testing, and can generate Gemini Gemtext summaries of posted content. Its design emphasizes automation, configurability, and integration into command-line workflows while maintaining a clean separation between platforms through a common interface.
    +

    Gos (Go Social Media)



    View on Codeberg
    View on GitHub
    @@ -416,9 +484,7 @@
  • 🧪 Status: Experimental (no releases yet)


    • -RCM (Ruby Configuration Management) is a lightweight, KISS (Keep It Simple, Stupid) configuration management system written in Ruby and designed for personal use. The project provides a domain-specific language (DSL) for declaratively managing system configuration, including files, directories, symlinks, and packages. It serves as an alternative to more complex configuration management tools like Ansible or Puppet, focusing on simplicity and ease of use for individual system administration tasks.
    -
    -The system is implemented with a modular architecture centered around a DSL class that provides keywords for different resource types (file, directory, symlink, touch, package). Each resource type inherits from a base Resource class and implements specific evaluation logic for creating, modifying, or removing system resources. Key features include automatic backup functionality (with SHA256 checksums), ERB template support, conditional execution, parent directory management, and support for file permissions and ownership. The system uses a declarative approach where users define desired states in configuration blocks, and RCM handles the imperative steps to achieve those states, making it particularly useful for personal dotfile management and system configuration automation.
    +

    rcm



    View on Codeberg
    View on GitHub
    @@ -439,9 +505,8 @@
  • 🏷️ Latest Release: 3.0.0 (2024-10-01)


    • -**Gemtexter** is a static site generator and blog engine that transforms content written in Gemini Gemtext format into multiple output formats. It's a comprehensive Bash-based tool designed to support the Gemini protocol (a simpler alternative to HTTP) while maintaining compatibility with traditional web technologies. The project converts a single source of Gemtext content into HTML (XHTML 1.0 Transitional), Markdown, and native Gemtext formats, enabling authors to write once and publish across multiple platforms including Gemini capsules, traditional websites, and GitHub/Codeberg pages.
    -
    -The implementation is built entirely in Bash (version 5.x+) using a modular library approach with separate source files for different functionality (atomfeed, gemfeed, HTML generation, Markdown conversion, templating, etc.). Key features include automatic blog post indexing, Atom feed generation, customizable HTML themes, source code highlighting, Bash-based templating system, and integrated Git workflow management. The architecture separates content directories by format (gemtext/, html/, md/) and includes comprehensive theming support, font embedding, and publishing workflows that can automatically sync content to multiple Git repositories for deployment on various platforms.
    +The Gemtexter blog engine and static site generator
    +===================================================

    View on Codeberg
    View on GitHub
    @@ -462,9 +527,9 @@
  • 🧪 Status: Experimental (no releases yet)


    • -This project is a **Docker containerization wrapper for a GPodder sync server**, specifically built around the micro-gpodder-server implementation from https://github.com/bohwaz/micro-gpodder-server. GPodder is a podcast client that allows users to synchronize their podcast subscriptions and episode states across multiple devices. The sync server enables this synchronization by providing a centralized service that podcast clients can connect to for managing subscriptions, episode progress, and playback history.
    +This project provides a Dockerized build environment for the GPodder sync server, specifically targeting the [mygpo](https://github.com/gpodder/mygpo) backend. The GPodder sync server enables users to synchronize podcast subscriptions and playback progress across multiple devices and clients, making it easier to keep listening experiences consistent. By containerizing the server with Docker, the project simplifies deployment and management, ensuring that all dependencies and configurations are encapsulated and reproducible.

    -The project is implemented as a simple Docker build system with a Makefile that provides convenient commands for building, running, and deploying the containerized service. The actual server code is included as a git submodule, while this wrapper provides infrastructure automation including data persistence through volume mounting (./data to /var/www/server/data), network configuration (port 8080 exposure), and AWS ECR deployment capabilities. This approach makes it easy to deploy a self-hosted GPodder sync server with minimal setup, useful for podcast enthusiasts who want to maintain their own synchronization service rather than relying on third-party services.
    +The implementation centers around a Dockerfile and related configuration files that automate the setup of the mygpo server, including its Python dependencies and any required services (such as a database). Key features include ease of deployment (just a few Docker commands to get started), isolation from the host system, and portability across different environments. The architecture leverages Docker’s layered image system to build, run, and update the GPodder sync server efficiently, making it accessible for both development and production use.

    View on Codeberg
    View on GitHub
    @@ -485,9 +550,9 @@
  • 🧪 Status: Experimental (no releases yet)


    • -This project is a **Docker containerization setup for Radicale**, a CalDAV and CardDAV server written in Python. Radicale is a lightweight, standards-compliant calendar and contacts server that allows users to synchronize their calendars and address books across multiple devices and applications. The project provides a complete Docker image and deployment configuration that makes it easy to run a personal or small-team calendar/contacts server.
    +This project provides a Docker image for the [Radicale server](https://radicale.org), an open-source CalDAV and CardDAV server for managing calendars and contacts. By containerizing Radicale, the project makes it easy to deploy and run the server in isolated, reproducible environments, simplifying installation and upgrades. Users can quickly set up a personal or small-team calendar/contact server without worrying about system dependencies or manual configuration.

    -The implementation uses Alpine Linux as the base image for a minimal footprint, installs Python 3 and Radicale via pip, and configures the server with HTTP basic authentication using htpasswd. The setup includes persistent storage for collections (calendars/contacts) and authentication data through Docker volumes, exposes the service on port 8080, and includes a Makefile for easy building and deployment. The project also supports pushing to AWS ECR for cloud deployment, making it suitable for both local development and production use cases where you need a self-hosted alternative to cloud-based calendar services.
    +The Docker image is built to be lightweight and configurable, exposing necessary ports and allowing persistent storage of data via Docker volumes. The architecture typically involves a Dockerfile that installs Radicale and its dependencies, sets up configuration files, and defines entrypoints for running the server. This approach ensures portability, consistency across environments, and ease of integration with orchestration tools like Docker Compose or Kubernetes. Key features include simplified deployment, secure isolation, and support for custom configuration through environment variables or mounted files.

    View on Codeberg
    View on GitHub
    @@ -510,11 +575,7 @@
    quicklogger screenshot

    -**QuickLogger** is a minimalist Go-based GUI application built with the Fyne framework that's designed for rapid text note capture, primarily targeting mobile Android devices. It provides a simple interface for quickly logging thoughts, ideas, or notes to timestamped Markdown files (ql-YYMMDD-HHMMSS.md) with customizable categorization through dropdown menus for tags, activities, and time periods. The app is optimized for mobile use with features like character count indicators, text length warnings, and a clear button for quick text clearing.
    -
    -quicklogger screenshot
    -
    -The project follows a clean, single-file architecture with all functionality contained in main.go, making it easy to understand and maintain. It includes both a main logging interface and a preferences window for customizing save directories and dropdown options. The build system supports cross-platform compilation with special focus on Android APK generation, and the saved files are designed to work well with file syncing tools like Syncthing, making it a practical tool for capturing notes on mobile devices that can be automatically synchronized across multiple devices.
    +

    Quick logger



    View on Codeberg
    View on GitHub
    @@ -535,9 +596,7 @@
  • 🧪 Status: Experimental (no releases yet)


    • -This is a comprehensive personal cloud infrastructure project built with Terraform that deploys a multi-tier AWS architecture for hosting self-hosted services. The infrastructure is organized into modular components: org-buetow-base provides the foundation (VPC, subnets, EFS storage, ECR), org-buetow-bastion creates a bastion host for secure access, org-buetow-elb sets up application load balancing, and org-buetow-ecs runs containerized services on AWS Fargate. The project also includes an EKS cluster option with EFS CSI driver integration for Kubernetes workloads.
    -
    -The system is designed to host multiple personal services including Anki sync server, Audiobookshelf, Vaultwarden, Syncthing, Radicale (CalDAV/CardDAV), and others, all with persistent storage via EFS and secure TLS termination. The architecture follows AWS best practices with remote state management in S3, proper networking isolation, and automated backups, making it useful for individuals wanting to run their own private cloud services with enterprise-grade reliability and security.
    +

    Terraform



    View on Codeberg
    View on GitHub
    @@ -558,9 +617,9 @@
  • 🧪 Status: Experimental (no releases yet)


    • -This project is a Docker containerization of the Anki sync server, designed to provide a self-hosted synchronization service for Anki flashcard applications. Anki is a popular spaced repetition learning tool, and this project allows users to run their own sync server instead of relying on AnkiWeb's hosted service, giving them full control over their data privacy and synchronization infrastructure.
    +The **docker-anki-sync-server** project provides a Docker image for running an Anki sync server, which enables users to synchronize their Anki flashcard collections across multiple devices without relying on AnkiWeb. This is particularly useful for individuals or organizations who want to maintain control over their data, improve privacy, or operate in environments with restricted internet access. By containerizing the sync server, the project simplifies deployment, making it easy to set up a consistent and isolated environment on any system that supports Docker.

    -The implementation is built using a Rocky Linux base image with Python 3.9, and it integrates the community-maintained anki-sync-server project. The Dockerfile:dockerfile:1-19 sets up the environment by installing dependencies, configuring data paths for collections and authentication databases to persist in /data, and running the service under a dedicated user for security. The Makefile:makefile:1-12 provides build automation that clones the upstream anki-sync-server repository and includes AWS ECR deployment capabilities for cloud hosting. This containerized approach makes it easy to deploy and manage an Anki sync server across different environments while maintaining data persistence through volume mounts.
    +The implementation centers around creating a Docker image that packages the official Anki sync server along with its dependencies. The Dockerfile automates the installation and configuration process, exposing necessary ports and allowing for environment variable customization. Users can launch the server with a single command, and it integrates seamlessly with Anki clients by specifying the custom sync server URL. The architecture leverages Docker’s portability and isolation, ensuring that updates, scaling, and maintenance are straightforward and reproducible.

    View on Codeberg
    View on GitHub
    @@ -584,9 +643,7 @@
    gogios screenshot

    -Gogios is a lightweight, minimalistic monitoring tool written in Go designed for small-scale server monitoring. It executes standard Nagios-compatible check plugins and sends email notifications only when service states change, making it ideal for personal infrastructure or small environments with limited resources. The tool emphasizes simplicity over complexity, avoiding the bloat of enterprise monitoring solutions like Nagios, Icinga, or Prometheus by eliminating features like web UIs, databases, contact groups, and clustering.
    -
    -The implementation follows a clean architecture with concurrent check execution, dependency management, and persistent state tracking. Key features include state-based notifications (only alerts on status changes), configurable retry logic, federation support for distributed monitoring, and stale detection for checks that haven't run recently. The tool is configured via JSON and requires only a local mail transfer agent for notifications. It's designed to run via cron jobs and supports high-availability setups through simple dual-server configurations, making it perfect for users who want effective monitoring without operational overhead.
    +

    Gogios



    View on Codeberg
    View on GitHub
    @@ -602,15 +659,13 @@
  • 📈 Lines of Code: 1525
  • 📄 Lines of Documentation: 15
  • 📅 Development Period: 2023-04-17 to 2023-11-19
    • -
  • 🔥 Recent Activity: 754.0 days (avg. age of last 42 commits)
    • +
  • 🔥 Recent Activity: 754.1 days (avg. age of last 42 commits)
  • ⚖️ License: Custom License
  • 🧪 Status: Experimental (no releases yet)

    • ⚠️ **Notice**: This project appears to be finished, obsolete, or no longer maintained. Last meaningful activity was over 2 years ago. Use at your own risk.

    -Gorum is a minimalistic distributed quorum manager written in Go that implements a leader election and consensus mechanism across multiple nodes in a network. The system enables nodes to continuously vote for which node should be the leader based on priority scores, with automatic failover when nodes become unavailable. It's particularly useful for distributed systems that need to maintain a single authoritative node while providing high availability and fault tolerance.
    -
    -The architecture consists of several key components: a quorum manager that handles voting logic and score calculations, TCP-based client/server communication for exchanging votes between nodes, and an email notification system to alert administrators of leadership changes. Each node runs both a server to receive votes from other nodes and a client to send its own votes to peers. The system uses time-based vote expiration to detect failed nodes and automatically removes them from consideration, while priority-based scoring ensures predictable leader selection during normal operations.
    +

    Gorum



    View on Codeberg
    View on GitHub
    @@ -631,9 +686,7 @@
  • 🏷️ Latest Release: v1.0.0 (2023-04-29)


    • -GupRecords is a Raku-based system administration tool that analyzes and reports on system uptime statistics across multiple hosts. It processes raw uptime records from various systems and generates formatted reports showing the top-performing hosts or operating systems based on metrics like uptime, boot count, downtime, and calculated meta-scores.
    -
    -The tool is implemented with a clean object-oriented architecture featuring an Aggregator class that parses record files, Host and OS Aggregate classes that store statistics, and Reporter classes that generate formatted tables. It supports multiple analysis categories (host, OS, OS-major, uname) and various sorting criteria including uptime duration, boot frequency, system lifespan, and downtime. The formatted output includes visual indicators for active systems and provides both duration-based and numerical metrics in a structured table format, making it useful for system administrators to quickly identify the most reliable systems in their infrastructure.
    +

    guprecords - Global uptime records



    View on Codeberg
    View on GitHub
    @@ -655,9 +708,7 @@
    ⚠️ **Notice**: This project appears to be finished, obsolete, or no longer maintained. Last meaningful activity was over 2 years ago. Use at your own risk.

    -**Random Journal Page** is a personal utility script designed to help with journal reflection and review. The project randomly selects a PDF file from a collection of scanned bullet journals and extracts a random set of pages (42 by default) to create a smaller PDF for reading and reflection. This is particularly useful for revisiting past thoughts, book notes, and ideas that were written down over time.
    -
    -The implementation is straightforward - a bash script that uses find to locate PDF files, pdfinfo to determine page counts, and qpdf to extract page ranges. It intelligently handles edge cases like ensuring the extracted range stays within document bounds and automatically opens the result in a PDF viewer (unless run in cron mode). The script stores the extracted pages in the same directory as the source journals (designed for NextCloud sync) so they can be accessed across devices, making it a simple but effective tool for personal knowledge management and reflection.
    +

    Read a random journal



    View on Codeberg
    View on GitHub
    @@ -678,9 +729,7 @@
  • 🧪 Status: Experimental (no releases yet)


    • -**sway-autorotate** is a bash script for automatic screen rotation on tablets running the Sway window manager. It's specifically designed for touch-enabled devices like the Microsoft Surface Go 2 tablet, addressing the common need for automatic screen orientation changes when the device is physically rotated. The project is particularly useful for tablet users who frequently switch between portrait and landscape orientations, as it eliminates the need to manually rotate the display through system settings.
    -
    -The implementation consists of two main components: autorotate.sh monitors the device's orientation sensor using the monitor-sensor command (from iio-sensor-proxy) and automatically rotates both the screen display and input devices (touchpad/touchscreen) to match the physical orientation. The script maps orientation changes ("normal", "right-up", "bottom-up", "left-up") to corresponding rotation angles (0°, 90°, 180°, 270°) and uses swaymsg commands to update the display transform and remap input devices to maintain proper touch coordinates. A simple start.sh launcher runs the autorotate script as a background daemon, making it easy to integrate into system startup routines.
    +

    sway-autorotate



    View on Codeberg
    View on GitHub
    @@ -702,9 +751,9 @@
    ⚠️ **Notice**: This project appears to be finished, obsolete, or no longer maintained. Last meaningful activity was over 2 years ago. Use at your own risk.

    -This is a comprehensive Go-based algorithms and data structures educational project that implements fundamental computer science concepts for learning and practice. The codebase is organized into four main packages: data structures (ds), sorting algorithms (sort), search algorithms (search), and priority queues (queue), with extensive test coverage and benchmarking capabilities.
    +This project is a collection of exercises and implementations based on an Algorithms lecture, designed primarily as a refresher for fundamental algorithmic concepts. It provides a structured environment for practicing and testing various algorithms, making it useful for students or professionals looking to reinforce their understanding of algorithm design and analysis. The project includes both unit tests and benchmarking capabilities, allowing users to verify correctness and measure the performance of their solutions.

    -The project leverages Go's generics system to provide type-safe implementations of classic algorithms like quicksort, mergesort, binary search trees, red-black trees, and hash tables. It includes both elementary and advanced implementations (parallel sorting, various priority queue implementations) and appears to be designed as educational material for an algorithms course. The architecture emphasizes clean separation of concerns with shared type definitions, comprehensive testing via make test, and performance analysis through make bench, making it a valuable resource for understanding algorithmic complexity and implementation patterns in Go.
    +The architecture is straightforward: algorithm implementations are organized in source files, with accompanying test suites to ensure reliability. The use of Makefile commands (e.g., make test and make bench) streamlines the process of running tests and benchmarks, promoting good development practices. This setup encourages iterative development and performance tuning, making the project both educational and practical for algorithm study and review.

    View on Codeberg
    View on GitHub
    @@ -725,11 +774,7 @@
  • 🧪 Status: Experimental (no releases yet)


    • -Based on my analysis of the project, here's a concise summary:
    -
    -**Geheim** is a Ruby-based encrypted document storage system that provides secure, Git-backed storage for sensitive files and data. It uses AES-256-CBC encryption with PIN-based initialization vectors to protect both file contents and filenames, storing everything in an encrypted Git repository that can be synchronized across multiple remotes for geo-redundancy.
    -
    -The system is architected around several key components: a configuration system for customization, an encryption module handling AES operations, Git integration for version control and sync, and a CLI interface supporting both interactive shell mode and direct commands. Key features include fuzzy search through encrypted indices using fzf, clipboard integration for password management, secure file shredding, and support for both text and binary files. The implementation uses SHA256-hashed directory structures to organize encrypted data, with separate index files containing metadata and data files containing the actual encrypted content, making it suitable for personal document encryption with strong security practices.
    +

    geheim.rb



    View on Codeberg
    View on GitHub
    @@ -744,15 +789,14 @@
  • 📈 Lines of Code: 0
  • 📄 Lines of Documentation: 23
  • 📅 Development Period: 2021-05-21 to 2022-04-02
    • -
  • 🔥 Recent Activity: 1498.6 days (avg. age of last 42 commits)
    • +
  • 🔥 Recent Activity: 1498.7 days (avg. age of last 42 commits)
  • ⚖️ License: No license found
  • 🧪 Status: Experimental (no releases yet)

    • ⚠️ **Notice**: This project appears to be finished, obsolete, or no longer maintained. Last meaningful activity was over 2 years ago. Use at your own risk.

    -This is **foo.zone**, a personal blog and technical website belonging to Paul Buetow, a Site Reliability Engineer based in Sofia, Bulgaria. The project is a static website that serves as a comprehensive platform for sharing technical knowledge, book notes, and personal experiences in the fields of system administration, DevOps, and programming.
    -
    -The site is built using **Gemtexter**, a static site generator that creates both HTML and Gemini protocol content from markdown sources. The architecture is refreshingly simple and follows KISS principles, with content organized into several key sections: a main blog feed (gemfeed) with over 100 technical posts dating back to 2008, detailed book notes and summaries, project documentation (including tools like DTail for distributed log tailing), and personal resources. The website is served by OpenBSD using relayd and httpd, demonstrating the author's preference for robust, security-focused Unix systems. The project emphasizes clean, semantic HTML, custom CSS styling, and accessibility, while maintaining both web and Gemini protocol compatibility for broader reach across different internet communities.
    +The foo.zone internet site
    +===========================

    View on Codeberg
    View on GitHub
    @@ -774,9 +818,7 @@
    ⚠️ **Notice**: This project appears to be finished, obsolete, or no longer maintained. Last meaningful activity was over 2 years ago. Use at your own risk.

    -This project is a fascinating polyglot programming experiment that demonstrates how a single source file can be valid code in multiple programming languages simultaneously. The core file fibonacci.pl.raku.c is cleverly written to be syntactically valid in C, C++, Perl, and Raku, all while implementing the same Fibonacci sequence calculation. It achieves this through strategic use of C preprocessor macros that redefine Perl/Raku-style syntax (like my, sub, BEGIN) into valid C constructs, while the actual logic remains readable in both paradigms.
    -
    -The project is useful as an educational tool for understanding language syntax similarities, demonstrating advanced preprocessor techniques, and showcasing creative programming approaches. The implementation uses a recursive Fibonacci algorithm with a global variable to pass arguments, and the build system (via Makefile) compiles and runs the same source code with four different language compilers/interpreters (gcc, g++, perl, raku) to prove it produces identical output across all platforms. This polyglot approach makes it both a technical curiosity and a practical demonstration of cross-language compatibility.
    +perl-c-fibonacci: source code repository.

    View on Codeberg
    View on GitHub
    @@ -800,10 +842,153 @@
    ioriot screenshot

    -**I/O Riot** is a Linux I/O benchmarking tool designed to capture real production I/O operations and replay them on load test machines for performance analysis. Unlike traditional benchmarking tools that use artificial I/O patterns, I/O Riot records actual file system operations from production servers and reproduces them exactly on test hardware. This approach enables accurate performance testing, hardware evaluation, and I/O bottleneck identification without the complexity of distributed test environments.
    -
    -The tool is implemented in C for minimal overhead and uses SystemTap for efficient kernel-space I/O capture. The architecture consists of five main components: capture (recording I/O operations), initialization (preparing test environment), replay (executing captured operations), analysis (performance evaluation), and iteration (testing different configurations). It supports major Linux file systems (ext2/3/4, xfs) and over 40 syscalls including read, write, open, close, and various file operations. This makes it particularly valuable for optimizing OS configurations, e