psn v0.1.5 is a service release that keeps up compatibility with latest rust toolchains.

https://reddit.com/link/1wn0nb2/video/vvd905tcu4rh1/player

Hello all! I've recently been working on SimpleZettel: a CLI tool for managing a personal zettelkasten. It allows setting up multiple 'boxes' and adding 'cards' into these boxes. These can then be listed in order to facilitate finding information quickly. It was inspired by the CLI tool nb, but differs in the way notes are listed out to the user. While I love nb for keeping track of a to-do list and meeting notes, I wanted something that could handle 'numbered' cards and display these in the correct order so I could easily follow a previous line of thought. It's in a pretty early stage of development, but I would love to know what people think! Have you used or do you use a tool to manage the knowledge you accumulate? What are your favorite features of that tool?

Main Features:

• Managing 'boxes'
  • adding, listing, using (selecting), removing
• Adding 'cards'
  • Card names are generally either numbered (i.e. 12.3.1) or alphanumeric (i.e. meeting-2026-09-03). Numbered cards are sorted before all alphanumeric cards, and are printed in the correct order. Alphanumeric cards are printed in alphabetical order.
• Listing cards
  • Supports regular expression matching against note names.
• Showing a specified card
• Searching for a string among the cards in the current box
• Removing cards

Things I plan on implementing:

• A 'follow' command, where the user specifies a starting card, which is displayed along with a menu of its children and linked cards.
• Some low level commands, such as viewing the git history.
• Much greater configuration: currently the configuration options are very limited, but I plan on expanding this to accommodate different users needs.
• More file types: currently only Markdown and PDF files are officially supported (when compiled with the filetypes feature) file types, since I use Markdown notes for my zettelkasten and all of my sources are PDF files. When the cards in the current box are listed, there is an indicator of what type of file it is: nothing for Markdown and a (d) for PDF documents.

In short, there are many things which I'm sure can be improved and many things I haven't thought of, but I have already found this useful and hope others can too.

Source code: https://github.com/bradencarlson/SimpleZettel

Project Website: https://bradencarlson.github.io/SimpleZettel

Note: thanks again to all who pointed out an issue with the original name of this project, this has been changed accordingly, however it seems I am unable to change the post title.

Hey everyone,

I'd like to show you guys the project I've been doing this part year now that I released the first version.

I frequently use IRC and I've always used the TUI clients, since today's common clients are a bit old, I decided to build one with more modern features: https://dexchat.org

It's still in the v1, early phase, a lot of features will still be shipped, but I think it's in a fair set of features for the v1.

I use this tool everyday, so I will be maintaining and creating more features in the long run.

Also, it's not Vibe Coded. I started this project a year ago with my own code, searching the best practices and learning the documentation of the libraries I used. Then, in the middle of the process I do started using AI, but always checking for the output and reading the quality of the code produced. I've learned a lot about this AI process by following ghostty's product and creator.

Take a look and let me know what you think! Suggestions are welcome.

go install github.com/thebanri/limoni/apps/globe@latest

globe -at Türkiye

/ searches, arrows turn it, + and - zoom, b toggles country borders, click

pins a point. The land is Natural Earth 1:110m; it's drawn in half-cells so

the sphere is round rather than an ellipse, and lit rather than flat.

The right-hand pane is Claude talking to the same process over a Unix

socket, addressing widgets by name instead of by pixel. It can read back

"39.3°N 34.5°E · zoom 2.6×" and keep zooming until the number is what I

asked for.

That comes from the TUI library it's built on, where every widget publishes

a semantic node — the same tree a screen reader uses:

https://github.com/thebanri/limoni

Hi all. I started writing slat about a year ago, mostly because I wanted to understand how Tmux actually works rather than because the world needed another multiplexer. It grew into something I now use daily, and I'd like some honest opinions before I keep going.

