Which Linux command or utility is simple, powerful, and surprisingly unknown to many people or used less often?

This could be a command or a piece of software or an application.

For example I’m surprised to find that many people are unaware of Caddy, a very simple web server that can make setting up a reverse proxy incredibly easy.

Another example is fzf. Many people overlook this, a fast command-line fuzzy finder. It’s versatile for searching files, directories, or even shell history with minimal effort.

  • HotChickenFeet@sopuli.xyz
    2·
    4 months ago

    Most listed in some form elsewhere, but

    • Ugrep
    • ranger/lf
    • tmux (splitting terminal and detatching/reattaching when I’m sshing onto server, etc)

    I’ve also been enjoying Kate. It’s a decent text editor, but the ability to Ctrl + / to pipe selected lines through any Linux command (Uniq, shuf, etc) is a bit of a superpower for an editor

  • gandalf_der_12te@discuss.tchncs.de
    2·
    5 months ago

    socat - connect anything to anything

    for example

    socat - tcp-connect:remote-server:12345

    socat tcp-listen:12345 -

    socat tcp-listen:12345 tcp-connect:remote-server:12345

    • HotChickenFeet@sopuli.xyz
      1·
      4 months ago

      Do you have experience with either ranger, lf, or yazi? I’m wondering how broot compares. Big fan of file ranger, and this looks very similar.

    • Jumuta@sh.itjust.works
      1·
      5 months ago

      I heard about helix from you and I’ve used it for a year and a half or so now, it’s by far the best editor I’ve used so far and I can definitely vouch for it

      • deadcream@sopuli.xyz
        0·
        5 months ago

        Fish is a replacement of bash that’s a bit more user friendly (has some cool auto completion features out of the box and more sane behaviour like handling of spaces when expanding variables). I personally started to use nutshell recently but unlike fish it’s very different from bash.

        Starship is a “prompt” for various shells (that bit of text in terminal before you enter the command that shows current user and directory in bash). I haven’t used it but AFAIK it has many features like showing current time, integration with git, etc.

        • Ephera@lemmy.mlEnglish
          0·
          5 months ago

          Yep, here’s my Starship prompt, for example:

          So, I have it configured to show:

          • the exit code of the last command (if it’s non-zero),
          • the duration of the last command (if it’s longer than 2 seconds),
          • the time (when the last command ended),
          • the current directory,
          • the current Git branch, and it also shows some Git status information, for example the $ means I have something stashed,
          • and finally the technology in use in a repository/directory, so in this case that repo uses Rust and the compiler version is 1.83.
            • Ephera@lemmy.mlEnglish
              0·
              5 months ago

              Oh, when you’re coding something in a Git repo and you realize that you need to make a different change before you continue coding (e.g. switch to a branch, pull newest changes, or just create a separate smaller commit for part of your change), then you can run git stash push to put away your current changes, then make your other change, and then run git stash pop to bring your ongoing changes back. I recommend reading git stash --help, if you want to use it.

              Sometimes, though, you might end up just taking it into a different direction altogether or simply forget that you had something stashed. That’s when that indicator comes in handy. Because while you can have multiple things stashed, I do find it’s best not to keep them around for too long. If you do want to keep them for longer, then you can always create a branch and commit it as WIP onto there, so that you can push it onto a remote repo.

            • Ephera@lemmy.mlEnglish
              0·
              5 months ago

              Nope, I’m glad to share.

              I personalized it from the “Gruvbox Rainbow” preset from here: https://starship.rs/presets/
              So, you might prefer that, if you’re not, well, me.

              You will need to set up a NerdFont, like the Starship installation guide says.

              Here’s my configuration:

              Spoiler 
              "$schema" = 'https://starship.rs/config-schema.json'

format = """
[$status](bg:color_red fg:color_fg0)\
[](fg:color_red bg:color_orange)\
[$cmd_duration](bg:color_orange fg:color_fg0)\
[](fg:color_orange bg:color_yellow)\
[$time](bg:color_yellow fg:color_fg0)\
[](fg:color_yellow)\
$line_break\
[$directory](bg:color_aqua fg:color_fg0)\
[](fg:color_aqua bg:color_blue)\
[$git_branch\
$git_status](bg:color_blue fg:color_fg0)\
[](fg:color_blue bg:color_bg3)\
[$c\
$rust\
$golang\
$nodejs\
$php\
$java\
$kotlin\
$haskell\
$python\
$docker_context](bg:color_bg3 fg:color_fg0)\
[](fg:color_bg3)\
$line_break\
$line_break"""

palette = 'gruvbox_dark'

[palettes.gruvbox_dark]
color_fg0 = '#ffffff'
color_bg1 = '#3c3836'
color_bg3 = '#665c54'
color_blue = '#458588'
color_aqua = '#689d6a'
color_green = '#98971a'
color_orange = '#d65d0e'
color_purple = '#b16286'
color_red = '#cc241d'
color_yellow = '#d79921'

[status]
disabled = false
symbol = ""
format = ' $symbol $status '

[username]
format = ' $user '

[directory]
format = " $path "
truncation_length = 3
truncation_symbol = "…/"

[directory.substitutions]
"Documents" = "󰈙 "
"Downloads" = " "
"Music" = "󰝚 "
"Pictures" = " "
"Projects" = "󰲋 "

[git_branch]
symbol = ""
format = ' $symbol $branch '

[git_status]
style = "bg:color_aqua"
format = '$all_status$ahead_behind '

[nodejs]
symbol = ""
format = ' $symbol $version '

[c]
symbol = " "
format = ' $symbol $version '

[rust]
symbol = ""
format = ' $symbol $version '

[golang]
symbol = ""
format = ' $symbol $version '

