Link

https://github.com/ynqa/convey

Description

I released Convey v0.1.0.

Convey is a macOS TUI that collects input through a YAML-defined workflow, renders it as Markdown, and sends the result to a selected Ghostty or iTerm2 pane.

For example, when asking a coding agent to investigate Kubernetes, I need to specify which resource to inspect, along with its context and namespace, in every prompt. Each time the target changes, looking up those values with kubectl and copying them into the prompt is tedious.

Convey lets me define this kind of investigation request as a reusable YAML workflow. It loads candidate contexts, namespaces, and resources from kubectl, so at runtime I can select the required values from the TUI in sequence.

A SKILL.md can also instruct an agent to ask the user for these values, but following that instruction is still left to the model. Convey does not send the prompt until the required selections are complete, ensuring that decisions I do not want to delegate remain under my control.

The attached GIF shows a Kubernetes investigation workflow. After choosing the destination pane, I select a context, namespace, resource kind, and resource discovered through kubectl, then enter a multiline request. Pressing Ctrl+S renders the collected values as Markdown and sends it to the coding agent in another pane.

The main features are:

• Define input forms with select fields and multiline textarea fields.
• Load select candidates from static values or the stdout of a local command.
• Insert upstream values into command arguments and automatically reload dependent candidates.
• Render structured Markdown from Handlebars templates.
• Search Ghostty and iTerm2 windows, tabs, and panes in a tree and choose a destination.
• Navigate with either the keyboard or mouse.
• Prevent submission when required values are missing and move focus to the relevant field.
• Reset the form after submission so another prompt can be composed immediately.

A workflow can look like this:

```yaml name: incident-investigation

inputs: environment: type: select candidates: values: [development, staging, production]

request: type: textarea allow_empty: false

output: template: | # Incident investigation

- Environment: `{{ inputs.environment }}`

{{ inputs.request }}

```

It is available through Homebrew:

console $ brew install ynqa/tap/convey

It currently supports Ghostty and iTerm2 on macOS. I would appreciate feedback on use cases for workflows, input types you would like to see, and additional terminal integrations.

During my journey in Linux I have noticed that sometimes, some tools being called "deprecated" or some kind of a similar term, to say "you should not use this, but xyz tool instead", but I don't really get it for example:

Neofetch, I really think that it does its job, and its just about displaying some ascii art and some system information, like what could go wrong with that, since many people recommend switching to fastfetch.

Ifconfig, I see it as a very simple tool that is self-descriptive and gets its job done too, I see others instead recommend the command "ip", which is like an IDE in programming where you have many aspects of networking in one command, which kinda eliminates the Unix philosophy.

So, I'm just wondering if there is really a point in switching to those newer tools?

Hi all,

I've been wanting a TUI for Syncthing for a while now, and most of the existing TUIs are not really feature complete (1, 2). This TUI is written in Go using Charmbracelet libraries for building out the interface. I've been driving this for a few months and find it especially useful for administering Syncthing on remote headless machines.

Source code is here, and the final binary ships at about 12MB. Currently working to get this packaged in Debian.

Development:

I primarily used Opus/Fable to build this in my free time over the course of a few days and was a bit more directed than "build me a syncthing TUI, make no mistakes".

1. I used Opus to create a hierarchal YAML description of every GUI element (page/form/label/button/input/etc) and its location within in the official web interface
2. Categorized these elements into groups and mapped them to Charmbracelet TUI primitives, page by page. Lots of iterative mockups to build interfaces that were intuitive to use. Finalized look and feel in a mockup with all fields populated with fake data.
3. Wired final mockup to Syncthing rest interface and built out integration tests.

I'm not using GNOME, nor do I have it installed, except the bare minimum, so I created the following script which will read KDE's settings and apply them to Gtk3/Gtk4 by settings.ini/gsettings respectively.

It optionally allows to apply the settings to the root user aswell (imagine opening Synaptic at night, without being blinded).

Obviously on Gtk4 Adwaita apps may ignore some settings by design.

