I built this because I wanted a calendar on the terminal and with a nice JSON output, so can I use it for scripting. Besides supporting Google Calendar, you can connect to any CalDAV server (on my own tests, I used with GMX and worked fine).

It's my current daily-driver calendar. Any feedback is welcome.

GitHub: https://github.com/DouglasdeMoura/chroncal

This software's code is partially AI-generated (I put the attribution on the harness and the LLM used on the git commits).

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.

[removed]

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.

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!

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

When a host is unreachable, troubleshooting usually means running ping, dig, curl, and traceroute, and others, then piecing their outputs together.

So I built Network Doctor to solve that issue!

It checks the connection in stages, and explains where the chain failed in plain English.

Check it out: https://github.com/heymaikol/network-doctor

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.

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 created a cli tool with rust for mainly windows terminal users (like me), when I try to compare performance with robo copy, I see that mine is mostly faster but after one copy for benchmark, it’s been cached and it’s finishing very fast. So results starting to be useless. If anyone can guide me or give an advice will be much appreciated. Project is open source any contribution also is welcomed.

https://github.com/CanManalp/cpr

Cottage is a tool for teams to manage age-encrypted secrets in git repositories.

It provides a simple workflow to encrypt/decrypt secrets, manage recipients, and keep secrets out of the repo while still allowing for easy sharing via VCS. Cottage also generates redacted previews of encrypted secrets for better visibility and supports both persistent and temporary decryption workflows, while ensuring secrets are never committed in plaintext.

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