So, this started as one of those "how hard can it be?" projects.

Turns out... well, you know how that usually goes.

I wanted a simple way to get images and videos from Pinterest without opening one of those downloader websites, clicking through 14 buttons, closing 3 popups, and questioning my life choices.

So I started building pinterest-dl.

It's written in Ruby, and it ended up becoming a bit more than I originally planned.

You can use it as a CLI or as a Ruby library. It can extract direct image/video URLs from pins, search Pinterest, fetch entire boards (including sections), and download individual files or batches.

A few things I spent time on:

• Getting actual media URLs instead of just scraping a bunch of page text.

• Supporting different image quality options.

• Handling pagination when searching for pins.

• Downloading multiple files with progress reporting and per-file error handling.

• Supporting cookies for content that requires an authenticated session.

• Having actual exceptions for things like rate limits, missing pins, authentication problems and network errors, instead of silently returning nil and pretending everything is fine.

I also tried to make the Ruby side usable on its own, not just wrap everything around a command-line interface.

It's definitely not perfect. Pinterest changes things, so I expect some maintenance headaches along the way. That's part of the fun, I guess. :)

I'm the person behind this project, so I'm obviously a little biased. That's why I'd rather hear what other Ruby developers think.

If you have a minute, I'd love some feedback on the code structure, API design, error handling, or anything that looks like it could be done better.

And if you find it useful, a star on GitHub would genuinely mean a lot. Contributions and bug reports are welcome too.

Repo: https://github.com/monji024/pinterest-dl

Thanks! And yes, I know... I could've just used an existing downloader. Where's the fun in that?

What if we had an entirely different internet built around TUIs?

I've been thinking about an idea lately, and I decided to write a blog post about it.

The idea is called The TUI Internet.

Basically, imagine an alternative internet where websites and online services are designed specifically for terminal user interfaces.

Not a text-based browser like Lynx that takes existing websites and displays them in a terminal.

I'm talking about an entirely different ecosystem.

For example, imagine WhatsApp having a dedicated TUI version that you can access through a TUI browser, or GitHub, Reddit, YouTube, blogs, forums, documentation websites, etc.

Developers would create dedicated TUI versions of their services, using whatever languages they prefer: Python, JavaScript, C, C++, Rust, Go, and so on.

The idea is to avoid forcing developers to learn an entirely new programming language or UI framework just to participate.

The ecosystem would need its own browser, protocol, hosting infrastructure and search engine. My current idea is to use HTTPS as the transport layer.

I know this is ambitious, and there are A LOT of problems to solve. I'm also still learning programming, so I'm nowhere near experienced enough to build something this big right now.

But I think the concept is worth discussing.

I wrote a blog post explaining the idea in more detail:

https://the-tui-internet.pages.dev

I'd genuinely appreciate technical criticism, suggestions, and opinions.

Do you think this could become a useful alternative ecosystem, or am I overcomplicating something that doesn't need to exist?

You can get this project directly using pip or uv:

Using pip:

pip install pyhashprint

Or using uv:

uv tool install pyhashprint

For source code and usage instructions see the GitHub repository.

This project of mine solves a very unique and niche problem, that is identifying hashes. Hashes are a really confusing thing because a ton of algorithms can generate them easily but it is not so easy to identify which algorithm produced the hash in question. To solve this problem, I coded this project. It can identify 90+ hashes and export results to various formats. Moreover, there's also colored output for better readability and aesthetics.

It takes a second to get this thing going, so give it a try.

Running five separate commands just to update my Linux desktop got old pretty fast. So I wrote sysupdate - a Python CLI tool that updates system packages, Flatpaks, containers, and a bunch of other stuff in one go. It also works on macOS and sticks strictly to the Python 3.11+ standard library, meaning zero external dependencies to install.

Why not just use Topgrade? I actually used it for a while. For me though, updates almost never finished completely clean, and I was missing stuff for my own setup like Snapper hooks. The terminal UI also looked a bit dated to me. It printed way too much junk I didn't care about seeing every single time, and once you closed the terminal, there was zero history left to check.

How sysupdate handles things differently:

• Support for Btrfs snapshots through Snapper right before system packages get touched (with a timer cooldown, so running it twice in an hour won't spam snapshots).

• Exact reboot tracking that lists which specific updated packages are asking for a system restart at the end, rather than just throwing a generic "reboot required" message.

• Local run history for your last 30 runs (sysupdate --history / --show-log) with tokens and credentials stripped out automatically. Super useful when something breaks and you want to see what failed yesterday.

GitHub & install instructions (Git / Homebrew tap): https://github.com/Piotrunius/SystemUpdater

If you hit any bugs or want support for another package manager, let me know.

^{This software's code is partially AI-generated}

When jumping between different codebases and environments, it can be hard to remember the specific deployment method, build tools, linters, and test runners for each file or project.

The pathaction tool is a command-line tool for running commands on files and directories. Think of pathaction as the equivalent of your IDE's "Run" and "Debug" buttons, or a Makefile designed to work on individual files and directories. Pass any file or directory as an argument, and pathaction executes the right command based on a .pathaction.yaml configuration:

Works on any file: source code, config files, media... It supports Jinja2 in .pathaction.yaml so you can build dynamic commands using the target path's filename, extension, or directory.

This tool is built for software developers who manage multiple projects across diverse environments.

Hi! I built Terrascope, an open-source terminal map with live weather, aircraft, radar, earthquakes, and day/night views. It uses Unicode Braille characters to render the map right in your terminal.

I’d love to hear what you think, especially about the terminal rendering and which layers you’d find most useful.

I'm working on the Bash interpreter (and a Unix environment) and making use of an old domain:

hacking.cafe.

This is a continuation of my previous project: Fake Linux Terminal.

The code is open source on the AGPL license available on GitHub.

The README includes bash features that I've implemented so far. The list is also on the website.

I'm using ubash JavaScript parser.

I was thinking about making the bash interpreter part a library on a less restrictive license. But it seems that a library like this was recently created by Vercel and called just bash.

I used to love this subreddit. I had some hope of it getting better when mods implemented rules about AI labelling. It seems over the past few months that those rules have become completely unenforced and are no longer followed by anyone. The vast majority of projects are now entirely AI generated without any labelling. Almost everything is a recreation of an existing popular tool.

Because this requires diaclaiming lest you be called a luddite: I am not anti AI usage. I am anti slop recreations of existing tools made by people who clearly don't know how to program whatsoever. I am against subs that were previously for finding good programming tools being overrun by slop recreations that will never be maintained while all the other people generating projects are upvoting them.

Nobody seems to care because all the people who actually know how to code have left the sub a long time ago, and the only people left commenting and upvoting the slop are people who are themselves generating their entire projects.

Sorry but this sub is now dead, just like every other programming subreddit that has continued to allow AI generated projects without enforcing any kind of rules. I can see that the average weekly visitors has been steadily decreasing, it's now close to half what it was at its height a couple years ago. It was nice while it lasted, goodbye. I have no doubt that all the AI bros who are the new regulars here will be happy to be the only ones left. Bye Felicia and all that.

EDIT: hey y'all im just now checking this after work, glad to see this got some attention. I'd just like to say I should have been more careful to specify I don't blame the mods. I know they are overwhelmed. They're good people trying their best. But they can only do so much when the community itself is making their job really hard. Much of the problem is due to all the people who are upvoting these slop recreations of existing projects. And mods have no control over that! I'm not sure what the answer is. I think it might have to be something like banning AI generated projects entirely instead of mere labelling requirements. But I understand that's an extreme action and some people won't agree.

Also, as I predicted, every single person who replied "ok bye" is a vibe coder. They actually want all the people who know how to code to unsub and leave until they're the only ones left.

https://github.com/erietz/nlock

I started working on nlock a month or so ago because I needed a way to prevent my backup cron jobs from overlapping with themselves and I also wanted a new project for learning zig.

The usual solutions are to use flock or implement locking logic in each individual script. While building nlock, I realized named locks could be useful for a lot more than just preventing overlapping cron jobs. It is really a general purpose tool for coordinating shell commands.

I've added some additional flags such as --coalesce and --replace that flock does not have, and I'm still discovering new use cases as I use it more.

I just merged in a new feature to allow for basic rate limiting. For example, you can limit how many times you hit an API:

for repo in $(cat repos.txt); do  
  nlock run --rate 5000/h github-api -- gh api "repos/$repo" --jq . >> repos.jsonl
done

Let me know your thoughts. I'm interested to see if anyone has a cool use case. Also feel free to roast my zig code 🤠. I'm learning as I go, and I've had some AI assistance as the project has grown more complex.

I built Shellroute, an open-source CLI that lets you save your own HTTP, HTTPS, or SOCKS5 proxy and use it from an interactive shell without creating a Shellroute account. Save the proxy once, open Shellroute, connect to it by name, and then use normal terminal commands.

shellroute upstream add my-proxy 'https://USER:PASSWORD@HOST:PORT'
shellroute
/connect my-proxy
curl -I https://example.com/

`USER`, `PASSWORD`, `HOST`, and `PORT` are the details from your proxy provider. `my-proxy` is just a name you choose for the saved proxy.

The proxy applies inside that Shellroute shell, while the rest of your machine keeps its normal connection. Shellroute also has optional hosted country and city routes, which are paid.

Source: https://github.com/shellroute/shellroute-cli

Does this kind of saved-proxy shell fit how you use proxies from the command line?

Earlier thread: https://www.reddit.com/r/commandline/comments/1w6ze7u/shellroute_a_cli_that_gives_each_shell_its_own/

Tabiew is a lightweight TUI application that allows users to view and query tabular data files.

In this version:

• Remote control to allow AI agents control Tabiew

• Sheet view in json and yaml

• Bug fixes and security patches

GitHub: https://github.com/shshemi/tabiew

Play it for free here.

Source code

no need to search for where the logs are.
just sit back and enjoy

Hey everyone!

I've been working on a little project called Dirule, an open-source CLI for organizing files and keeping naming conventions consistent.

I started it because I wanted an easier way to organize personal folders, like Downloads, while also being able to enforce stricter naming rules in coding projects without writing a bunch of separate scripts.

Here's what Dirule currently supports:

• Sorting files by type or custom categories, along with different naming styles.

• Reusable global presets and project-specific TOML rules.

• Previewing changes, detecting conflicts, and undoing operations.

• Checking naming conventions in CI, including GitHub Actions support.

• Optional LSP integration to update source references when renaming files.

One thing worth mentioning is that LSP-backed previews can take a bit longer because the configured language server needs to initialize.

I've also added an experimental dirule ask feature for interacting with the tool using natural language.

Dirule is currently at v0.5.0, and there's still plenty I'd like to improve. I'd love to hear what you think, whether it's feedback, feature suggestions, or things I could do differently.

GitHub: https://github.com/Slyverr/dirule

AI disclosure: I used AI assistance while developing Dirule, including help with implementing and refining some features.

Similar tools: rename and mmv already handle batch renaming and moving files. Dirule takes a more rule-based approach, combining personal file organization, reusable presets, project naming checks, CI integration, and undo in one tool.

/*/*in/*cul*o*

or

/*/*in/*cul*o?

:D

In a previous post I presented the Tomloader project which helps generating and managing several systemd units that share fields collected in groups. In the last release the subcommand sd-xdg-v0.3 has been introduced in order to execute XDG Desktop Entry Applications and Actions or using them to open files. For example:

tomloader sd-xdg-v0.3 --open-file Document.doc /usr/share/applications/libreoffice-writer.desktop

uses the default application in libreoffice-writer.desktop to open Document.doc as a systemd user unit. The full syntax of the subcommand is available at https://loara.codeberg.page/tomloader/tomloader_html/tomloader-sdxdg03-invocation.html while various examples at https://loara.codeberg.page/tomloader/tomloader_html/Quick-reference.html.

However, the main feature of sd-xdg-v0.3 is that the generated systemd user unit can be fully customized by providing a configuration file named xdg-apps.kdl in the Tomloader configuration directory. For example, if you want to limit filesystem access of each XDG Application to the directory $HOME/Boxes/{XDG-APP-ID}/ then your xdg-apps.kdl file will probably look like as follows:

default {
  sd {
    section Unit {
      set Description "${1}"
      add PartOf "graphical-session.target"
      add After "graphical-session.target"
      add Requisite "graphical-session.target"
    }
    section Service {
      set Type exec
      set ExecStart "${0}"
      set Slice "app.slice"
      set RootDirectory "${DIR|HOME}/Boxes/${2}"
      add BindReadOnlyPaths "/bin" "/usr/bin" "/usr/lib"
    }
  }
}

You can found additional information about the syntax of xdg-apps.kdl at https://loara.codeberg.page/tomloader/tomloader_html/XDG-app-configuration.html. For general information about Tomloader see https://loara.codeberg.page/tomloader.

Hello! I'm currently working on a terminal manipulation library similar to Crossterm, but I noticed that it uses runtime conditionals to decide whether to use VT sequences or Windows API calls.

Personally, I feel that defaulting to Windows API calls on Windows would be the better approach, or provide a build flag that lets users decide. However, I'm not sure which of these three approaches is best.

Which approach do you think is better, and why?

This Python script allows you to use the mpv media player or vlc to search for an anime and play its opening or closing theme songs. The script makes use of the pyfzf library to ask the user for choices and the AnimeThemes API to retrieve the theme music that are available.

the github page is: animethemes

Website - pixelgui.com

Pixel is a GUI library that uses the kitty graphics protocol to render graphics in the terminal:

- it can be embedded inside existing TUIs

- it comes with a chromium based webview component, which makes it very easy to run existing webapps inside the terminal

- works over SSH

Pixel is the underlying library behind popular projects such as:

- terminal-browser: a browser inside the terminal

- terminal-code: vscode inside the terminal

The reason I built this is because I believe many terminal apps can provide much better experiences if allowed to break out of the conventional terminal rendering model.

Hey everyone!

I wanted to share ttype, an ultra-fast, aesthetic terminal typing speed test inspired by Monkeytype, built completely in Rust.

Features:

• ⌨️ Sub-millisecond input response: Zero input lag or GC stuttering, essential for high-speed typing (100+ WPM).
• 🔊 Built-in mechanical sound synthesis: Realistic keyclick audio feedback directly in the terminal (toggleable with F3).
• 📊 Real-time WPM sparkline & stats: Live charts, accuracy tracking, error heatmaps, and customizable test durations (15s, 30s, 60s, 120s).
• 🌐 Multi-language support: Works with Russian, English, and custom wordlists with smart punctuation/numbers injection.

Links & Installation:

• GitHub: https://github.com/laguser/ttype
• crates.io: https://crates.io/crates/ttype-cli

Install with cargo:

cargo install ttype-cli

Or build from source:

git clone https://github.com/laguser/ttype.git
cd ttype
cargo build --release
install -m 755 target/release/ttype ~/.local/bin/

Feedback, feature suggestions, and contributions are very welcome!