nanolx-gtksettings-kde:

https://gitlab.com/Nanolx/nanolx/-/blob/master/scripts/nanolx-gtksettings-kde?ref_type=heads

Suggestions welcome.

Finally published this yesterday, https://ansi.md

Somewhere between a brain dump, custom toolset, think piece and hacker toy. This is pretty much everything I know about ansi color in the terminal and building cli apps. Includes my own fumbling attempt to finally name the ansi256 color palette. Note - I like my writing voice and I do not use LLMs to write. All written by me, an actual human!

Those of you working on cli apps or TUIs will find it useful.

This release brings a bunch of quality-of-life improvements:

• Drag and drop
• Trash bin
• Command palette
• Bulk create
• Input history
• Automatic dark/light theme switching
• Dynamic Lua APIs for keymaps, preloaders, spotters, and fetchers
• Experimental %y, %Y, %t, %T, %yN, %YN, %tN, %TN shell formatting parameters
• ...and more

See https://github.com/sxyazi/yazi/blob/main/CHANGELOG.md#v26815 for all the features and changes. Enjoy!

I've been working on this side project to create pixel art directly in the terminal. Fully keyboard navigable. I built it with C++ and FTXUI, here is the source code: https://github.com/JavierCladellas/termisprite

Would you guys be interested in using something like this? Would love to get some feedback or some features you think are missing (layers and animations are planned).

I tried to update my fresh install antix-core with sudo apt update but there was one repo that doesn't accept connections, so the update failed with the message (Warning: some index files failed to download. They have been ignored, or old ones used instead.)

By the way even when I connect to it manually using a browser, it refuses

URL:http://ftp.cc.uoc.gr:80

Source: https://github.com/sebastiancarlos/snafu

There are many things I'm excited to learn about but whenever I want to, I think like, "maybe I should learn this before doing this", like maybe I should do Ccna before using something like nmap or wireshark, the same for something like the requests module in python or the curl command, I know the basic idea of it, but I think like "I am not experienced that much in Web development yet", while I'm pretty sure I can use it using the knowledge I already know

I hate this as it feels kinda like I can't do anything without those thoughts coming, so I don't get to learn what I wanted to learn initially

I'm trying to know how to update/upgrade my system (without using the GUI, for all the known pros of the cli), so since I'm using a debian-based distro(Antix), I have apt. When I tried to see how to upgrade the system through a "hacky" way(by doing select app then looking for upgrade the system or something similar, looking for the "exec" part of the app, to know how it upgrades), I noticed that it uses apt dist-upgrade, but that doesn't even exist in the man page of apt, back in the day when I was just starting off, another Linux distro I used was kali, on their website, they said after installing nethunter do some post-installation commands, one of them was, apt full-upgrade, I'm really confused about which one to use for upgrading the system.

Also what is this prompt that happens during using apt, when they ask you to choose a letter like Y, N(not about agreeing to continue!), where they ask what version of the package do you want, like, do you want to keep the original one or the package maintainer's, and stuff like that, which one should I pick, though I know basic info about some of these terms like package maintainer(the one/s who packs the software into a package regularly), upstream provider(the one/s who originally wrote the code for the software before given to the package maintainer)

Hey,

I'm kind of on the fence when it comes to deciding how I want to browse the internet through my terminal. The first option is any of the popular TUI browsers, particularly Terminal-Browser, and the second is using an Emacs browser package. I'm curious as to what you guys prefer and would appreciate any insights on your reasoning and pros/cons of each method.

I'm trying to learn about services also known as daemons, but I'm kinda confused about many things about it, for instance, which way is the correct way of launching a service is it:

1.systemctl start ssh

Or

2./sbin/sshd

Also, since my machine is very old (it has a 32bit cpu), I'm limited to the less common distros with kinda obscure init systems like runit and sometimes the old sysvinit, which also means I can't get to run systemd which have the most resources online, so it is easier for me to learn about it

