Used to be written in Python, but is now 100% Rust.

It was designed to help remind *nix system administrators of options for commands that they use frequently, but not frequently enough to remember.

Let’s imagine a completely hypothetical world where it’s the umpteenth time you’ve used it, but you still can’t remember which flags to send to tar… so you run:

cheat tar

You’ll be greeted by:

# To extract an uncompressed archive:
tar -xvf '/path/to/foo.tar'

# To extract a .gz archive:
tar -xzvf '/path/to/foo.tgz'

# To create a .gz archive:
tar -czvf '/path/to/foo.tgz' '/path/to/foo/'

# To extract a .bz2 archive:
tar -xjvf '/path/to/foo.tgz'

# To create a .bz2 archive:
tar -cjvf '/path/to/foo.tgz' '/path/to/foo/'

The cheatsheets themselves are community-sourced.

dog is a command-line DNS client, like dig.
It has colourful output, understands normal command-line argument syntax, supports the DNS-over-TLS and DNS-over-HTTPS protocols, and can emit JSON.

The only downside is that (for now) you have to build it from source if you want to use it.

In this episode we discuss Mislav’s experience building not one, but two Github CLIs - hub and gh. We dive into questions like, “What lead to the decision to completely rewrite the CLI in Go?”, “How were you testing the CLI, especially during the transition?”, and “What Go libraries are you using to build your CLI?”

ffmpeg is an incredibly powerful tool, but its many flags and options make it not the easiest thing to wield (especially if you use it just infrequently enough to forget the magic syntax you ginned up last time).

vdx makes ffmpeg more approachable for many of the common video processing operations you may need on a regular basis. Examples!

$ vdx '*.mov' --crop=360,640    # Crop to width 360, height 640
$ vdx '*.mov' --format=gif      # Convert to GIF
$ vdx '*.mov' --fps=12          # Change the frame rate to 12
$ vdx '*.mov' --no-audio        # Strip audio
$ vdx '*.mov' --resize=360,-1   # Resize to width 360, maintaining aspect ratio
$ vdx '*.mov' --reverse         # Reverse
$ vdx '*.mov' --rotate=90       # Rotate 90 degrees clockwise
$ vdx '*.mov' --speed=2         # Double the speed
$ vdx '*.mov' --trim=0:05,0:10  # Trim from time 0:05 to 0:10
$ vdx '*.mov' --volume=0.5      # Halve the volume

Command line tool to extract the main content from a webpage, as done by the “Reader View” feature of most modern browsers. It’s intended to be used with terminal RSS readers, to make the articles more readable on web browsers such as lynx. The code is closely adapted from the Firefox version and the output is expected to be mostly equivalent.

I could see this fitting in nicely in a pipeline between curl and, well, lots of other commands.

Plaintext storage, git-backed, Markdown formatting, and all in a single script. 👌

Ruby is my favorite tool for slightly-longer-than-one-liners, but I don’t often reach for it directly from the command line. This little cookbook might change my mind on that:

A shell utility like bash provides built-in commands and scripting features to make it easier to solve and automate various tasks. External *nix commands like grep, sed, awk, sort, find, parallel etc can be combined to work with each other. Depending upon your familiarity with those tools, you can either use ruby as a single replacement or complement them for specific use cases.

If you haven’t given the new gh a look since they announced the beta earlier this year, a lot has changed:

Since we released the beta, users have created over 250,000 pull requests, performed over 350,000 merges, and created over 20,000 issues with GitHub CLI.

It’s available for all major operating systems and if your development workflow goes through GitHub you will undoubtedly save some time and typing by adopting it.

We’ve linked K9s up in the past, but I’ve been playing with it today and I just had to share it again. Gerhard has us up and running on LKE (more on that coming to the blog and podcast soon) so I’ve had a chance to kick the tires a bit.

I have no idea how any of this magic works, but I do know that I like it and I’m excited to learn more. Here’s a screen grab of its Pulses feature, which gives you an overview of your entire cluster.

gix is a command-line interface (CLI) to access git repositories. It’s written to optimize the
user-experience, and perform as good or better than the canonical implementation.

Furthermore it provides an easy and safe to use API in the form of various small crates for implementing your own tools in a breeze.