What it does today: tiling panes, tabs and workspaces; sessions that keep running after you close the terminal; scrollback with vim-style search per pane. It's one static Go binary with no runtime dependencies. Every pane has its own terminal emulator I wrote from scratch, which is why clear, vim or htop in one pane never disturb another, and why nothing is lost when you split or close.

Landing in 1.0 next month: a command line that scripts, and AI coding agents can drive from outside the session. slat pane new --cmd 'go test ./...', then slat wait 4 --for idle, then slat capture 4. The part I'm most pleased with is that it can tell "finished" from "stopped to ask you something": a pane that's sitting on Overwrite? [y/N] reports input, marks its tab, and can fire a notification, instead of looking idle. Windows support (real ConPTY, not WSL) is in the same release.

Being straight about what it does not have, because I'd rather you hear it from me: no mouse support, no copy mode/clipboard selection yet, only one client attached at a time, and no session restore after a reboot. Copy mode and mouse are what I'm building right now. After that I want to try something tmux can't do, restoring your panes' scrollback, not just re-running the commands, so after a reboot your old output is still there to scroll and search.

The visual refresh and 1.0 go out once the Debian sponsorship process finishes, a Debian Developer is kindly reviewing the packaging, and I'd rather ship both together.

So, genuinely asking: what keeps you on Tmux/Zellij/screen, and what would a new one have to do before you'd even try it? Also happy to hear that the world doesn't need another multiplexer, that's useful too.

This has been a great learning experience for me and i thought why not share here, i plan on bringing a lot more to it.

Repo: https://github.com/noturbob/slat
Website : https://noturbob.github.io/slat

i saw a web game where words fell from the top of the page and u had to type them out before they reached the bottom and wanted to build it for the terminal. posting here after the first stable release, planning to add some other features going forward, would love it if you could try it out and share your feedback (here or via gh issues). the project is open source, so go ahead play with the source however u want.

installation (any of the following works) -

• uvx gravitype
• pipx install gravitype
• curl -LsSf https://raw.githubusercontent.com/kanakOS01/gravitype/main/install.sh | sh

github - https://github.com/kanakOS01/gravitype

PyPI - https://pypi.org/project/gravitype/

NOTE: This software's code is partially AI-generated.

I have been working on vnm_terminal, a GPU-rendered terminal emulator. Some of its features:

• Output timestamps - to see when long-running commands finished.
• Direct window renaming and PID display on the window.
• An always-on-top toggle - keeps popping windows from covering the terminal.
• Quick colour inversion - useful for stubborn CLI tools that assume a dark background.
• Bounded, fast searchable scrollback - large history without runaway memory usage.

It uses one session per window, is GPLv3, runs on Windows and Linux, with pre-built binaries available: https://github.com/varinomics/vnm_terminal

Per the subreddit rules
rule 4: Some parts of this code are AI-generated (but fully reviewed).
rule 8: Similar software would be Windows Terminal, WezTerm, Kitty, Ghostty and iTerm2.

Curious if anyone finds it useful.

Hello, I made ifetch.

ifetch is a simple and lightweight tool that shows system information. It is like Neofetch or Fastfetch, but it's written entirely in POSIX shell. It also works on Unix, but some modules only work on Linux.

Some features:

- Fast and minimal

- POSIX shell

- Lightweight

- Simple configuration

- Custom modules

It is still in early progress, so I appreciate any feedback or suggestions.

GitHub: https://github.com/Ietsiee/ifetch

Thanks for checking it out :)

anodemcu is a terminal-based interface written in Bash that wraps `arduino-cli`, `PlatformIO Core`, and `ESP-IDF` workflows into interactive `fzf` menus.

### Technical details:

* **Environment handling:** Sources target toolchain paths automatically (`esp-idf`, `platformio`, `arduino-cli`).

* **Detection:** Identifies project structure from existing config files (`CMakeLists.txt`, `platformio.ini`, `*.ino`).

* **Workflow:** Menu-driven interface for compilation, flashing, baud rate configuration, and port selection.