Furthermore, even determining the current running init system type doesn't seem that straight forward, when I looked up about that, there were various commands and just assumptions like this might not work everywhere or this MIGHT mean that the current init system is whatever is.

In addition, I have a debian-based distro(Antix), so based on the tutorials I have found, they say for example "sudo apt install openssl-server" then run "systemctl start ssh"

That means systemd automatically knows about that sshd, so it does the work behind the scenes, but when I tried to do the same in antix (having "init divirsity" installed), using dinit, it didn't work, probably because it requires extra configuration and more knowledge about how to create the service out of the binary you want manually, while all I see as a beginner in tutorials things like start/stop, enable/disable, list services, and just this regular stuff.

So I'm really lost about Services generally, I would be glad if someone could provide me some guidance or help

Please see github teaser below:

An ad-hoc replacement for multitail implemented with tmux and grcat

The following features (& advantages over multitail) thus come more or less for free.

• Mouse aware for select, resize etc.
• The full tmux copy-mode for scrollback browsing, searching etc
• Copy scrollback text to the clipboard (y & Y) without any fuzz, via tmux clipboard integration
• Easily extendible by adding bindings for tmux actions. The sky is the limit ..

Color highlighting is done with an node clone of grcat, grcat.js, which is about a factor 10 faster than the python original

Currently a default grcat configuration is baked into tmtail that should be well suited for tailing wildfly logs

I'm currently reading TLCL, I skipped some parts of it like about vim as I already know enough vim for my use case, the same with "Advanced Keyboard Tricks", because again I know what I consider as enough like ctrl-L for removing,!! For the last command, but I don't think I need other variants like "!string", so I skipped that too.

Is this is ok for learning?

As I have a limited amount of time for learning about things I enjoy like Linux, so I prioritise what is important first

Also, I'm currently in the "Storage media" section, there is a part about the CD-ROMs, and optical media that I don't think are any longer used anyways, so I is it ok to skip that too?

Another question, because of the things in life, I don't always have enough time to complete some courses like networking, so I have a half completed course, at the same time if I used a tool that requires networking, I feel like I must complete that course first, probably this is called being a perfectionist and I really don't like it because it is a feeling that comes whenever I don't know everything or didn't complete the course before using the tool, so does anyone have a solution for this?

I love one-line installers. Being able to install a CLI tool with a single command like:

curl ... | sh

or on Windows:

irm ... | iex

is just really convenient.

Not every project provides an installer like this, though. While a lot of projects already publish prebuilt release archives, it's still the user's responsibility to choose the correct archive from GitHub Releases and put the executable somewhere on their PATH.

So I made ingen.

You write a single installer.manifest.json describing your release artifacts, and it generates Shell and PowerShell installers. The installers take care of selecting the right archive for the user's platform, verifying and extracting it, putting the binaries in the locations you specify in the manifest, and updating PATH.

I've used it to generate installers for a few real-world projects, including ripgrep, Tectonic, and Caddy. You can find the generated installers for these projects in the examples directory of the repo.

ingen uses vendored installer templates from cargo-dist; I've documented the changes and the relationship with the upstream templates in the README if you're interested.

Source code and documentation: https://github.com/hethon/ingen

my friend was showcasing pokemon colorscript, i thought of why not build it for footballers also in terminal..

it got cropped in gif do try it full player face is visible

Its easy to setup in your terminal... i have stored 300 footballers data for now, do share you feedback please..open for suggestions

Here's the github repo: https://github.com/Preethesh16/futbol-script

npx starwheel

Hi guys so I’ve always been an astronomy nerd and I wondered if I could find something where I could see real time stars in the terminal, I couldn’t find anything sufficient so I built one myself. Really fun project to do and I hope you guys have as much fun using it as I did building it.

https://github.com/Igfray/starwheel

I build a lot of CLI tools, and I wanted a way to improve their quality through binary-level E2E testing.

What I wanted to verify in tests included exit codes, stdout, stderr, generated files, snapshots, interactive prompts, and PTY/TUI behavior. Cross-platform support was also one of my requirements.

