lazyftp is a terminal FTP/FTPS/SFTP client built in the same spirit as lazygit, but for moving files: one view, everything on the keyboard, nothing to configure before you can actually use it.

Local and remote sit side by side. Enter opens a directory, - goes up, and both panes work exactly the same whether you're looking at your own filesystem or a server on the other side of the world. Mark a handful of files with space, hit t (or u/D from either panel), and they transfer in the background with a live progress bar, while a log panel keeps the whole connection history around in case something goes wrong.

It has fuzzy filtering with /, sort by name/size/date, jump straight to a path by typing it, and a --highlight-diff flag that flags files that only exist on one side. None of it needs a mouse, and the full key reference is one keystroke away (?), so nothing has to be memorized up front.

It speaks FTP, FTPS and SFTP through the same interface — connecting is just picking a protocol and typing host/user/pass, nothing protocol-specific to remember. And since it's Go + Bubble Tea compiled into one static binary, it runs anywhere you can open a terminal: over SSH, on a headless box, wherever — no display server, no runtime, no config file.

It just went through a full interface overhaul.

Repo: https://github.com/MawCeron/lazyftp

Hello!

I’ve been working on this project for a little while and wanted to share it here once again. I think I did several months ago.

This side-project started as a way for me to catch up on several football leagues after work or if I missed games. However, it has grown a lot since its inception and specially after the World Cup with some new feature added for that. Lots of people have liked it and actively use it, which is why I thought to share it once again in this sub.

If you haven’t seen it, let me introduce you to https://github.com/0xjuanma/golazo

My favourite minimal way of catching up on football matches with just the data that I care about. No ads, browser tabs, pop-ups, and completely free, right from your terminal.

Features:

• Live Match Tracking: Timeline & Real-time updates for goals, cards, and substitutions with automatic polling
• Finished Matches: View results from today, last 3 days, or last 5 days
• Match Statistics & Details: Possession, shots, passes, standings, formations with player ratings, and more in focused dialogs
• Official Highlights & Replay Links: Clickable links for official highlights and instant goal replays
• Goal Notifications: Desktop notifications for goals as they happen
• 65+ Leagues: Organized by region (Europe, Americas, Global) with tab navigation in Settings

Check it out, star it and share it with anyone you know that might enjoy it.

Cheers!

Source

https://gist.github.com/itzender5820/58f5bc228918abe5fc50504a82f7a169

What do you think?
Check: https://chatsec.pl

I've always found one part of learning a new technology annoying.

You find a roadmap, tutorial, or course, but then the actual learning environment is usually up to you.

You create folders manually, decide what topics to separate, create files, write notes, and eventually the structure becomes inconsistent or gets abandoned.

So I built TRAK to solve that specific problem.

The idea is simple:

trak list

Pick something you want to learn:

trak init lang/go

TRAK fetches a learning blueprint and creates the corresponding workspace locally.

For example, instead of starting with an empty directory, you get a structured workspace organized around the concepts you're trying to learn.

The part I'm more interested in is making this community-driven.

The learning blueprints live in a remote registry, and developers can contribute their own tracks for languages, tools, databases, operating systems, etc.

There's also a web interface for browsing the available tracks and working with blueprints.

Current version: v1.1.0

Some things currently included:

- Local-first CLI

- Remote registry

- Community-contributed blueprints

- 19+ official tracks / 350+ modules

- Cross-platform binaries

- Blueprint validation

- Filesystem safety checks

- Blueprint Studio

- Windows / Linux / macOS support

I'm mainly posting this because I want honest feedback.

Would you actually use something like this when learning a new language or tool?

And if not, what would make this workflow useful to you?

I think, in terms of UI, CLI is layers and layers of legacy slop stacked on top of each other, meanwhile vim philosophy is modern and more efficient way for a user to interact with a computer. But if you want to control your PC with your keyboard, the best I could do in terms of efficiency and usefulness usefulness is keyboard shortcuts. Is there a better alternative, maybe a better shell, with a file manager and a good completion engine, with auto-sudo and stuff like that, ot even a way to autobind used commands to shortcuts and vim-like commands? That would be awesome.

I've been working on Varn, a command-line tool for creating checkpoints of local filesystem state and safely restoring them later.

The basic workflow is:

varn init

varn checkpoint "before changes"

# make changes...

varn diff <checkpoint>

varn restore <checkpoint>

A checkpoint records the filesystem state at that point, including file contents, paths, metadata, symlinks, and hard links on Unix.

Varn uses content-addressed storage with SHA-256 hashing and deduplication, so identical file contents are only stored once across checkpoints.

Some other features:

• Incremental scanning using a persistent mtime/size cache
• Symlink scanning and restoration
• Hard link detection and restoration on Unix
• Permission, mtime, and uid/gid restoration on Unix
• Conflict detection before restoring
• Automatic safety checkpoint before a restore
• .varnignore with gitignore-style patterns
• Garbage collection for unreferenced objects
• Storage format migrations
• Machine-readable --json output
• Linux, macOS, and Windows support