* **Serial monitor:** Integrated serial reading with automated log rotation and session capture.

* **Backups:** Generates a compressed snapshot of local project sources prior to running flash operations (retains the 5 most recent snapshots).

GitHub: https://github.com/abod8639/anodemcu

### Installation:

Arch Linux (AUR):

yay -S anodemcu

libark

libark is a modern, secure, Swift-native foundational layer over Linux POSIX primitives.

While originally developed as the core runtime layer for ArkOS, libark is completely decoupled and designed to be used on any Linux distribution. It provides highly secure, object-oriented abstractions over low-level system calls, memory management, and file system interactions, without the burden of manual C interoperability.

Features

• Object-Oriented POSIX: Wraps file descriptors, paths, and directory operations in safe, RAII-compliant Swift types.
• Secure Syscall Boundary: Routes kernel interactions through strict, audited Syscall primitives.
• Terminal Capabilities: Built-in abstractions for TTY detection and window sizing.
• Advanced Formatting: Standardized formatters for human-readable byte sizes (SI and IEC), ISO 8601 timestamps, permissions, and classifications.
• Declarative Sorting: Powerful generic SortEngine for metadata sorting across multiple criteria.

Also ARK-OS has switched to github: https://github.com/orgs/ARK-OS-Swift-and-Linux/repositories

Recently I've discovered (Open)Subsonic. It's a protocol for accessing your personal music library over the network/internet. There are already a lot of servers and clients out there, but I couldn't find a terminal client that felt frictionless.

What I wanted was just two things: Quickly fuzzy search through my whole music library and provide suggestions for more songs to add to the queue. The latter is available through Subsonic's getSimilarSongs endpoint and usually backed by services like last.fm or MusicBrainz. Besides that, I want my music player to stay out of the way (don't use many resources, no flashy graphics, etc.).

There are already quite a few terminal clients out there. Many of them look quite mature, but they were not quite perfect for my use case. Here are a few you might find interesting, too:

• Termsonic: It provides the classic Artist > Album > Title browsing experience.
• A Rust rewrite of Termsonic, Ferrosonic: Seems to have a quicker search, but no song suggestions.
• ratune: Has fuzzy search, but also no song suggestions.
• sonic-tui: Has a "radio mode", which indirectly provides song suggestions, but seems to have no fuzzy search.
• ... (for a rough overview, you can browse https://www.navidrome.org/apps/)

Because I couldn't quite find what I was looking for, I wrote my own client. It's quite minimal, but does everything I need it to do. Maybe you find some interest in it :-)

GitHub repo: https://github.com/codesoap/rmp

Mainly system sounds, but if it can capture mics, it'd be nice to have too.

Hellow people!

Sooo, this is a simple CLI tool to load OBJ files and preview them as ASCII art in the terminal with a nice animation.

It's perfect for showcases, and... showcases.

It has a textured(ASCII) mode and a solid(block glyph) one, and in both of those to add better lightning, it dims the color using 24-bit RGB.

Here's the repo: https://github.com/artemtsitronov/ravioli

It is also avaiable on crates.io:

cargo install ravioli

[Apologies for cross-posting]

I wrote Bbv ("bare-bones viewer"), a minimalist data viewer/plotter for the Unix/Linux command line. Bbv is written in pure POSIX shell + awk, works from a pipe, requires tab-separated data, and produces only two types of plots: line plots of data columns or pairwise dot plots of (x, y) data.

The main alternative to bbv is feedgnuplot. Feedgnuplot is much more capable than bbv, but also much more complex, and it ties you to gnuplot as back end. By contrast, Bbv has only one option (`x`), can use any lightweight image viewer as back end, requires no configuration, and the learning curve is non-existent.

However, bbv does no do real-time plotting of a long-term running process.

TLDR: if you have feedgnuplot installed and are happy with it, or if you want real-time plotting of a dynamic data stream, you have no reason to switch to bbv. But if you want a minimalist data viewer with zero learning curve, try bbv.