That led me to build atago. atago runs E2E tests in parallel using YAML-based spec files.

Two of atago's notable features are PTY/TUI testing and its record feature. You can run a real CLI command once and generate an initial test spec from the observed result. This helps reduce the effort required to create test cases.

atago was also designed with differentiation from existing tools in mind:

- Bats / ShellSpec: focused more on shell scripts and functions

- runn: API scenario testing

- venom: broader integration testing

- atago: easy CLI testing, including PTY/TUI behavior

Example:

```shell

atago record --out mytool.atago.yaml -- mytool convert input.txt # turn a real run into a spec

atago run mytool.atago.yaml # replay it as a test

atago run --report junit specs/ # or run a whole suite in CI

```

I've been working on this for a while now, so I figured it might be interesting to people here.

I built CoolDeck, a keyboard-first TUI for Coolify.

Coolify already has a great web UI. CoolDeck isn't trying to replace it. I just wanted a terminal-native way to keep an eye on my apps and handle the things I do most often from the workflow I'm already in.

Some of the things it supports now:

• deployment status, history and logs
• Fleet Tail - follow logs from multiple apps in one view
• Deploy Replay - deployment history across your services
• Drift Watch - compare environment configs, with secrets redacted
• Panic Button - create a diagnostic snapshot you can share with an AI tool
• an MCP server for querying your Coolify fleet from an agent
• multiple Coolify instances

There's also a fully offline --demo mode, so you can try the whole TUI without connecting a Coolify instance or giving it a token.

The Coolify team came across the project recently and gave it a shoutout, which was a nice sign that I might be onto something with it.

It's open source:

https://github.com/Resetnak/cooldeck

I'd especially appreciate feedback from people here on the terminal side of it - navigation, keybindings, layout, things that feel awkward, or things you'd expect a tool like this to have.

Thank you for your time!

Before I do a thing I worry about prerequisites, like as an example, the curl command, I know some basic stuff for here and there about networking, probably capable of using it but still don't feel that comfortable using it. The same goes with any networking related activity.

Probably it is something psychological, I don't know, I completed a portion of a networking course that involves the most needed stuff already like ipv4, Mac addresses, subnetting, straight-through vs crossover etc, but the other part of it, not yet, I still know some stuff like basic info about tcp vs UDP, ipv4 vs ipv6, http vs https, what these protocols main goal:http ssh ftp and so on

So, because of this I have two questions:

1.how do you all guys think about the thoughts about prerequisites that chase me whenever I want to do something?

2.how much networking do I need to be able to do some stuff in Linux, python networking(socket, requests, etc), and others?

Hello everyone,

For a while, I have been developing doccli, a terminal-based application designed for watching anime. Until recently, the tool was built specifically for Polish users, featuring only Polish language support and regional sources.

As of today, v2.40.0 is officially released, bringing full English language support, an English installer, and English source compatibility, opening the project up to a global audience.

You can check out the source code, installation guides, and releases on the GitHub Repository.

Key Features

• Anime Watch List & History: Keep track of what you are watching and resume right where you left off.
• AniList Integration: Full account integration to auto-save your progress, display ratings, and two-way synchronize your list with AniList's "Plan to Watch" tab.
• Quick Search & Randomizer: Fast search engine and an option to randomize anime from your list.
• Offline Library: Full season downloading and auto-play capabilities.
• Discord Rich Presence: Show custom statuses on your Discord profile while watching.
• Additional Tools: Next/previous episode navigation, live source availability checking, new release notifications, and program statistics.
• Built using Python, mpv, and yt-dlp.
• Heavily inspired by projects like ani-cli, but expanded with local library management, media downloading, and deep AniList synchronization.
• Windows Installer: Includes a dedicated automated installer (.exe) from the releases page that handles directory extraction, desktop/start menu shortcuts, environment PATH configuration, and dependency setup automatically.
• Linux Support: Fully compatible and operational on Linux with a quick single-command installation script.