[php]
symbol = ""
format = ' $symbol $version '

[java]
symbol = " "
format = ' $symbol $version '

[kotlin]
symbol = ""
format = ' $symbol $version '

[haskell]
symbol = ""
format = ' $symbol $version '

[python]
symbol = ""
format = ' $symbol $version '

[cmd_duration]
format = ' 󱦟 $duration '

[time]
disabled = false
time_format = "%R"
format = '  $time '

[line_break]
disabled = false
      • jennraeross@lemmy.world
        0·
        5 months ago

        Helix is a terminal based text editor. It’s much like vim / neovim, but unlike those editors it’s good to go right out of the box, no configuration or plugins needed to make it work well.

        Topgrade is one I haven’t used, but it looks like its intended purpose is to let you upgrade your apps with one command, even if you use multiple different package managers (I.e. if you were on Ubuntu, you could use it to upgrade your apt packages, at the same time as your snap packages, as well as flatpak, nix, and homebrew if you’ve added those.)

      • Dessalines@lemmy.ml
        0·
        5 months ago

        It does have clojure lsp support, but you’ll probably have to use a command line for most repls.

        • SFloss (they/them)@lemmy.ml
          0·
          5 months ago

          Yeah the clojure lsp support is top notch, but there being no support for “jacking in” to a repl is the big thing keeping me from using helix full time. There’s a way of doing it if you use kitty, but it’s pretty janky.

    • Trent@lemmy.mlEnglish
      0·
      5 months ago

      Just commenting to give more love to helix. It’s my favorite “small quick edits” editor.

    • ObsidianZed@lemmy.world
      0·
      5 months ago

      I’ve actually been testing with fish recently coming from zsh, though I might wait until 4.0 fully releases before I make a more conclusive decision to move or not.

      With that said, I remember looking through omf themes and stumbled onto Starship that branched off one of the themes and really liked the concept.

    • deadcream@sopuli.xyz
      0·
      5 months ago

      I use it occasionally but every time I need to do something a tiny bit more complex than “extract field from an object” I have to spend half an hour studying its manual, at which point it’s faster to just write a Python script doing exactly what I need it to do.

        • deadcream@sopuli.xyz
          0·
          5 months ago

          I actually installed it recently out of curiosity, but I’m hesitant about learning its advanced features like that. At least jq is a standalone tool that’s more ubiquitous than nushell, so you can rely on it even in environments that you don’t fully control (e.g. CI like GitHub Actions). And if you use it in some public code/scripts then other people will be more familiar with it too.

  • kyub@discuss.tchncs.deEnglish
    1·
    5 months ago
    • awk
    • the (usually rust-based) coreutils “alternatives” like bat, fd, eza, procs
    • trash-put (rm with trash integration. But beware that it also operates on directories by default, which rm only does with -r. There should be an option to change that behavior but there isn’t. Don’t alias rm to this)
    • wl-copy/paste (or the older one for X11, ‘xclip’ IIRC. Enables you to do stuff like “cat image.jpg | wl-copy” to copy it to the clipboard. Best alias it to something shorter)
    • xdg-open (open the file using your associated program for that file type. Alias to “o” or so)
    • pass (awesome password manager, when you have a GPG key pair. Even better in combination with e.g. wofi)
    • notify-send (to send GUI notifications from shell scripts)
    • ledger (plain-text accounting software. If you use Emacs you should take a look at this as it’s written by an Emacs dev, and has good integration of course)
    • nc
    • nohup
  • harsh3466@lemmy.ml
    1·
    5 months ago

    zoxide. It’s a fabulous cd replacement. It builds a database as you navigate your filesystem. Once you’ve navigated to a directory, instead of having to type cd /super/long/directory/path, you can type zoxide path and it’ll take you right to /super/long/directory/path.

    I have it aliased to zd. I love it and install it on every system

    You can do things like using a partial directory name and it’ll jump you to the closest match in the database. So zoxide pa would take you to /super/long/directory/path.

    And you can do partial paths. Say you’ve got two directories named data in your filesystem.

    One at /super/long/directory/path1/data

    And the other at /super/long/directory/path2/data

    You can do zoxide path2 data and you’ll go to /super/long/directory/path2/data

  • gandalf_der_12te@discuss.tchncs.de
    1·
    5 months ago

    losetup

    it’s useful for dealing with virtual disk images. like a real physical hard disk, but it’s a file on the computer. you can mount it, format it, and write it to a real physical disk.

    it’s sometimes used with virtual machines, with iso images, or when preparing a bootable disk.

  • GenderNeutralBro@lemmy.sdf.orgEnglish
    1·
    5 months ago

    vd (VisiData) is a wonderful TUI spreadsheet program. It can read lots of formats, like csv, sqlite, and even nested formats like json. It supports Python expressions and replayable commands.

    I find it most useful for large CSV files from various sources. Logs and reports from a lot of the tools I use can easily be tens of thousands of rows, and it can take many minutes just to open them in GUI apps like Excel or LibreOffice.

    I frequently need to re-export fresh data, so I find myself needing to re-process and re-arrange it every time, which visidata makes easy (well, easier) with its replayable command files. So e.g. I can write a script to open a raw csv, add a formula column, resize all columns to fit their content, set the column types as appropriate, and sort it the way I need it. So I can do direct from exporting the data to reading it with no preprocessing in between.

  • toastal@lemmy.ml
    1·
    5 months ago

    netstat -tunl shows all open ports on the machine to help diagnose any firewall issues.

    • friend_of_satan@lemmy.worldEnglish
      0·
      5 months ago

      I love jq, but I wouldn’t call it “surprising simple” for anything but pretty-formatting json. It has a fairly steep learning curve for doing anything with all but the simplest operations on the simplest data structures.