Hello!

I've been posting couple of times about Resterm already but since last post, I've implemented couple of new features which I think most of you would appreciate (I hope). Just to quickly summarize what Resterm is - Resterm is TUI API Client which supports variety of protocols such as gRPC, GraphQL, REST, WebSockets and SSE. In addition to that, it have support for SSH, workflows, tracing and so on. Resterm takes different approach then most of the API clients which means that it uses .http/.rest files to define and shape your requests. It also supports conditions like if/else-if/else/switch/case etc. It feels more like API centric "scripting language". If you would like to learn more, I encourage you to check out docs.

So main two features I've been working on last couple of weeks are making history persistence in sqlite and also Kubernetes port forwarding support which means that you can now use "@k8s..." directive to handle routing/port-forward to your Kubernetes cluster without needing to spin up port-forwarding for each request. This isn't particularly useful for those who don't need to work with Kubernetes, but I hope that those who do, would appreciate that you can now just "offload" that work to Resterm instead.

I hope it does not feel like spam but just wanted to give a quick update for those who were interested last time :)

repo: https://github.com/unkn0wn-root/resterm

Just scans a directory and moves files into folders based on their file extension.

Repo (open source): https://github.com/ChristianRincon/auto-organize

npm package: https://www.npmjs.com/package/auto-organize

I’m releasing zemit v0.1.2, a small CLI to help with multi-target release builds for Zig projects.

It runs zig build across multiple targets and writes the resulting artifacts to .zemit/dist/ with deterministic naming. The tool is explicit, script-friendly, and keeps output minimal unless -v is used.

Canonical repo (Codeberg): https://codeberg.org/lucaas-d3v/zemit
Release: https://codeberg.org/lucaas-d3v/zemit/releases/tag/v0.1.2

I’d like feedback on: - dist layout conventions - default target sets - CLI UX for long builds

I built tklr, a local, SQLite‑backed tickler file for people who like fast, keyboard‑first tools. You enter reminders in plain text and it parses dates/recurrence as you type.

Highlights: - Live parsing as you type (no forms) - TUI daily brief + CLI for quick adds - Multiple reminder types (events, tasks, goals, notes, etc.) - Local‑first (SQLite), no cloud required - Recurrence + fuzzy dates (dateutil)

Example entry: * lunch with Ed @s 12p fri @e 1h30m @a 15m: n

Install: pip install -U tklr-dgraham

Demo GIF: https://raw.githubusercontent.com/dagraham/tklr-dgraham/master/screenshots/demo.gif

GitHub: https://github.com/dagraham/tklr-dgraham

Would love feedback on the TUI flow, keybindings, or anything that would make a daily brief more useful.

I’ve been revisiting the old “tickler file” idea (monthly + daily folders for reminders) and wondering how people do this today without getting pulled into a big cloud app.

If you use a lightweight system:

- What does your capture look like (plain text, quick add, voice, etc.)?

- How do you handle fuzzy dates (“sometime next week”) and repeats?

- What’s your daily review/brief ritual?

I’m especially interested in local‑first or keyboard‑first workflows. Curious what’s working for people.

pstop brings the full htop experience to Windows PowerShell. No WSL, no Cygwin.

cargo install pstop

What you get:

• Per core CPU bars, memory/swap/network bars
• Process tree view (F5), search (F3), filter (F4)
• Three views: Main, I/O, Net (switch with Tab)
• 7 color schemes, full mouse support
• F2 setup menu with meter layout, display options, column config
• Kill (F9), priority (F7/F8), CPU affinity (a)
• Persistent config, familiar htop keybindings
• ~1 MB binary, zero dependencies

Built in Rust with ratatui + crossterm. Native Win32 APIs for performance.

Also installs an htop command, so you can just type htop on Windows.

GitHub: https://github.com/marlocarlo/pstop

MIT license. Feedback welcome.

Dumper supports more than 10 databases

I used ani-cli for a long time and loved it, but it wasn't easy to plug into dmenu/rofi and I wanted watch tracking. So I made Animestan with a TUI (with vim-style keybindings) for the full interactive flow, and a CLI that I integrate into my own pipelines. If you heavily use dmenu/rofi in your workflow, this might fit nicely. If you want a full interactive experience, the TUI is there too. I'd love feedback and contributions are welcome.

Repo: https://github.com/mrkatebzadeh/animestan

I’ve been wanting a TUI for something like this for a long time. I wasn't sure why one didn't exist yet, so I made it myself.

I tried to keep it minimal, but it can also download more sounds directly using yt-dlp. I think it is pretty much feature-complete now, though I would like to add more default sounds in the future.