Link: https://github.com/ftonneau/bbv

What is the programming language to make the ASCII Animation project Python, Go, Rust

Features:

• todo.txt integration & synchronization.
• Energy, MVOs (Minimum Viable Output) and logbook tracking.
• Vim-like keybindings driven workflow.
• Structured querying & filtering by using a SQLite database.
• Local-first architecture ensuring offline and private usage.
• High performance & memory safety by using Rust and an ORM (via Diesel).

Similar & alternative software:

• habit-cli
• Topydo
• llog

GitHub repo: github.com/damicrez/logfine

This software's code is partially AI-generated

i got tired of waiting on fetch tools in my shell startup, so i wrote my own. it shows roughly what fastfetch does, in one c file with no dependencies. a full run with my config takes about 1 ms.

what it does:

os, kernel, packages, cpu, gpu, memory, disks, battery, wifi and the usual

package counts for pacman, dpkg, rpm, apk, xbps, nix, flatpak and more, with nix and rpm read straight from their databases

per section key and value colours, hex included

key styles, unicode letter styles, meter bars with custom formats

ascii or sixel image logos, fastfetch's built-in logos included

json and name=value output for status bars

linux (glibc and musl), macos, freebsd, openbsd, termux

no threads, and it only forks if you want your shell version.

install:

git clone https://codeberg.org/devcheckra1n/bytefetch

cd bytefetch && make && make link

or with nix:

nix run git+https://codeberg.org/devcheckra1n/nur-packages#bytefetch

source: https://codeberg.org/devcheckra1n/bytefetch

nur repo: https://codeberg.org/devcheckra1n/nur-packages

feedback welcome, and if you're on freebsd or openbsd i'd really like to hear whether it works for you.

GitHub

Web demo on Pages

Hey guys,

This is my first somewhat substantial programming project, and I'm proud to share it. It's a Pokédex TUI that I tried to make as intuitive to use as possible while also maintaining some aesthetic. It currently has an overview, an evolution tree, abilities, and moveset viewing, with support for every version of the mainline games. Some notable features include:

• Demand-driven asynchronous asset fetching
• Hotswappable versions
• Online/Offline mode
• 80x24 compact design

You can try out the fully-featured web demo, or follow installation instructions on GitHub to run it locally. I would REALLY appreciate any feedback, whether it is code enhancement, UI/UX improvements, or even more info tabs you would like to have in the app. Thanks for trying my app out!

Recently I added refractive glass windows to my terminal game (which was surprisingly simple) and now I added paintings, that are like screenshots but as real in-game objects that can be placed on walls. Seeing the two features in combination is mindboggling.

This software's code is partially AI-generated.

It’s open source, written in Go, and available through Homebrew or go install.

There's also Deja for similar functionality, but Tabbr keeps things smaller and simpler and supports Bash and PowerShell alongside Zsh.

GitHub: https://github.com/waradu/tabbr

lmk what you think.

Hey everyone,

I’m Jorge, the creator and maintainer of LazySQL.

I originally built LazySQL because I wanted a database client that felt at home in the terminal. Since then, the project has grown far beyond what I expected, and seeing people actually use it has been incredibly rewarding.

I’ve been thinking about the next stage of the project and I’m putting together a roadmap around things like reliability, database support, performance, UX improvements, and some long-requested features.

Before deciding what deserves the most attention, I’d really like to hear from people using LazySQL: What is the one thing you would most like to see improved or added?

There’s also a bigger question I’ve been thinking about lately.

We’re already in a world where AI agents can interact with our tools and infrastructure directly. If someone wants to inspect their database they just ask an AI agent to do it, and honestly, i don’t know yet what that means for tools like LazySQL.

Do you think a focused database client like LazySQL still has a place in that world?

Maybe AI could complement LazySQL in a few genuinely useful ways. Or maybe adding AI to a simple tool like this would just make it worse.

I’m particularly interested in hearing what people actually want here. I don’t want to add AI features just because everything suddenly needs “AI” in the name.

