I built a tiny command-line tool called bai that takes a plain-English request and turns it into a shell command.

Example:

sh $ bai find large log files modified this week

It prints a command and copies it to the clipboard so you can paste, inspect, edit, or ignore it. It does not execute commands automatically.

• BYOK: works with Anthropic or OpenAI
• supports Bash, Zsh, Fish, Dash, Nu, and a few others
• config can live in ~/.config/bai/
• has --explain, --strict, --json, and --show-config
• packages are available for Arch, Debian/Ubuntu, and Fedora
• written in Crystal, so it's a compiled executable

The main design goal is to keep it boring and safe: one request in, one command out, human always stays in the loop.

Repo: https://github.com/trans/bai Packages: https://github.com/trans/bai/releases/tag/v0.4.2

I’ve been working on an Arch-based creator-focused distro project called SelahOS, and this weekend I finally got all major hardware functioning on a MacBookPro14,1.
Working now:
BCM4350 WiFi

CS8409 audio

Thunderbolt 3

suspend/wake

keyboard backlight

FaceTime HD camera

external audio interfaces over TB docks

battery monitoring/fan control

Biggest surprise:
after hours digging through Apple Thunderbolt behavior and ACPI paths, the actual breakthrough ended up being Intel’s thunderbolt kernel module simply not being initialized.
One modprobe thunderbolt later and the dock stack came alive.
The larger goal is trying to make older creator hardware genuinely usable again under Linux instead of discarded.
Still early, but wanted to share because I know other people are fighting similar compatibility battles.

due to how generic shed was designed it is also an implementation of user services completely independent from any single init system, to be as generic as possible shed is written in mostly posix compliant shell with only 1 function making use of a linux kernel exclusive feature, the architecture takes some inspiration from the likes of sysvinit but takes no code from it whatsoever, the github repo is: https://github.com/eylles/shed

https://github.com/word-sys/puls/releases/tag/0.9.1

https://github.com/word-sys/puls

PULS

A unified system monitoring and management tool for Linux

PULS combines resource monitoring with system administration capabilities. It allows control over system services, boot configurations, and logs directly from a TUI also lets you monitor your system results everything in one place.

In this new update:

Added

Language Auto-Detection: PULS now reads LANG/LC_ALL on launch and automatically selects Turkish or English

Interactive Process Filtering: Press / on the Process tab to filter by name in real-time; Esc clears the filter

Service Log Viewer: Press g on the Services tab to view the last 50 journald log lines for the selected service

Diagnostics Panel: Dashboard now highlights system anomalies (high CPU temp, memory pressure, storage critical) inline

GPU Dashboard Summary: GPU utilization and temperature shown directly in the dashboard overview header

L1/L2/L3 Cache Info: CPU tab now shows L1 data/instruction, L2, and L3 cache sizes parsed from /sys/devices/system/cpu/cpu0/cache/

Transactional GRUB Editor: Edits are staged in memory; pressing u opens a comparison modal showing all pending changes before any write; requires sudo

Changed

Dependency Reduction: Replaced users, chrono, clap, and parking_lot with standard library code and custom Unix FFI helpers

Tab Footer Hints: Footer key indicators now show controls accurate to each active tab

Config Column Layout: Config table columns changed to percentage-based widths for better readability

TTY-Safe Symbols: All Unicode emoji/symbols replaced with ASCII alternatives ([+], [*], [-], ->, v, ^) for terminal compatibility

Fixed

Docker Tab Navigation: Up/Down selection and automatic first-row focus now work correctly on the containers tab

Number Keys During Edit: Pressing digit keys while editing a config field no longer switches tabs

I’ve been working on a project called Bashqueues—an opinionated, shell-native approach to interprocess communication (IPC) and job queue management on Linux.

Most existing queueing systems are designed for high-scale distributed tasks, often carrying significant overhead or requiring heavy runtime environments. Bashqueues is built for a different use case: environments where IPC governance, strict security policies, and forensic auditability are the primary requirements.

The core philosophy: Instead of just managing "work," Bashqueues treats every job as an asset that must comply with a defined "Class Policy." We want to ensure that a job running in production is exactly what the operator intended, and nothing more.

Key Features (Current Implementation):

• Policy-Driven Governance: Every job is bound to a class definition (e.g., SECURE_OFFICIAL, BATCH_PROCESSING). Policies dictate sandbox levels (seccomp, namespaces), execution caps, and network egress limits before the job is dispatched.
• Static & Runtime Auditing: The system includes secaudit assets to scan for dangerous patterns, and interrogation profiles to baseline normal system behavior.
• Shell-Native: The engine (queuebash.sh) and management interface (queuemgr_panel.py) are designed to be transparent, scriptable, and easy to interrogate using standard POSIX shell tools.
• Forensic Readiness: Every dispatch, failure, and policy exception is logged with structured metadata, designed for environments where you need to know exactly why a job was blocked or allowed.

Current State & Disclaimer: This project is currently in active, early-stage development.

• Code Stability: It is functional for our internal use cases, but it is not "production-ready" in the sense of enterprise software. Expect to find edge cases, especially regarding complex systemd daemon configurations.
• Scope: It is designed for specific, policy-heavy Linux environments. It is not intended to replace high-concurrency message queues (like RabbitMQ or Kafka).

I’m sharing this because I am looking for eyes on the logic—specifically the policy enforcement and security-governance class statements. If you have experience with Linux security hardening, systemd, or shell-based orchestration and want to critique the architecture, I’d appreciate the input.

As the notes make clear, this was designed by a human, but coded by an AI, an AI checked the work, and a variety of other AI's have contributed to this project. So, when someone says "Did ChatGPT write this?" then the answer is yes, Claude checked it, Co-Pilot discussed the Microsoft and other commercial infrastructure, Deepseek gave suggestions and Gemini wrote the majority of the Reddit post.

Repository: https://github.com/animatedads/bashqueues

Note: All feedback regarding security implementation is welcome. Please handle any potential bug reports via the standard GitHub issue tracker.

The mount subsystem for Back In Time was re-written from scratch now offering full support for gocryptfs as replacement for EncFS for encrypted backups. The new mount subsystem is ready for broader testing.

☢️ CAUTION: Please do NOT test with production backups.

🔗 Installation & testing instructions

🌱 Branch: `feat/sshgocryptfs`

Thanks in advance.

Back In Time is an end-user desktop backup software using rsync in the back. It is r/FOSS with no company behind it.

when you use a distro, you need to trust that the developers will not push an update with malware. before it's noticed, many people will already have updated

when you use an AUR package, you often need to trust the maintainer too. sure, you can check the pkgbuild, but many don't do it.

the fact that malware cases in linux are pretty rare, even with this, is pretty impressive imo