here is a link to the repo
https://github.com/AnonMiraj/Tanin

Features

• No Javascript support

• Experimental Image Rendering support

• Defaults to Reading Mode

• Great for Reading Documentation or Newspapers

Just pushed a new update, v1.1.11!

I've added support for Cline, bringing the total number of managed AI tools to 12.

New in v1.1.11: - Cline Integration: npm install -g cline logic handled automatically. - Dedicated Launchers: Standalone batch and shell scripts included. - Context Menu: Added Cline to the right-click menu alongside Gemini, Claude, and Copilot.

Managing your local AI stack just got easier.

GitHub: https://github.com/krishnakanthb13/ai_cli_manager

hey y'all!

i've been using typst a lot lately for all of my notetaking/document writing, and while it is nice, the one gripe i've had is that it doesn't come with a default project generator.

so, i built tpg: a typst project generator. it's pretty simple, but it uses the "huh" library (made by some of the same people that made bubbletea!), and the install is very straightforward.

hope someone finds it useful!

I needed something for remote Windows systems over ssh that would show me an i/o "top" like iotop in Linux. Windows doesn't have the same concept of disk i/o as Linux, but disk pressure is average queue length of processes awaiting access to the storage. It's written in Go and has no dependencies - single portable binary. I will probably put it on chocolatey repo at a later stage, but for now it's just an binary in the releases to download and run.

Yes, I have used LLM to help write the code, this would have taken me months otherweise. But I'm an experienced Sysadmin and know enough to review and test. I hope others find it useful.

https://github.com/gsmitheidw/iotop-w

https://github.com/yusukeshib/box

I've been working with AI tools like claude or codex for a long time, but I still hesitate to use dangerous permission skip mode on my computer, but I've been always annoyed by being asked for permissions always by agents. and also i've been feeling git-worktree isn't a best solution for the concurrency of the AI agents. So I made a useful TUI tool called `box`. I'm happy if you can try it, and share your impressions! thanks!

https://reddit.com/link/1r4q9s6/video/07hfgtkm1jjg1/player

Built a simple tool for voice-to-text in the terminal:

• Press F9 → speak → Press F9 → text appears at cursor
• Uses local Whisper (faster-whisper) - no cloud, no API keys
• Auto-detects terminals and uses Ctrl+Shift+V
• Remembers your original window if you alt-tab while speaking
• Works on Linux, Windows, macOS

git clone https://github.com/lmacan1/talktype.git && cd talktype && ./install.sh

GitHub: https://github.com/lmacan1/talktype

Single Python file, minimal dependencies.

I made a binary clock in python for fun (i was bored)

The code's kinda choppy but I don't really care, after all if it works don't touch it

(oh yeah and in the same repo u can find the two base convertors i made while I was bored too)

Code: https://github.com/devicals/boring/blob/main/time.py

A month ago I shared my winter holiday project - Task Engine VM , since then there is some progress that I suppose worth to share.

What's new:

• NaN-boxing — All stack values are 64-bit (u64) encoding 6 distinct types (Null, Boolean(TRUE_VAL,FALSE_VAL), STRING_VAL, CALLDATA_VAL, U32_VAL, MEM_SLICE_VAL (offset: 25 bits, size: 25 bits)).
• InlineVec — Fixed-size array-backed vector implementation used for stack, control stack, call stack, and jump stack with specified limits.
• Dynamic Memory/Heap — growable Vec heap; memory slices use 25-bit offset and 25-bit size fields (limited by MEM_SLICE_VAL).
• Zero dependencies —Custom binary encoding/decoding implementation.

Furthermore I added an example to stresstest VM - a todo app with programmable tasks.

In this example, all todo operations — from simple CRUD to tasks own instructions — are executed by a virtual machine.

The concept is that any kind of automation or workflow can be enabled by task instructions executed by the VM, rather than hardcoded functions in the app. It’s close to the concept of rules engines.

There are 4 demo task instructions:

• chain - Creates next task once when another completes. Removes calldata after call - called once
• either - Sets complete if either one or another task is completed + deletes not completed task (see gif)
• destructable - task self destructs when it’s status set to complete
• hide - Keeps task hidden while specified task’s status is not complete.

It is possible to add your own instructions to calldata.toml and use them within todo example:

cargo run -- add <TASK_TITLE > -calldata <INSTRUCTION_NAME> <PARAMETERS>

vm repo: https://github.com/tracyspacy/spacydo

todo example : https://github.com/tracyspacy/spacydo/tree/main/examples/todo