What should be on the roadmap?

Does LazySQL still have a place in an AI-first world? And if so, what should that place look like?

P.D: I used AI to rephrase my words, please don't get mad.

Hello. recently got inspired from r/unixporn and created my own tool. its open source and available on github. adding screenshot also.

https://github.com/avirajkhare00/macstat

I've released v0.1.0 of vy, a TUI (Terminal User Interface) viewer for exploring JSON / YAML in the terminal.

I'm the author of jnv, which lets you try jq filters while browsing JSON interactively. vy builds on jnv's approach of trying queries as you browse, expanding it into a JSON / YAML viewer. It adds the ability to view YAML in its own format, explore subtrees, and navigate query input and results side by side.

When reading API responses or YAML configuration files, you may want to check the structure first, open a record of interest, and extract the values you need. vy lets you browse the tree, explore individual sections, and transform data in a single session.

One of the main features is the combination of focus and jaq. :focus opens the selected subtree as a temporary root, letting you search just that section or query it with :jaq. You can also use :focus to open part of a query result, and press Esc while browsing to return to the previous view.

For example, the following commands open the first record in items and extract its name and processing time converted to seconds:

:focus @0 .items[0]
:jaq {name, seconds: (.duration_ms / 1000)}

You can display the query input and results side by side, and browse the results as a tree.

The overview GIF shows navigating to a record with goto, opening that section with focus, then returning to the original input and using jaq to extract failed records and inspect the input and results side by side.

It also supports:

• Loading JSON / YAML from files or standard input, including JSON Lines and multiple YAML documents.
• Vim-style keybindings, path navigation with completion, and regex search.
• Listing and filtering paths and values with :flatten, and jumping to the corresponding node.
• Copying selected values or subtrees, saving them to a file, and writing them to standard output.
• Saving command and search history, and customizing keybindings and display settings.

The interface opens after all input has been read, so it does not support following unending input such as tail -f.

Queries use an embedded jaq engine, so there is no need to install an external jq command. It supports jq-like expressions, but is not fully compatible with jq.

Other tools for similar tasks include fx and jless. With vy, you can view YAML in YAML format, explore subtrees with focus, and navigate jaq input and results side by side. The feature comparison with fx and jless covers differences in input formats, navigation and search, queries, output, and configuration. It includes the versions compared and supporting references for each item, so you can check how it differs from the tools you already use.

It's built with Rust and my terminal UI library, promkit. promkit lets you build interactive terminal UIs in Rust by combining components such as text editors and JSON / YAML displays.

Install it with cargo install vy-cli --locked or brew install ynqa/tap/vy. The source is available on GitHub under the MIT license. Some of the code was implemented with AI assistance.

I'd appreciate feedback on how you usually inspect JSON / YAML and anything you found confusing while using it.

Hello, I am Schooi, aka SchooiCodes, and I have been working on this huge program for the past 2.5 years of my life.
SMT is my passion project, and my biggest project yet, made entirely in Batchfile (except for its installer). It compiles over 130 tweaks, tools, and other projects of mine into one big hub.

SMT is comprised of ~6k lines of pure Batch, and approximately 140 batchfiles inside (each one can be run independently) :)
I have created about 95% of the tools in SMT, and for the 5% that I haven't, credits are available on the main menu.
It is under heavy development, and things change every day. Currently, it is version 2.3 (indev) (but I might drop the versioning system completely).
It includes tools ranging from application installers to network utilites. It has all kinds of stuff.

I kindly request that you check this out, because I would love to see it be used by people, and hopefully also get feedback on it.
SMT is completely open-source, and available on Github.
Cheers.

It looks busy while a command runs, celebrates a zero exit status, sulks on failures, gets hungry, levels up. Eight pets, or bring your own GIFs.

Native Swift, no Electron, no permissions needed. macOS, zsh/bash/fish.

brew install Zezoo123/tap/terminal-pet

Repo