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.

¡Hola a todos!

Hoy les traigo otra de mis herramientas, que acabo de lanzar.

- Permítanme explicarles brevemente la nueva herramienta: Renombrador.

Renombra archivos y carpetas por lotes con vista previa y función de deshacer, ya sea desde la terminal o haciendo clic derecho en Nemo. Puro Bash, sin dependencias pesadas. Para más detalles sobre lo fácil que es renombrar cientos de fotos, archivos y más, consulta el repositorio.**

🔗 Renombrador: https://github.com/filonux/Renombrador

🔗 Renombrador documentación: https://filonux.github.io/Renombrador/

Como siempre, la herramienta está actualmente en español, pero si la comunidad lo solicita (a través de estrellas de GitHub, comentarios o cualquier otro medio), lo incluiré en la agenda para su implementación. Lo mismo para un archivo .deb.

- También he actualizado Scriptya. He añadido una pequeña opción para cambiar los iconos de los scripts instalados, así que puedes ir cambiándolos hasta encontrar el que más te guste. Ahora incluso puedes cambiar el icono de Scriptya y usar el del repositorio.

Seguiré publicando más software de código abierto cada semana. Por ahora, seguimos en la era clásica, pero poco a poco avanzaremos hacia tecnologías más complejas. Todavía tengo mucho que compartir con vosotros.

Como siempre, estaré muy pendiente de vuestras contribuciones, comentarios y sugerencias.

Dejo mi correo electrónico de contacto abajo para quien quiera ponerse en contacto conmigo, ya sea para colaborar o para cualquier otra propuesta.

¡Os deseo lo mejor!

“Quiero usar la tecnología, no que la tecnología me use a mí.”

Filonux

- Correo electrónico: filonux@proton.me

-----HERRAMIENTAS DE FILONUX-----

1🔗 LinuxMint-Scripter: https://github.com/filonux/LinuxMint-Scripter

2🔗 Scriptya: https://github.com/filonux/Scriptya

3🔗 Escritura: https://github.com/filonux/Enkripta

4🔗 Eliminador de MintApp: https://github.com/filonux/MintApp_Remover

5🔗 Administrador de inicio automático: https://github.com/filonux/Autostart_Manager

6🔗 Configuración perfecta: https://github.com/filonux/Mint-Setup

7🔗 Mint-Doctor: https://github.com/filonux/Mint-Doctor

8🔗 Color-Mint: https://github.com/filonux/Color-Mint

9🔗 Browser-Cleaner: https://github.com/filonux/Browser-Cleaner

10🔗 Simple-Backup: https://github.com/filonux/Simple-Backup

🔗 Repositorios de GitHub: https://github.com/filonux

Hey, I wanted a clearer way to see which skills I had installed across tools like Claude Code, Codex, Cursor, and others.

I couldn’t find a simple tool focused specifically on browsing local skills. There probably is one, but I didn’t come across it, so I built skillbrowse over the weekend.

It scans the usual skill folders, lists what it finds, and lets you search through the skills and read their SKILL.md files from the terminal.

It’s still an early version, but it was a fun project to work on and already solves my immediate problem.

GitHub: https://github.com/dchancogne/skillbrowse

Feedback, bug reports, and pointers to similar tools are appreciated. And I'd love a star on the repo if you find this tool useful.

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.

Hey everyone! Hope I don’t get roasted for this 😅 I’m here with a fun little intro video.

My goal is simple: build something genuinely useful for everyone.

I originally built this tool just to improve my own productivity. I was using the native Mac Terminal, but managing multiple projects — especially projects I connect to remotely over SSH — had become a complete nightmare. On top of that, I was also keeping VS Code open mostly for Git, which was adding even more overhead to my machine.

So, as a solution, I built a program with Claude where I could manage all of my terminals on a single canvas.

But things got a little out of hand 😅

I kept adding features, and it eventually turned into something close to an autonomous development environment.

So, what can you actually do with it?

• Your terminals are persistent. You can close the app, lose your connection, reconnect over SSH, and continue with the exact same layout and sessions.
• You can connect to a server over SSH and manage all of its terminals as if they were local. Drag & drop, images, and everything else still work.
• You can continue your sessions from your phone.
• Git operations like push, pull, commit, etc. are built in.
• Terminals can communicate with each other. You can connect their contexts, and with skills, one terminal can read or use information from another terminal’s context when needed.
• You can also do orchestration. For example, you can tell one terminal: “Start a Claude Code session for the frontend and act as the orchestrator,” and have it manage the other sessions.

But yeah… I’m a bit stuck right now.

To keep pushing the project forward, I either need a sponsor or simply some motivation from the community.

If you can leave a few words of feedback, I’d really appreciate it.

And if that’s too much to ask, I’d happily settle for a GitHub star ⭐️

Much love,
Enes

Website: nodeterm.dev

Repo: https://github.com/eneskirca/nodeterm

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.

Every week I'd hit some flag combo I'd used before, forget it, and end up back googling the same thing — or get lucky and find it in my shell history, if I remembered it just a little bit.

So I created recall — save a command once, label it your way, then find it and run it straight from your shell. No copy-paste required.

The one that finally pushed me to build this: I SSH into a bunch of different servers, each with its own port, key, and options. I got tired of digging up or copy-pasting the right command every time.

