https://github.com/Alexandro521/Tanko/releases/tag/v2.1.0

without AI

TL;DR: Noodle has changed a lot since the last Reddit post at v0.5.7. v0.7.6 adds built-in agent skill installation/update support, and the roadmap to v1 is now focused on assertions, chaining, scripting, testing, runner/CI, and stabilizing the execution model. After v1: streaming, OpenAPI sync, Bruno import, advanced automation, GraphQL/WebSockets/gRPC, and more.

The last time I posted Noodle here it was on v0.5.7. I ended that post saying it was still a small project. It still is, but I don't think it feels like a toy anymore. I've been working on it pretty much nonstop since then.

For anyone who hasn't seen it before, Noodle is a keyboard-first REST client for the terminal. The main idea is still the same: requests are simple YAML files that live in your repo, so you can edit them with anything, commit them to Git, share them with the code they belong to, and use the same collection from the TUI, CLI, CI, or a coding agent.

Since 0.5.7, quite a lot has changed

• Import/export is now available directly from the TUI, with OpenAPI, Swagger, Postman and Insomnia support. There is a proper Settings workspace, collection configuration, proxies, TLS and mTLS, OS-backed secret storage, much stricter redirect/security handling, and a persistent cookie jar with its own TUI.
• Authentication has also grown a lot. Noodle now supports Basic, Bearer, API keys, NTLMv2, AWS SigV4, OAuth 1.0a and OAuth 2.0, including browser authorization, PKCE, refresh tokens and secure token storage.
• XML is now a first-class body type alongside JSON, multipart, urlencoded and binary. Invalid collection YAML can be repaired without leaving the TUI. External-editor workflows are better, updates can install automatically, and there have been a lot of smaller UI and keyboard improvements along the way.

0.7.6 adds something I'm particularly excited about: better support for coding agents.

Noodle already has a noodle-use skill that teaches coding agents how Noodle collections work: how to create requests, organize collections, work with environments, audit requests, import other formats, run requests, etc.

With 0.7.6 you'll be able to install it directly with:

noodle agent install

And if the skill is installed, updating Noodle will update the skill too.

I wanted this to be part of Noodle itself instead of asking people to know about another package manager command and manually keep a skill in sync.

The nice part about agent support in Noodle is that there isn't really a special "AI workspace". The agent works with the same YAML files you do. If it creates or changes a request, you can open the file, review the diff and commit it like anything else in the repo.

So what happens now?

Before v1, the focus is no longer adding random HTTP features. I want to finish the execution side of Noodle:

• declarative assertions
• response capture and request chaining
• run-scoped variables
• pre-request and post-response JavaScript
• advanced tests
• a sandboxed scripting runtime
• proper script editors in the TUI with syntax highlighting, diagnostics and autocomplete for the Noodle scripting API
• a real collection runner
• CI-friendly results, stable exit codes and reporters

The goal is that the same collection can go from:

explore → debug → chain → test → automate → CI

That is where I want to call it v1.0.

For me, 1.0 isn't "Noodle has every feature Postman/Bruno/Yaak has". It means the YAML format, execution lifecycle, scripting API and CLI contracts are stable enough that I can commit to keeping them compatible.

After v1 and on the way to v2, there is still plenty I want to do: SSE and streaming responses, OpenAPI 3.1 and OpenAPI sync, direct Bruno/OpenCollection migration, multiple cookie sessions, JWT auth, external secret providers, better network timing/debugging, more advanced automation, and eventually GraphQL, WebSockets and gRPC.

I'm trying pretty hard not to turn Noodle into a giant workspace that happens to run in a terminal. I still want the repository to be the workspace.

I wrote a more complete summary of everything that changed between 0.5.7 and 0.7.6. And I've published the roadmap, including the detailed scope I'm currently thinking about for every version.

GitHub: https://github.com/wilfredinni/noodle

Install:

curl -LsSf https://noodlerest.dev/install.sh | sh

As always, feedback is very welcome. A bunch of what has ended up in Noodle came from people pointing out things that annoyed them or were missing, so if you use Bruno, Yaak, Posting, Postman, Insomnia, curl, or anything else for API work, I'm especially interested in what would still stop you from using Noodle.

flow just hit 0.2.0, and it's the biggest update since launch. A quick recap for anyone new here: flow is a real time terminal bandwidth monitor with Braille grid waveforms, spring smoothed numbers, and glowing borders that react to traffic load.