The author describes this as “idiomatic, modern, lean, fast, safe, & pure” but that was too many superlatives to put in the headline. It does look nice, though. I dig the libraries + CLI that leverages them approach. Demo video on Asciinema.

Built in Go, askgit is an open source CLI and coming soon web interface (linked above). With this tool in your toolbox, you can mine your repo for info like commit count by author on each day of the week:

SELECT
    count(*) AS commits,
    count(CASE WHEN strftime('%w',author_when)='0' THEN 1 END) AS sunday,
    count(CASE WHEN strftime('%w',author_when)='1' THEN 1 END) AS monday,
    count(CASE WHEN strftime('%w',author_when)='2' THEN 1 END) AS tuesday,
    count(CASE WHEN strftime('%w',author_when)='3' THEN 1 END) AS wednesday,
    count(CASE WHEN strftime('%w',author_when)='4' THEN 1 END) AS thursday,
    count(CASE WHEN strftime('%w',author_when)='5' THEN 1 END) AS friday,
    count(CASE WHEN strftime('%w',author_when)='6' THEN 1 END) AS saturday,
    author_email
FROM commits GROUP BY author_email ORDER BY commits

Kayla Cinnamon, Program Manager at Microsoft for Windows Terminal, Console, Command Line, and Cascadia Code joined us to talk about the release of Windows Terminal 1.0 and the new Windows command-line experience. We talk about everything that went into rethinking the command line experience on Windows, the UX and UI design behind it all, the learnings of working in open source, and what’s to come for the Windows command line experience.

🎶 Universal binaries because written in Go. A command-line interface to your favorite show. Install it with curl simply pass the right strings. These are a few of my favorite things 🎶

dijo is a habit tracker. It is curses-based, it runs in your terminal. dijo is scriptable, hook it up with external programs to track events without moving a finger. dijo is modal, much like a certain text editor.

Poodle’s features include:

• Register your web services and endpoints easily.
• Use variables in endpoints definitions.
• Painless debugging and interaction with APIs.
• Search web services and endpoints interactively.
• Edit services and endpoints easily (config is just a TOML file).
• Sync services via Gist automatically.

Turns out everyone’s favorite macOS package manager has an official cask for managing fonts. Who knew?!

I would like to show some examples of this philosophy in action – of how one can use different unix tools together to accomplish something powerful.

This post takes you step-by-step through printing a leaderboard of authors based on number of commits to a git repo, browsing memes on reddit, setting your desktop wallpaper, and getting a random movie from an IMDB list.

This makes heavy use of fzf, which is a command-line fuzzy finder. You can stage and unstage files fuzzily found by the tool and commit interactively.

You have wrapped your head around the Go syntax and practised them one by one, however you won’t feel comfortable writing applications in Go unless you build one.

In this blog post we’ll build a CLI application in Go, which we’ll call go-grab-xkcd. This application fetches comics from XKCD and provides you with various options through command-line arguments.

The name derives from the Standup meetings since its initial purpose was to cover my need for keeping my Standup notes in a convenient way.

Quickly enter notes with a flexible text interface. Note creation looks like:

stup add @|--at|-@ <when> -n|--note "<note text>" -c|--category "<category-name>"

Then you can pull them back out by date, date-range, and/or category with:

$ stup show @ <when> -c|--category "<category-name>"

Notes are all saved as plaintext (markdown) so throw the entire directory in your synced-cloud-folder solution of choice and you have instant notes sync across all your devices.

Suitcase is a command line tool that can be “programmed” to display a SwiftUI interface that can trigger commands and scripts.

Editly is a tool and framework for declarative NLE (non-linear video editing) using Node.js and ffmpeg. Editly allows you to easily and programmatically create a video from set of clips, images and titles, with smooth transitions between and music overlaid.

The video in the gif below was produced by sending Editly this JSON config.

These libraries come from the team at repl.it and you can play with them in your browser on repl.it.

A nifty tool (Ruby gem) from the folks at Instacart. Designed for:

• speed - up to 4x faster than traditional tools on a 4-core machine
• security - built-in methods to prevent sensitive data from ever leaving the server
• convenience - sync partial tables, groups of tables, and related records