github.com/parthsigdel/recall — feel free to give it a try, still actively working on it.

Tiny high-level programming language built in less than a month *without* any AI assistance as my first ever C++ project at 17.

- No dependencies
- Close to Python/NodeJS performance, in some cases faster (see benchmark)
- Tiny memory footprint
- Tiny executable size
- Incredibly modular. Pick & choose everything.
- Nones, Bools, Ints, Floats, Strings, Arrays, Maps (dict), & user defineable types*
- I/O, Math, File Managment, Time, Str/Arr Util, & full ANSI modules all included, most are embedded into the executable itself.

Why make this? I wanted a portable & embeddable language that was fully sandboxed, very memory efficient, & has all the essential high-level language features, all while being under 200KB in size. I have looked all over, the language I was looking for just didn't exist, so I made it myself.

I want to keep working on it & improving this because I know this is something a lot of people beside me would find useful, giving a star really helps

https://github.com/PhosXD/Ity

Everything is open source & free to use!

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)

https://github.com/CallMeAlphabet/fasthex

fasthex swaps in for xxd or hexdump on Linux, but runs about 55 times faster than xxd and 140 times faster than hexdump thanks to memory mapping, multi threading, and AVX2 SIMD. It still handles all the display modes you'd expect, can reverse a dump back into binary, and needs nothing installed.

The benchmarks in the video are made with my timing utility timeit. The benchmarks in the video and in the table below as well the GitHub repo differ, because of caching and different testing conditions.

Benchmarks:

Tool	Time	Speed vs fasthex
fasthex	0.78s	1x (baseline)
xxd	43.62s	55.5x slower
hexyl¹	53.14s	67.6x slower
hexyl	104.93s	133.5x slower
hexdump	116.03s	147.5x slower

¹ --color=never was used to avoid colors.

2 standout features:

1. Reverse mode. Turns a hex dump back into binary with -r, something xxd can do but hexdump can't, useful for round tripping edited hex output straight back into a file.

2. Zero dependency pre-built binary. One static x86_64 executable, no runtime libraries, no interpreter needed, drop it anywhere and it just runs.

Install:
Arch: paru -S fasthex / fasthex-bin

Non-arch:
cargo install fasthex

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.

So I wondered sometimes, how little info we have when we install NPM packages.. so I built revera... its a npm package scorer, but on steroids. It uses a complex sophisticated algorithm (still not perfect, but near-perfect) that nails at ranking NPM packages.. it gives every package a score and the score is determined on criterias such as maintainability, trust, package releases, downloads, much more..

the audit command scans the working directory for

it has the following extra features:

• logging in with github for higher rate limits
• why command for explaining a certain package's score
• doctor for checking if everything is working
• caching system which lives for 24h on local machine
• and a customizable config

It would mean the world to me if you all could try it out and give feedback (bad or good)!

github repo: https://github.com/aaravmaloo/revera

npm package page: https://www.npmjs.com/package/@aaravmaloo/revera

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

Would love any feedback.

https://github.com/danfry1/waxon

I always wanted to AFK in Roblox/Sober while doing other stuff on my PC, but traditional auto-clickers weren't really what I wanted. They take over your mouse/keyboard input, which gets annoying when you're trying to code or work in another window. Also, other tools are prone to getting you banned.

So I made Roblox Caffeine. Instead of simulating mouse clicks or injecting anything into Roblox, it creates a virtual Xbox 360 controller through Linux's /dev/uinput interface and periodically sends a tiny controller input to keep the game from considering you idle.

This way, you can leave Roblox/Sober running in the background and move the window to another workspace while coding or doing other work-related tasks.

I originally made it specifically for Roblox on Linux/Sober, but since it's just exposing a virtual gamepad, it can potentially work with other games that accept controller input and have idle kick timers.

https://github.com/EbadShelby/roblox-caffeine

Any feedback will be appreciated.

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.

After spending a long time tweaking my zsh config, I ended up with no plugin manager and no custom prompt!

Everything is native, lazy-loaded, and deferred.

Minimal native prompt, fast startup, and modular config.

btw, I'm loading 9 plugins and multiple config files for fzf, function, etc..

Only 11 lines in .zshrc

Here are my zsh-bench measurements on login:

first_prompt_lag_ms=16.963
first_command_lag_ms=17.380
command_lag_ms=13.187
input_lag_ms=3.318
exit_time_ms=15.100

feel free to check the repo:
https://github.com/houssamouhra/zsh-config

It’s a really small cross-platform tool for checking listening TCP/UDP ports.

Run it with no arguments and you get a TUI where you can browse, search, sort, inspect, and kill processes interactively.

Or keep it simple:

> lsoff 8080
PROTO  PORT  ADDRESS  PID    PROJECT  PROCESS  PATH                                       CMD                                 CWD
tcp    8080  0.0.0.0  85783  yuunama  node     /opt/homebrew/Cellar/node/25.5.0/bin/node  node /opt/homebrew/bin/live-server  ~/mywork/yuunama

You can also search by process name, PID, path, command line, project, and more.

I’m sure something similar already exists, but I wanted one simple tool that works the same way 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.

https://github.com/yutat23/lsoff