What's new

Throughput values now actually use the spring physics the README always claimed. Numbers glide toward their targets instead of snapping, which sounds small but changes how the whole dashboard feels under load.

The ping target is now configurable. It defaulted to 1.1.1.1 and had no way to change it. Now you can set ping_target in the config or pass --ping on the command line if you want to check latency against your own gateway or a different host entirely.

There's a new streaming JSON mode. --json-stream writes one JSON object per line to stdout, continuously, so you can pipe flow into whatever else you're building. This was the most requested feature since --json and --once shipped.

Daily totals now survive restarts. They get written to ~/.config/flow/stats.json on quit and reloaded on the next launch, so closing your terminal doesn't wipe out the day's numbers anymore.

Themes are no longer limited to the 8 built in ones. Drop a .toml file into ~/.config/flow/themes/ and flow picks it up automatically at startup. Full control over colors and gradients if the defaults don't match your setup.

There's also a public roadmap now (ROADMAP.md) laying out where 0.2.x through 0.5.x are headed, and test coverage got a real pass, especially around the spring animation math and the history persistence round trip.

Since the last big writeup

If you've been following along, a lot happened between 0.1.1 and 0.1.7 too: a theme selector, bits/sec toggle, live ping indicator, a network processes panel, an interface details overlay, reset confirmation to stop accidental data loss, and a full typography and spacing pass that gave the whole UI a much more deliberate hierarchy. 0.2.0 is really the point where all of that groundwork turns into new capability instead of polish.

Usage

flow                        # hero view, auto interface
flow --compact               # numbers only
flow --tiny                  # tmux status bar
flow --json-stream            # continuous JSON Lines, new in 0.2.0
flow --ping 8.8.8.8            # custom ping target, new in 0.2.0

Install / upgrade

go install github.com/programmersd21/flow/cmd/flow@latest

Pre-built binaries for Linux, macOS, and Windows are on the releases page. Config and theme files are backward compatible, nothing to migrate.

Links

Source, changelog, and roadmap: https://github.com/programmersd21/flow

Appreciate everyone who's been using flow and sending feedback, it's shaped most of what shipped in this release. If it felt cool, a star on the repo goes a long way.

I like flame graphs, so I built a CPU profiler using an ebpf engine. Click into any of your processes and press f for flame. Lives here if you want to check it out.

​

Sometimes it's really pain in ass to clean the linux machine. And also pain for delete any app. So I Built a Tui based cleaner to Reclaim my disk space.

It's a use full tool. Give a try if you are interested.

githublink:

https://github.com/swadhinbiswas/veet

[removed]

Hi,

I built a small TUI tool for those who work day in and day our with logs.

Demo and docs: https://nightbuildlabs.github.io/lumen/

Repo: https://github.com/nightbuildlabs/lumen (MIT)

Recently started working extensively with Kubernetes. Debugging logs was hard with grep. Started exploring TUI log processors, what was missing was the existing tools did not handle the structure well. The structure is right there in the logs — field names, severities, timestamps, but all of them required me to understand the structure or regex or some sort of pre setup.

So I built lumen. cat anything.log | lumen:

• The UI paints in <[100]ms and logs stream in live while ingestion continues behind it
• Press /, type three characters, and it autocompletes field names discovered from the data you just piped in, ranked by occurrence count — no schema files, ever
• status_code=500 flips to a query mode backed by an embedded DuckDB; a 1M-row result scrolls without materializing more than a viewport
• A severity-colored sparkline on the border shows when the errors spiked; jump to it
• It eats mess: kubectl pod prefixes, docker-compose interleaving, logfmt, multiline Java stack traces (joined into one entry), ANSI noise. Lines it can't parse are still shown and still searchable — it never silently drops anything

Why build it when there's lnav?

- I found the learning curve of lnav to be comparatively steep; I need to know the exact pattern or attribute of the log item I am looking for.

- While juggling multiple projects this becomes challenging to an extent - hence built out auto indexed logs; now I don't need to remember the regex and can query like a search box.

Currently support JSON and logfmt; adding support for nginx, syslog, django and cloudwatch soon.

Give it a spin! Would love some feedback.

I love claude code but am fatigued by the pure chat interface for all types of agent work. Even the GUIs these days are just better styling over the same chat interface.

I built tart (tartifacts) as a tiny way for agents to create and update persistent terminal dashboards instead of narrating everything at you.