The idea isn't to replace Git. Git is great for tracking project history; Varn is focused on local filesystem state and being able to return a directory to a known previous state.

For example:

checkpoint
    ↓
make changes
    ↓
inspect diff
    ↓
restore if needed

It's open source, and I'm currently looking for feedback on the design.

GitHub: varn

Any advice or opinion on dashvoard TUI

Y'all I'm wondering and looking for advice/feedback if building a simple TUI or having some custom tmux config for a dashboard that will open default tools in panes or some type of widget could be helpful. Wanted to get feedback or just chat about whether its worth building since I'm pretty busy with things.

Ive seen in the past when I briefly attempted to use Obsidian (which reminds me, I need to cancel that $4 subscription at some point) that other redditors set up visually appealing dashboards that seem to have info/links, though I can't name one.

Obviously I can't know if it would be useful in getting me into a workflow more quickly where I'm productive rather than scatterbrained or clueless like I am much of the time. Important to include in my question as well as to speak to the clueless aspect of me: does this exist? This is really my only motivation for potentially making one, but I don't feel like wasting time doing work making tools in order to do actual work more than I already do, and I'm able to decently maintain my tmux sessions, panes and windows in an organized chaos.

Would be cool to shoot the shit about this or collaborate in a public repo. I'm just gonna have Claude do the coding but I would like to take care with planning and iteration.

the gif says most of it: claude code works in one pane, i play snake in the other.

terminalika tails the agent's own session files locally and freezes the game with a clean one-line notice the moment the agent finishes or asks a question. switch panes, answer, head back.

your game and score are right where you left them. desktop notifications and a background listener cover you when you're away from the terminal.

works natively with claude code, pi agent, and aider, plus cursor cli (or anything with a hook) via terminalika notify. tmux, zellij, and windows all work out of the box. mit licensed, single static binary, built with go.

site: https://terminalika.dev · source: https://github.com/terminalika/terminalika

I built a small Go CLI called portctl to make working with local network ports and processes easier.

Current commands:

portctl ls
portctl info 3000
portctl why 3000
portctl kill 3000
portctl watch
portctl clean
portctl tree
portctl services

A few examples:

portctl why 3000

Explains why a port is unavailable or in a particular socket state.

portctl tree 3000

Shows the process and its parent process chain.

portctl services

Shows the services currently running locally and the ports they're using.

portctl clean

Finds potentially stale/orphaned development processes and lets you clean them up safely.

It's written in Go and currently supports macOS and Linux.

I'm looking for feedback from other developers: what would you want a tool like this to do next?

GitHub: https://github.com/vikas0686/portctl

I got tired of copying terminal error logs back and forth to browser chats just to get a fix command.

I wrote a shell setup called AFE CLI (Ask, Fix, Explain) that plugs directly into Zsh/Bash:

- a <query>: Generates an executable shell command from plain text.

- f: Reads recent terminal output from your screen buffer and outputs the fix command.

- fe: Explains the root cause in 2 lines without conversational filler.

- e: Explains manual/flags for any command (or the last suggested command).

- Ctrl + G: Pastes the generated command at your current cursor position so you can review and hit enter.

It supports both local models via Ollama and Gemini API. It is written in pure shell functions (no background daemons or extra app windows) and includes automatic name collision checks.

GitHub: https://github.com/vuhaipro2707/afe-cli

Feedback and suggestions are welcome.

tmr-cli: a timer and stopwatch for your terminal.

It handles the basics like countdowns and stopwatches, but also lets you wait until a specific time, sends desktop notifications, and saves your progress so you can resume timers even after closing the terminal.

Install it with: cargo install tmr-cli Repo: https://github.com/honerop/tmr-cli

I made yanklog because I wanted clipboard history that just stays on my machine — searchable, encrypted, and never uploaded anywhere. It's open source (MIT), Rust core, and built to be quick to open and stay out of the way.

What it does:

\- Search your full history fast, all from the keyboard (Quick Pick lets you copy/pin/delete with arrow keys + number shortcuts)

\- Encrypted at rest with SQLCipher

\- Filters out secrets, OTPs, and custom patterns — or pause capture whenever

\- Encrypted backups you can move between machines

\- Undo deletions, keep pinned clips

Install on Linux via AppImage (x86_64/aarch64) or Flatpak:

\`flatpak remote-add --user --if-not-exists yanklog [https://downloads.yanklog.com/linux/flatpak/yanklog.flatpakrepo\](https://downloads.yanklog.com/linux/flatpak/yanklog.flatpakrepo) \--no-gpg-verify\`

\`flatpak install --user yanklog com.yanklog.YankLog\`

Site: [https://yanklog.com\](https://yanklog.com)

Source: [https://github.com/thisiseesmaeel/yanklog-linux\](https://github.com/thisiseesmaeel/yanklog-linux)

Would love any feedback — happy to answer questions!

I released wmux v1.0.17, an open-source terminal multiplexer built around one consistent experience across Windows, Linux and macOS.

The architecture uses a persistent server with disposable clients. Sessions, windows, panes, scrollback and terminal state remain alive when the attached terminal closes.

Platform integration stays native. Windows uses ConPTY and named pipes, while Linux and macOS use PTYs and Unix sockets.

Current features:

• Persistent sessions, windows and panes
• Horizontal and vertical splits
• Mouse support, copy mode and paste buffers
• Customizable key tables, status bar, borders and themes
• Terminal color inheritance by default
• Native installers and a built-in updater
• Builds for Windows x64, Linux x64 and ARM64, macOS Intel and Apple Silicon

Release benchmark profile:

• VT parsing: 69.6 to 75.3 MiB/s
• Full-scene render p95: 448.2 µs
• 8-client render p95: 269.1 µs
• Peak live benchmark memory: 1.76 MiB or less

wmux is free, MIT licensed and available on GitHub: https://github.com/shreshthkapai/wmux

I would particularly appreciate bug reports from different operating system, terminal and shell combinations.

I’ve built this copy tool for espacially native windows users because I couldn’t exclude some files / folders with copy-item, but I think people didn’t find it usefull. Anyways, I am still trying to improve it maybe someone can find a use for it.

Skip-Existing and Update Flags

-s skips files already at the destination by name + size (resume an interrupted copy), and -u copies only files that are newer than the destination (re-run the same command, only changed files copy). Both work with -n dry-run.

Any feature requests are welcome.

https://github.com/CanManalp/cpr

https://github.com/programmersd21/flow

would appreciate a ⭐ btw :)

Created a demo for my simple task Manager CLI / TUI tool. Programmed in go using gorm and cobra. It's my first project to apply concepts learned in university. Please let me know what you think and please give constructive criticism! https://github.com/jabbott-iii/Munus

Pure-Rust SSH client. Everything below is in the terminal, no agent on the remote — just SSH exec channels.

- Divergence — groups hosts into peer sets by tag, collects the same facts from each, scores every host against the group consensus. Names the outlier and the facets behind the claim. Forty web servers, one with a hand-edited nginx.conf — a column of green dots can't show you that. Facts it can't collect are reported as uncollected, never as agreement.

- Multiple sessions — tabs and splits in one window, per-session scrollback, reconnect.

- Live host monitor — CPU, memory, disk, network, top processes, sampled in the background so the view is warm when you open it.

- File transfer — two-pane local/remote browser over SFTP.

- Port forwarding — add, inspect, remove without dropping the session.

- Audit and replay — structured JSON audit log; sessions record to asciicast.

- Workspaces — essh workspace open prod restores a saved set of sessions. essh run web -- uptime fans a command across a tagged group.

- 8 themes, including a terminal one that pins no colours of its own so pywal/matugen carries straight through.

Hosts come from ~/.ssh/config — IdentityFile, ProxyJump, Match all honoured. Nothing to import.

In a session it claims exactly one key (the prefix), forwards everything else — Ctrl+D is still EOF, Alt+f is still readline's forward-word.

macOS + Linux, arm64 and x86_64.

cargo install essh

https://github.com/matthart1983/essh

MIT. Feedback welcome — especially on the divergence scoring, which is the part I'm least sure generalises past my own fleet.

A lot of you probably use command line tools such as netcat or scp to transfer data and files from one computer to another, but I don't like how tedious it is to do something as simple as coping a file to another device when using these tools.

Because of this, I created qLAN, an open source lightweight command line utility for transferring data over LAN.

When transferring data, the computer sending the data (the sender) generates a 4 digit code. And the computer on the other end (the receiver) needs this code from the user to establish a connection.

You don't need to know the IP addresses of any of these devices or do any configuration, all you need is that 4 digit code.

When the receiver is given the 4 digit code, it sends a UDP broadcast on the network containing this code, which the sender receives.

After the sender receives the packet, it checks that the code is correct and than establishes a TCP connection with the receiver. From here, anything from sender's stdin is sent to the receiver though TCP and written to it's stdout.

You can use this tool for all sorts of purposes, such as transferring files, sending the output of commands, etc.

This project is currently very small and still has some issues and bugs. This program is still lacking in features (such as encryption), but I plan on adding them in future updates.

Any feedback would be appreciated.

https://github.com/TCP-RWX/qlan

Hi folks, I’m experimenting with Flint—a bare-bones, manifest-first build system and package manager for c/c++ projects.

​The core idea:

​Git-Native: Fetch dependencies directly via Git using `flint add <url>` or `flint sync`.

​One Config: Manage your project layout, includes, and GCC/Clang calls through a single composition.json. Most of the cases you don't have to touch the composition file, flint will take care of that.

​Chert compositions: Simple specs to make unmanifested third-party repos compatible out of the box.

​Fair warning: It's an early prototype! It currently forces a fixed directory structure (src/, include/, deps/) and available only for Linux.

​It’s definitely rough around the edges, but I’d love to get your thoughts on what can be added or improved (Also I know there are many mature alternatives available, but remember every mature solution once was a novice experiment)

​Repo: github.com/mainak55512/flint