A tart is basically:

- a manifest

- a script that fetches live state

- a script that renders it

Install: `uv tool install tartifacts`

Then tell your agent to use `tart --skill`.

Works nicely with tmux/herdr (agent chats in one pane, dashboards live in another).

Github - https://github.com/tg1482/tart

Hey everyone! 👋
Like many developers on macOS, I often found myself low on disk space thanks to Xcode DerivedData, forgotten Docker build caches, dangling images, and bloated dev caches. Most cleanup tools are either sketchy closed-source subscription apps (like CleanMyMac) or risky one-liner bash scripts that `rm -rf` without a safety net.
So I created 
**CLI-NER**
 — an open-source, fast, and safety-first CLI & TUI tool built in Rust to analyze and clean disk space on macOS.
### 🛡️ Why it's built differently (Safety-First):
- 
**Reversible by default**
: Files are moved to the macOS 
**Trash**
 (`~/.Trash`), not permanently deleted.
- 
**Dry-run by default**
: `cli-ner clean` simulates the operation first. You have to pass `--execute` to actually touch files.
- 
**Strict Blocklist & Allowlist**
: Critical system dirs (`/System`, `/usr`) and personal data (`~/Documents`, `~/.ssh`, `~/Library/Mail`) are strictly untouched.
- 
**Developer-Aware**
:
- 
**Docker**
: Interactive wizard, protects running containers, locked in-use images, and persistent volumes.
- 
**Xcode**
: Safe checks for DerivedData/Archives (verifies Xcode isn't running).
- 
**Node/Python/Brew**
: Cleans npm cache, pip cache, Homebrew orphans.
- 
**Interactive TUI Dashboard**
: Built with `ratatui` (`cli-ner dashboard`) to inspect operations history, charts, and audit logs.
- 
**Immutable JSONL Audit Trail**
: Everything is logged under `~/.cli-ner/logs/`.
### 🚀 Quick Start:
```bash
# Clone & install via Cargo {#clone--install-via-cargo  data-source-line="28"}
git clone https://github.com/fabrizioriccardo73/cli-ner.git
cd cli-ner
cargo install --path .
# 1. System Health Check {#1-system-health-check  data-source-line="33"}
cli-ner doctor
# 2. Interactive Docker management {#2-interactive-docker-management  data-source-line="36"}
cli-ner docker
# 3. Simulate Cache Clean (Dry-run) {#3-simulate-cache-clean-dry-run  data-source-line="39"}
cli-ner clean
# 4. Explore history & reclaimed space {#4-explore-history--reclaimed-space  data-source-line="42"}
cli-ner dashboard
``` 


The project is 100% free and open source (MIT licensed). I would love to get your feedback, feature requests, or contributions!
🔗 
**GitHub Repo**
: [https://github.com/fabrizioriccardo73/cli-ner](https://github.com/fabrizioriccardo73/cli-ner)

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:

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:

$ 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.

I've been using T3 Code for a while and genuinely love its UI — the chat view, the workflows, the whole feel of it.

Then I discovered omp (oh-my-pi) and it was a wake-up call. My agents just feel powerful with it. The way it hands them tools, the rewriting hooks, the whole setup — they work so much better.

Problem: I missed the T3 Code experience. So I decided to marry the two.

I forked T3 Code and heavily modified it to run specifically on omp (omp --mode rpc). Stripped it down to omp only, added managed omp install and account login right in Settings. Bringing the omp functionality into the ui of t3 code and calling it pivot. Also thought about the name t3.14 but did not end up going with that name.

It's alpha. Rough around the edges, needs a lot of work. But I've been using it as my main driver for a couple days now and honestly? Really enjoying it. Figured I'd share it.

GitHub: https://github.com/13kparkin/Pivot

Edit: I know there are other gui wrappers out there for this type of thing but nothing that quite felt right for me like t3code does.

We just shipped a terminal for Linux, macOS and Windows. Apache-2.0, one file to install: https://starling.build/terminal.html

Speed. Ten workloads at steady state, matched fonts and verified grids, measured against the fastest terminal on each platform:
• Linux: 1.38x the ghostty nightly
• macOS: 1.28x ghostty
• Windows: 1.41x Windows Terminal

Efficiency, which matters more for TUIs. All of that on about half the CPU — 0.44x to 0.53x of the other terminal across the three platforms. Memory is flat no matter how much has scrolled past: on Windows we measure 73 MB against Windows Terminal’s 1,026 MB for identical work.

For full-screen apps specifically: alt screen is 1.06x ghostty on Linux and 1.87x Windows Terminal, and DOOM-Fire — which repaints every cell every frame — runs at ~1,600 fps on Linux.

Side-by-side videos, charts, and the raw per-leg data are on that page.

And you can build your own on the same widget. The terminal ships in our SDK, so a working terminal app is about twenty lines of Swift — emulator, PTY, scrollback, selection, fonts and glyph atlas all inside the widget:

import ExampleHost
import Flutter

let session = TerminalSession()
session.startShell()

runExampleApp(title: "Terminal", width: 940, height: 620) {
TerminalView(session: session)
}

Happy to answer questions.

Built this over the last few months. Recently added synced lyrics support.

Would love any feedback.

https://github.com/danfry1/waxon

Just for fun this weekend I ended up doing a pure csharp dotnet implementation of the Python tool 'Terminal Text Effects' https://github.com/ChrisBuilds/terminaltexteffects for absolutely no other reason than A) I don't like Python and B) Why not?

Its output is byte for byte identical to what the Python tool would output given the same input and seed values... with the one exception that my dotnet version starts in under 12ms and the Python version is somewhere around 86ms.

All built as native AOT and no dependencies.

https://github.com/Hypabolic/Hypa-TTFX

If anybody wants it I might publish it as a library (or you can just fork it and do it yourself)

-- Edited to include the link to my own code that I totally forgot to include because I'm an idiot lol

Over the past few weeks I've been building Gray Box — a small, local-first tool that acts as long-term memory for anything I'd otherwise forget (work notes, meeting takeaways, task owners, random ideas, personal stuff too).

The idea is simple:

1. Capture — dump whatever's on your mind, instantly, no structure required. This step does nothing clever on purpose — it just writes your text to an immutable inbox. Zero chance of losing an idea to a bug or a slow API call.
2. Organize — on demand, an LLM reads your unprocessed notes and extracts people, projects, tasks, decisions, meetings — then deterministic Python (not the LLM) creates/merges the actual wiki pages and maintains backlinks. The model only reasons; it never touches the filesystem directly.
3. Ask — query or chat with your knowledge base and get a cited answer pulled only from what you've actually captured. If it doesn't know, it says so — no hallucinated answers.

Why I built it this way:

• Plain Markdown + YAML frontmatter, no database. Every page is a .md file you can grep, diff, or read in any editor forever. If you stop using Gray Box tomorrow, your knowledge base is just a folder.
• No vector DB by default. At personal scale (hundreds–low thousands of pages), keyword search + a real link graph (related/backlinks, walked one hop during retrieval) handles almost everything. Embeddings are there if you want better recall, but they're opt-in, not a prerequisite.
• Immutable inbox. Your raw notes are never edited or deleted by the organizer. If the LLM mis-extracts something, your original words are always still there.
• Any LLM. Built on LiteLLM, so point it at OpenAI, Anthropic, Gemini, Mistral, or a fully local model via Ollama — one config value.

It also ships with a nice interactive TUI (arrow-key menu, file-import shortcut, workspace switching, live spinner during LLM calls) if you'd rather not memorize CLI flags — that's honestly become my favorite part of the project.

There's also a lightweight local dashboard for browsing your knowledge base, exploring backlinks, visualizing your notes as a graph, and chatting with your captured knowledge—all without leaving your machine.

Repo: https://github.com/Aaryanverma/graybox

pypi: pip install graybox

I'd genuinely love feedback — especially from anyone who's tried the "capture now, structure later" approach with other tools and has opinions on where it breaks down at scale.

It's not trying to be a "real-time collaborative team wiki" or a WYSIWYG notes app — it's aimed at one person's running memory of their own life and work, captured with as little friction as possible.

100 stars. I know that's nothing by internet standards, but I genuinely didn't expect anyone outside my own GitHub profile to care about this.

Kairo started as a frustration project. I was deep in a coding session, had to context-switch to my task manager, and just... snapped a little. Opened a new Go module that same night. That was a few months ago.

For those who haven't seen it — Kairo is a fully local, keyboard-first terminal task manager. SQLite storage, 32 themes, fuzzy search, natural language deadlines, a Lua plugin system, a CLI API for scripting, and an optional MCP server if you want to point AI agents at your task list. No cloud. No account. No subscription. Just a binary you run in your terminal.

Things I didn't expect when building it:

• That people would actually use the Lua hooks (shoutout to the person who built a webhook notifier with them — genuinely wild)
• That the "32 themes" feature would be the thing people mentioned most
• That u/Tornado300 would show up and fix bugs I'd been avoiding for weeks

What's coming: encrypted multi-workspace support, a sandboxed plugin environment, and smarter task suggestions. I'm building this in the open and taking feedback seriously — if something annoys you, open an issue or just tell me here.

If you've been looking for a task manager that lives where you actually work — give it a shot.

→ github.com/programmersd21/kairo

Thanks for the stars. They matter more than they probably should.

It strictly follows the unix philosophy. Do only one thing, but do it right.

It goes with a vim like work flow. Everything is fully configurable in the config file.

https://github.com/thatmanspr/Scriptee

It works on linux (and mac if u manually install the dependencies). It doesn't work on microslop devices.

I shared this over in r/CLI and was really happy with how well it was received, so I figured I’d share it here too.

lsoff is a small cross-platform CLI/TUI for checking which processes are listening on TCP/UDP ports.

Run it with no arguments and you get a TUI where you can search, sort, inspect processes, and kill them if needed. It works on Windows, Linux, and macOS.

I did put some extra care into process termination. it tries to verify that the process is still the same one you originally selected instead of blindly trusting a PID.

I’ve also been improving the TUI based on feedback. j/k navigation, x to kill, expandable sockets for the same PID, and a cleaner shortcut footer.

Homebrew tap support was added recently too.

GitHub:

https://github.com/yutat23/lsoff

Feedback on the TUI/UX is very welcome!

Hey everyone,

rmcl has now reached v0.4.1.

For anyone who has not seen it before: rmcl is a keyboard-driven TUI Minecraft launcher for managing and launching Minecraft instances directly from the terminal.

Since the last update, both v0.4.0 and v0.4.1 have been released.

v0.4.0 is probably the biggest update rmcl got so far. The modrinth discovery feature I mentioned in my previous post is now finished and also got expanded quite a bit. v0.4.1 is only a small follow up update that fixes the update labels.

Changes are:

• built-in content discovery: Mods, resource packs, shaders, datapacks and modpacks can now be browsed and installed directly inside the TUI
• Modrinth and CurseForge support: Discovery now supports both providers. You can choose which provider should be preferred or also limit the search to only one of them
• modpack browser: You can now press m from the instance list to browse modpacks. The old URL, slug and local file import options are still available with i
• project pages: Projects now have actual detail pages with descriptions, images, links, supported versions and a version selection
• content updates: rmcl can now check installed mods, resource packs, shaders and datapacks for compatible updates and you can review and update them together
• version management: Press v on installed content to change its version or just reinstall the current one
• dependency management: Required mod dependencies are now installed automatically. Shared dependencies are also tracked so they don't get removed while another mod still needs them
• managed modpacks: Installed modpacks can now be updated, reinstalled or changed to another compatible version while keeping your worlds, configs, options and user added content
• datapack discovery: Datapacks can now also be browsed and installed directly into a selected world
• world improvements: Worlds now have better metadata cards and can also be launched directly from the world list

There were also a lot of smaller UI, safety and stability changes:

• mouse wheel scrolling is now supported
• discovery now has continuous scrolling and page jumping
• terminal images behave better around popups
• text inputs now support Ctrl+Backspace
• installs and updates now use staged operations, so if something fails the changes can be rolled back
• interrupted modpack updates can be recovered
• existing installations are automatically moved to the new managed content layout on first start and a backup of the old layout is created
• v0.4.1 fixes a small issue with the update labels

Overall the main goal of v0.4.0 was making content management a proper part of the launcher.

You can now discover, install, update, change and remove most Minecraft content without ever leaving the terminal. With Modrinth and CurseForge support rmcl is getting closer to covering most of the features people expect from modern Minecraft launchers like Prism Launcher, just inside a TUI.

As always, feedback, bug reports and suggestions are very welcome.

GitHub: https://github.com/objz/rmcl/

Release and downloads: https://github.com/objz/rmcl/releases/tag/v0.4.1

After years of using newsboat as my rss reader and pinboard.in for my bookmarking needs, I have decided to create my own tui reader + bookmarker.

Source