Update docker!

.gitignore

@@ -1,5 +1,7 @@
 zsh/extraconfig.zsh
 zsh/env.zsh
 bash/extraconfig.bash
+nushell/history.*
+nushell/config/extra.nu
 .data
 bin-extra

bin/video2gif

@@ -12,10 +12,10 @@ fi
 
 palette_dir=$(mktemp -d)
 
-ffmpeg -y -ss $2 -t $3 -i $1 \
+ffmpeg -y -ss $2 -to $3 -i $1 \
     -vf fps=30,scale=320:-1:flags=lanczos,palettegen $palette_dir/palette.png > /dev/null 2>&1
 
-ffmpeg -ss $2 -t $3 -i $1 -i $palette_dir/palette.png -filter_complex \
+ffmpeg -ss $2 -to $3 -i $1 -i $palette_dir/palette.png -filter_complex \
-    "fps=30,scale=320:-1:flags=lanczos[x];[x][1:v]paletteuse" -y output.gif > /dev/null 2>&1
+    "fps=30,scale=640:-1:flags=lanczos[x];[x][1:v]paletteuse" -y output.gif > /dev/null 2>&1
 
 rm -rf $palette_dir

nushell/config.nu

@@ -0,0 +1,14 @@
+source ~/.config/nushell/config/init.nu
+source ~/.config/nushell/config/extra.nu
+source ~/.config/nushell/config/mount.nu
+source ~/.config/nushell/config/config.nu
+source ~/.config/nushell/config/aliases.nu
+source ~/.config/nushell/config/git.nu
+source ~/.config/nushell/config/ssh.nu
+source ~/.config/nushell/config/update.nu
+source ~/.config/nushell/config/gclone.nu
+source ~/.config/nushell/config/pass.nu
+source ~/.config/nushell/config/docker.nu
+source ~/.config/nushell/config/xrandr.nu
+source ~/.config/nushell/config/tfetch.nu
+

nushell/config/aliases.nu

@@ -0,0 +1,137 @@
+# replace /home/$USER by ~
+def tildize [] {
+    if ($in | path split | zip ($env.HOME | path split) | all { $in.0 == $in.1 }) {
+        ($in | str replace $env.HOME "~")
+    } else {
+        $in
+    }
+}
+
+# remove extension shortcut
+def rm-ext [] {
+    $in | path parse | udpate extension "" | get parent stem | str join "/"
+}
+
+# ls builtin
+alias _ls = ls
+
+# shortcut for ls builtin
+alias l = _ls
+
+def _ls_format_mode [mode: string] {
+    let chars = $mode | split chars
+    let r1 = if ($chars | get 0) == "r" { [(ansi yellow_bold), "r", (ansi reset)] } else { [(ansi grey), "-"] }
+    let w1 = if ($chars | get 1) == "w" { [(ansi red_bold), "w", (ansi reset)] } else { [(ansi grey), "-"] }
+    let x1 = if ($chars | get 2) == "x" { [(ansi green_bold), "x", (ansi reset)] } else { [(ansi grey), "-"] }
+    let r2 = if ($chars | get 3) == "r" { [(ansi yellow), "r", (ansi reset)] } else { [(ansi grey), "-"] }
+    let w2 = if ($chars | get 4) == "w" { [(ansi red), "w"] } else { [(ansi grey), "-"] }
+    let x2 = if ($chars | get 5) == "x" { [(ansi green), "x"] } else { [(ansi grey), "-"] }
+    let r3 = if ($chars | get 6) == "r" { [(ansi yellow), "r", (ansi reset)] } else { [(ansi grey), "-"] }
+    let w3 = if ($chars | get 7) == "w" { [(ansi red), "w"] } else { [(ansi grey), "-"] }
+    let x3 = if ($chars | get 8) == "x" { [(ansi green), "x"] } else { [(ansi grey), "-"] }
+    [$r1, $w1, $x1, $r2, $w2, $x2, $r3, $w3, $x3] | each { $in | str join } | str join
+}
+
+# quick and easy ls
+def ls [dir?: string] {
+    let output = _ls (if $dir == null { "" } else { $dir }) | sort-by type name -i
+    if ($output | length) == 0 { "" | cat } else { $output | grid -c -s "  " | cat }
+}
+
+# ls with hidden files
+def la [dir?: string] {
+    _ls -al (if $dir == null { "" } else { $dir })
+        | sort-by type name -i
+        | each { $in | update mode (_ls_format_mode $in.mode) }
+        | select mode name target user size modified
+}
+
+# ls with details
+def ll [dir?: string] {
+    _ls -l (if $dir == null { "" } else { $dir })
+        | each { $in | update mode (_ls_format_mode $in.mode) }
+        | sort-by type name -i
+        | select mode name target user size modified
+}
+
+# du builtin
+alias _du = du
+
+# non recursive du
+def du [...args] {
+    let parsed_args = if ($args | is-empty) { ["*"] } else { $args }
+    $parsed_args | each { _du -a $in | select path apparent physical } | flatten
+}
+
+# df
+def df [] {
+    ^df -h
+        | str replace "Sys. de fichiers" "@"
+        | str replace "Monté sur" "@"
+        | detect columns
+        | rename "filesystem" "size" "used" "available" "used%" "mountpoint"
+}
+
+# easy markdown formamtter
+def to-md [] {
+    let arg = $in
+    $env.config.table.mode = markdown;
+    echo $arg
+}
+
+# Useful aliases
+
+# colored ip
+alias ip = ip -c
+
+# neovim
+alias v = nvim
+
+# quit
+alias :q = exit
+
+# evince in background
+def pdf [arg: string] {
+    pueue add evince ($arg | str replace ' ' '\ ')
+}
+
+# ripgrep
+alias rg = rg -uu
+
+# mkdir && cd
+def --env mkcd [dir: string] { mkdir $dir; cd $dir }
+
+# run command in background
+alias pa = pueue add --immediate
+
+# show background commands
+def pst [] {
+    pueue status -j
+        | from json
+        | get tasks
+        | transpose
+        | each { $in | get column1 }
+        | each {
+            let stdin = $in
+
+            $stdin | update status (
+                if $stdin.status == "Running" {
+                    ((ansi yellow) + "Running")
+                } else if not (echo $stdin.status | get -i Done | is-empty) {
+                    let exit_value = $stdin.status | get "Done"
+
+                    if ($exit_value == "Success") {
+                        ((ansi green) + "Success")
+                    } else {
+                        (ansi red) + "Failed (" + ($exit_value | get "Failed" | into string) + ")"
+                    }
+                } else {
+                    "Unknown???"
+                }
+              )
+            | update path ($in.path | tildize)
+            | update start ((ansi magenta) + ($in.start | date humanize))
+            | update end ((ansi magenta) + ($in.end | date humanize))
+        }
+        | select status command path start end
+}

nushell/config/config.nu

@@ -0,0 +1,16 @@
+# Change default config
+$env.config.keybindings = (echo $env.config.keybindings | append {
+    name: newline_or_run_command_2
+    modifier: CONTROL
+    keycode: char_j
+    mode: emacs
+    event: {send: enter}
+})
+
+$env.config.show_banner = false
+$env.config.use_grid_icons = false
+$env.config.cursor_shape.emacs = block
+$env.config.history.max_size = 1_000_000_000_000_000
+$env.config.history.file_format = "sqlite"
+$env.config.history.isolation = true
+$env.config.filesize.metric = false

nushell/config/docker.nu

@@ -0,0 +1,81 @@
+# docker aliases
+
+# lazydocker
+alias ld = lazydocker
+
+# docker-compose
+alias dc = docker-compose
+
+# docker-compose build
+alias dcb = docker-compose build
+
+# docker-compose build and push
+def dcp [] { docker-compose build; docker-compose push }
+
+# docker-compose up with build and remove-orphans
+alias dcu = docker-compose up -d --build --remove-orphans
+
+# docker-compose down
+alias dcd = docker-compose down
+
+# docker-compose down and up
+def dcr [] { docker-compose down; docker-compose up -d --build --remove-orphans }
+
+# kubernetes aliases
+$env.KUBECONFIG = if ([$env.HOME, .kubes, current-cube] | path join | path exists) {
+    open ([$env.HOME, .kubes, current-cube] | path join)
+} else {
+    ""
+}
+
+def _kube_kubes [] {
+    _ls ~/.kubes | where type == dir | get name | path basename
+}
+
+# easily switch kube config
+def --env kube [name?: string@_kube_kubes] {
+    use assert
+
+    let kubes_path = [$env.HOME, .kubes] | path join
+
+    if $name == null {
+        rm ([$kubes_path, current-cube] | path join)
+        $env.KUBECONFIG = ""
+        return
+    }
+
+    let kube_config =  [$kubes_path, $name, config] | path join
+
+    if not ($kube_config | path exists) {
+        error make {msg: ($kube_config + " does not exist")}
+    }
+
+    $kube_config | save -f ([$kubes_path, current-cube] | path join)
+    $env.KUBECONFIG = $kube_config
+}
+
+# k9s
+alias kns = k9s -n all
+
+# lazydocker / k9s shortcut for each compose / cluster
+alias mnemosyne = ssh phoenix -t "cd infra && /home/polymny/.local/bin/lazydocker"
+alias zeus = k9s -n all --kubeconfig ($env.HOME + '/.kubes/zeus/config')
+alias safir = k9s -n all --kubeconfig ($env.HOME + '/.kubes/safir/config')
+
+# start minikube with test kube
+def "minikube start" [] {
+    $env.KUBECONFIG = ([$env.HOME, '.kubes', 'test', 'config'] | path join)
+    ^minikube start
+}
+
+# stop minikube with test kube
+def "minikube stop" [] {
+    $env.KUBECONFIG = ([$env.HOME, '.kubes', 'test', 'config'] | path join)
+    ^minikube stop
+}
+
+# delete minikube with test kube
+def "minikube delete" [] {
+    $env.KUBECONFIG = ([$env.HOME, '.kubes', 'test', 'config'] | path join)
+    ^minikube delete
+}

nushell/config/gclone.nu

@@ -0,0 +1,141 @@
+# gclone aliases
+
+def _gclone_dirs [] {
+    _ls ($env.GCLONE_PATH + "/*")
+        | append (_ls ($env.GCLONE_PATH + "/*/*"))
+        | append (_ls ($env.GCLONE_PATH + "/*/*/*"))
+        | each { $in.name | path basename }
+        | sort
+        | uniq
+}
+
+# cd to a git directory
+def --env cdg [key: string@_gclone_dirs] {
+    let dir = _ls ($env.GCLONE_PATH + "/*")
+        | append (_ls ($env.GCLONE_PATH + "/*/*"))
+        | append (_ls ($env.GCLONE_PATH + "/*/*/*"))
+        | where { $in != null and ($in.name | path basename) == $key }
+
+
+    match ($dir | length) {
+        0 => {
+            print (
+                (ansi red_bold) + "error" +
+                (ansi reset) + (ansi attr_bold) + ":" +
+                (ansi reset) + " no such file or directory"
+            )
+            return
+        }
+
+        1 => {
+            cd $dir.0.name
+        }
+
+        _ => {
+            print (
+                (ansi attr_bold) + "info:" +
+                (ansi reset) + " multiple entries found, please select one"
+            )
+
+            echo $dir
+
+            print (
+                (ansi --escape 'A') +
+                (ansi attr_bold) + "Enter your choice: " + (ansi reset)
+            )
+
+            let choice = input
+
+            if not ($choice =~ "^[0-9]*$") {
+                print (
+                    (ansi red_bold) + "error" +
+                    (ansi reset) + (ansi attr_bold) + ":" +
+                    (ansi reset) + " couldn't parse integer"
+                )
+                return
+            }
+
+            let choice = $choice | into int
+
+            if $choice >= ($dir | length) {
+                print (
+                    (ansi red_bold) + "error" +
+                    (ansi reset) + (ansi attr_bold) + ":" +
+                    (ansi reset) + " integer is outside range"
+                )
+                return
+            }
+
+            cd ($dir | get $choice | get name)
+        }
+    }
+}
+
+# clone repository in the right place
+def gclone [repo_url: string] {
+
+    let attr = if ($repo_url | str starts-with "https://") {
+        $repo_url | parse "https://{server}/{owner}/{repo}" | get 0
+    } else if ($repo_url | str starts-with "http://") {
+        $repo_url | parse "http://{server}/{owner}/{repo}" | get 0
+    } else if ($repo_url | str starts-with "ssh://") {
+        $repo_url | parse "ssh://git@{server}/{owner}/{repo}" | get 0
+    } else if ($repo_url | str starts-with "git@") {
+        $repo_url | parse "git@{server}:{owner}/{repo}" | get 0
+    } else {
+        print (
+            (ansi red_bold) + "error" +
+            (ansi reset) + (ansi attr_bold) + ":" +
+            (ansi reset) + " failed to parse repo url"
+        )
+        return
+    }
+
+    let server = $attr.server
+    let server_portless = $attr.server | split row ':' | get 0
+    let owner = $attr.owner
+    let repo = $attr.repo
+
+    let target = [$env.GCLONE_PATH, $server_portless, $owner, $repo] | path join
+    let target = if ($target | str ends-with '.git') {
+        $target | path parse | update extension "" | get parent stem | str join "/"
+    } else {
+        $target
+    }
+
+    if ($target | path exists) {
+        print (
+            (ansi red_bold) + "error" +
+            (ansi reset) + (ansi attr_bold) + ":" +
+            (ansi reset) + " clone target already exists"
+        )
+        return
+    }
+
+    let clone_url = if $env.GCLONE_FORCE_SSH {
+        $attr | format "ssh://git@{server}/{owner}/{repo}"
+    } else {
+        $repo_url
+    }
+
+    print -n (
+        (ansi attr_bold) + "info:" +
+        (ansi reset) + " cloning " + $clone_url + "..."
+    )
+
+    let clone = do { git clone --recurse-submodules $clone_url $target } | complete
+
+    if $clone.exit_code == 0 {
+        print " done!"
+    } else {
+        print (
+            "\n" + (ansi red_bold) + "error" +
+            (ansi reset) + (ansi attr_bold) + ":" +
+            (ansi reset) + " clone failed:"
+        )
+
+        print -n $clone.stderr
+    }
+
+}
+

nushell/config/git.nu

@@ -0,0 +1,46 @@
+# git aliases
+
+# git
+alias g = git
+
+# git add
+alias ga = git add
+
+# git add --all
+alias gaa = git add --all
+
+# git checkout
+alias gco = git checkout
+
+# git checkout -b
+alias gcb = git checkout -b
+
+# git commit
+alias gc = git commit --verbose
+
+# git commit --all
+alias gca = git commit --verbose --all
+
+# git diff
+alias gd = git diff
+
+# git log
+alias glog = git log --oneline --decorate --graph
+
+# git pull
+alias gl = git pull
+
+# git push
+alias gp = git push
+
+# git status
+alias gst = git status
+
+# git status
+alias gs = git status
+
+# git merge
+alias gm = git merge
+
+# git push --set-upstream ...
+def gpsup [] { git push --set-upstream origin (git rev-parse --abbrev-ref HEAD) }

nushell/config/init.nu

@@ -0,0 +1,757 @@
+# Nushell Config File
+#
+# version = "0.86.0"
+
+# For more information on defining custom themes, see
+# https://www.nushell.sh/book/coloring_and_theming.html
+# And here is the theme collection
+# https://github.com/nushell/nu_scripts/tree/main/themes
+let dark_theme = {
+    # color for nushell primitives
+    separator: white
+    leading_trailing_space_bg: { attr: n } # no fg, no bg, attr none effectively turns this off
+    header: green_bold
+    empty: blue
+    # Closures can be used to choose colors for specific values.
+    # The value (in this case, a bool) is piped into the closure.
+    # eg) {|| if $in { 'light_cyan' } else { 'light_gray' } }
+    bool: light_cyan
+    int: white
+    filesize: cyan
+    duration: white
+    date: purple
+    range: white
+    float: white
+    string: white
+    nothing: white
+    binary: white
+    cell-path: white
+    row_index: green_bold
+    record: white
+    list: white
+    block: white
+    hints: dark_gray
+    search_result: {bg: red fg: white}
+    shape_and: purple_bold
+    shape_binary: purple_bold
+    shape_block: blue_bold
+    shape_bool: light_cyan
+    shape_closure: green_bold
+    shape_custom: green
+    shape_datetime: cyan_bold
+    shape_directory: cyan
+    shape_external: cyan
+    shape_externalarg: green_bold
+    shape_filepath: cyan
+    shape_flag: blue_bold
+    shape_float: purple_bold
+    # shapes are used to change the cli syntax highlighting
+    shape_garbage: { fg: white bg: red attr: b}
+    shape_globpattern: cyan_bold
+    shape_int: purple_bold
+    shape_internalcall: cyan_bold
+    shape_list: cyan_bold
+    shape_literal: blue
+    shape_match_pattern: green
+    shape_matching_brackets: { attr: u }
+    shape_nothing: light_cyan
+    shape_operator: yellow
+    shape_or: purple_bold
+    shape_pipe: purple_bold
+    shape_range: yellow_bold
+    shape_record: cyan_bold
+    shape_redirection: purple_bold
+    shape_signature: green_bold
+    shape_string: green
+    shape_string_interpolation: cyan_bold
+    shape_table: blue_bold
+    shape_variable: purple
+    shape_vardecl: purple
+}
+
+let light_theme = {
+    # color for nushell primitives
+    separator: dark_gray
+    leading_trailing_space_bg: { attr: n } # no fg, no bg, attr none effectively turns this off
+    header: green_bold
+    empty: blue
+    # Closures can be used to choose colors for specific values.
+    # The value (in this case, a bool) is piped into the closure.
+    # eg) {|| if $in { 'dark_cyan' } else { 'dark_gray' } }
+    bool: dark_cyan
+    int: dark_gray
+    filesize: cyan_bold
+    duration: dark_gray
+    date: purple
+    range: dark_gray
+    float: dark_gray
+    string: dark_gray
+    nothing: dark_gray
+    binary: dark_gray
+    cell-path: dark_gray
+    row_index: green_bold
+    record: white
+    list: white
+    block: white
+    hints: dark_gray
+    search_result: {fg: white bg: red}
+    shape_and: purple_bold
+    shape_binary: purple_bold
+    shape_block: blue_bold
+    shape_bool: light_cyan
+    shape_closure: green_bold
+    shape_custom: green
+    shape_datetime: cyan_bold
+    shape_directory: cyan
+    shape_external: cyan
+    shape_externalarg: green_bold
+    shape_filepath: cyan
+    shape_flag: blue_bold
+    shape_float: purple_bold
+    # shapes are used to change the cli syntax highlighting
+    shape_garbage: { fg: white bg: red attr: b}
+    shape_globpattern: cyan_bold
+    shape_int: purple_bold
+    shape_internalcall: cyan_bold
+    shape_list: cyan_bold
+    shape_literal: blue
+    shape_match_pattern: green
+    shape_matching_brackets: { attr: u }
+    shape_nothing: light_cyan
+    shape_operator: yellow
+    shape_or: purple_bold
+    shape_pipe: purple_bold
+    shape_range: yellow_bold
+    shape_record: cyan_bold
+    shape_redirection: purple_bold
+    shape_signature: green_bold
+    shape_string: green
+    shape_string_interpolation: cyan_bold
+    shape_table: blue_bold
+    shape_variable: purple
+    shape_vardecl: purple
+}
+
+# External completer example
+# let carapace_completer = {|spans|
+#     carapace $spans.0 nushell $spans | from json
+# }
+
+# The default config record. This is where much of your global configuration is setup.
+$env.config = {
+    show_banner: true # true or false to enable or disable the welcome banner at startup
+
+    ls: {
+        use_ls_colors: true # use the LS_COLORS environment variable to colorize output
+        clickable_links: true # enable or disable clickable links. Your terminal has to support links.
+    }
+
+    rm: {
+        always_trash: false # always act as if -t was given. Can be overridden with -p
+    }
+
+    table: {
+        mode: rounded # basic, compact, compact_double, light, thin, with_love, rounded, reinforced, heavy, none, other
+        index_mode: always # "always" show indexes, "never" show indexes, "auto" = show indexes when a table has "index" column
+        show_empty: true # show 'empty list' and 'empty record' placeholders for command output
+        padding: { left: 1, right: 1 } # a left right padding of each column in a table
+        trim: {
+            methodology: wrapping # wrapping or truncating
+            wrapping_try_keep_words: true # A strategy used by the 'wrapping' methodology
+            truncating_suffix: "..." # A suffix used by the 'truncating' methodology
+        }
+        header_on_separator: false # show header text on separator/border line
+        # abbreviated_row_count: 10 # limit data rows from top and bottom after reaching a set point
+    }
+
+    error_style: "fancy" # "fancy" or "plain" for screen reader-friendly error messages
+
+    # datetime_format determines what a datetime rendered in the shell would look like.
+    # Behavior without this configuration point will be to "humanize" the datetime display,
+    # showing something like "a day ago."
+    datetime_format: {
+        # normal: '%a, %d %b %Y %H:%M:%S %z'    # shows up in displays of variables or other datetime's outside of tables
+        # table: '%m/%d/%y %I:%M:%S%p'          # generally shows up in tabular outputs such as ls. commenting this out will change it to the default human readable datetime format
+    }
+
+    explore: {
+        status_bar_background: {fg: "#1D1F21", bg: "#C4C9C6"},
+        command_bar_text: {fg: "#C4C9C6"},
+        highlight: {fg: "black", bg: "yellow"},
+        status: {
+            error: {fg: "white", bg: "red"},
+            warn: {}
+            info: {}
+        },
+        table: {
+            split_line: {fg: "#404040"},
+            selected_cell: {bg: light_blue},
+            selected_row: {},
+            selected_column: {},
+        },
+    }
+
+    history: {
+        max_size: 100_000 # Session has to be reloaded for this to take effect
+        sync_on_enter: true # Enable to share history between multiple sessions, else you have to close the session to write history to file
+        file_format: "plaintext" # "sqlite" or "plaintext"
+        isolation: false # only available with sqlite file_format. true enables history isolation, false disables it. true will allow the history to be isolated to the current session using up/down arrows. false will allow the history to be shared across all sessions.
+    }
+
+    completions: {
+        case_sensitive: false # set to true to enable case-sensitive completions
+        quick: true    # set this to false to prevent auto-selecting completions when only one remains
+        partial: true    # set this to false to prevent partial filling of the prompt
+        algorithm: "prefix"    # prefix or fuzzy
+        external: {
+            enable: true # set to false to prevent nushell looking into $env.PATH to find more suggestions, `false` recommended for WSL users as this look up may be very slow
+            max_results: 100 # setting it lower can improve completion performance at the cost of omitting some options
+            completer: null # check 'carapace_completer' above as an example
+        }
+    }
+
+    filesize: {
+        metric: true # true => KB, MB, GB (ISO standard), false => KiB, MiB, GiB (Windows standard)
+        format: "auto" # b, kb, kib, mb, mib, gb, gib, tb, tib, pb, pib, eb, eib, auto
+    }
+
+    cursor_shape: {
+        emacs: line # block, underscore, line, blink_block, blink_underscore, blink_line, inherit to skip setting cursor shape (line is the default)
+        vi_insert: block # block, underscore, line, blink_block, blink_underscore, blink_line, inherit to skip setting cursor shape (block is the default)
+        vi_normal: underscore # block, underscore, line, blink_block, blink_underscore, blink_line, inherit to skip setting cursor shape (underscore is the default)
+    }
+
+    color_config: $dark_theme # if you want a more interesting theme, you can replace the empty record with `$dark_theme`, `$light_theme` or another custom record
+    use_grid_icons: true
+    footer_mode: "25" # always, never, number_of_rows, auto
+    float_precision: 2 # the precision for displaying floats in tables
+    buffer_editor: "" # command that will be used to edit the current line buffer with ctrl+o, if unset fallback to $env.EDITOR and $env.VISUAL
+    use_ansi_coloring: true
+    bracketed_paste: true # enable bracketed paste, currently useless on windows
+    edit_mode: emacs # emacs, vi
+    shell_integration: false # enables terminal shell integration. Off by default, as some terminals have issues with this.
+    render_right_prompt_on_last_line: false # true or false to enable or disable right prompt to be rendered on last line of the prompt.
+    use_kitty_protocol: false # enables keyboard enhancement protocol implemented by kitty console, only if your terminal support this
+
+    hooks: {
+        pre_prompt: [{ null }] # run before the prompt is shown
+        pre_execution: [{ null }] # run before the repl input is run
+        env_change: {
+            PWD: [{|before, after| null }] # run if the PWD environment is different since the last repl input
+        }
+        display_output: "if (term size).columns >= 100 { table -e } else { table }" # run to display the output of a pipeline
+        command_not_found: { null } # return an error message when a command is not found
+    }
+
+    menus: [
+        # Configuration for default nushell menus
+        # Note the lack of source parameter
+        {
+            name: completion_menu
+            only_buffer_difference: false
+            marker: "| "
+            type: {
+                layout: columnar
+                columns: 4
+                col_width: 20     # Optional value. If missing all the screen width is used to calculate column width
+                col_padding: 2
+            }
+            style: {
+                text: green
+                selected_text: green_reverse
+                description_text: yellow
+            }
+        }
+        {
+            name: history_menu
+            only_buffer_difference: true
+            marker: "? "
+            type: {
+                layout: list
+                page_size: 10
+            }
+            style: {
+                text: green
+                selected_text: green_reverse
+                description_text: yellow
+            }
+        }
+        {
+            name: help_menu
+            only_buffer_difference: true
+            marker: "? "
+            type: {
+                layout: description
+                columns: 4
+                col_width: 20     # Optional value. If missing all the screen width is used to calculate column width
+                col_padding: 2
+                selection_rows: 4
+                description_rows: 10
+            }
+            style: {
+                text: green
+                selected_text: green_reverse
+                description_text: yellow
+            }
+        }
+    ]
+
+    keybindings: [
+        {
+            name: completion_menu
+            modifier: none
+            keycode: tab
+            mode: [emacs vi_normal vi_insert]
+            event: {
+                until: [
+                    { send: menu name: completion_menu }
+                    { send: menunext }
+                    { edit: complete }
+                ]
+            }
+        }
+        {
+            name: history_menu
+            modifier: control
+            keycode: char_r
+            mode: [emacs, vi_insert, vi_normal]
+            event: { send: menu name: history_menu }
+        }
+        {
+            name: help_menu
+            modifier: none
+            keycode: f1
+            mode: [emacs, vi_insert, vi_normal]
+            event: { send: menu name: help_menu }
+        }
+        {
+            name: completion_previous_menu
+            modifier: shift
+            keycode: backtab
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: menuprevious }
+        }
+        {
+            name: next_page_menu
+            modifier: control
+            keycode: char_x
+            mode: emacs
+            event: { send: menupagenext }
+        }
+        {
+            name: undo_or_previous_page_menu
+            modifier: control
+            keycode: char_z
+            mode: emacs
+            event: {
+                until: [
+                    { send: menupageprevious }
+                    { edit: undo }
+                ]
+            }
+        }
+        {
+            name: escape
+            modifier: none
+            keycode: escape
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: esc }    # NOTE: does not appear to work
+        }
+        {
+            name: cancel_command
+            modifier: control
+            keycode: char_c
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: ctrlc }
+        }
+        {
+            name: quit_shell
+            modifier: control
+            keycode: char_d
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: ctrld }
+        }
+        {
+            name: clear_screen
+            modifier: control
+            keycode: char_l
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: clearscreen }
+        }
+        {
+            name: search_history
+            modifier: control
+            keycode: char_q
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: searchhistory }
+        }
+        {
+            name: open_command_editor
+            modifier: control
+            keycode: char_o
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: openeditor }
+        }
+        {
+            name: move_up
+            modifier: none
+            keycode: up
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: menuup}
+                    {send: up}
+                ]
+            }
+        }
+        {
+            name: move_down
+            modifier: none
+            keycode: down
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: menudown}
+                    {send: down}
+                ]
+            }
+        }
+        {
+            name: move_left
+            modifier: none
+            keycode: left
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: menuleft}
+                    {send: left}
+                ]
+            }
+        }
+        {
+            name: move_right_or_take_history_hint
+            modifier: none
+            keycode: right
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: historyhintcomplete}
+                    {send: menuright}
+                    {send: right}
+                ]
+            }
+        }
+        {
+            name: move_one_word_left
+            modifier: control
+            keycode: left
+            mode: [emacs, vi_normal, vi_insert]
+            event: {edit: movewordleft}
+        }
+        {
+            name: move_one_word_right_or_take_history_hint
+            modifier: control
+            keycode: right
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: historyhintwordcomplete}
+                    {edit: movewordright}
+                ]
+            }
+        }
+        {
+            name: move_to_line_start
+            modifier: none
+            keycode: home
+            mode: [emacs, vi_normal, vi_insert]
+            event: {edit: movetolinestart}
+        }
+        {
+            name: move_to_line_start
+            modifier: control
+            keycode: char_a
+            mode: [emacs, vi_normal, vi_insert]
+            event: {edit: movetolinestart}
+        }
+        {
+            name: move_to_line_end_or_take_history_hint
+            modifier: none
+            keycode: end
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: historyhintcomplete}
+                    {edit: movetolineend}
+                ]
+            }
+        }
+        {
+            name: move_to_line_end_or_take_history_hint
+            modifier: control
+            keycode: char_e
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: historyhintcomplete}
+                    {edit: movetolineend}
+                ]
+            }
+        }
+        {
+            name: move_to_line_start
+            modifier: control
+            keycode: home
+            mode: [emacs, vi_normal, vi_insert]
+            event: {edit: movetolinestart}
+        }
+        {
+            name: move_to_line_end
+            modifier: control
+            keycode: end
+            mode: [emacs, vi_normal, vi_insert]
+            event: {edit: movetolineend}
+        }
+        {
+            name: move_up
+            modifier: control
+            keycode: char_p
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: menuup}
+                    {send: up}
+                ]
+            }
+        }
+        {
+            name: move_down
+            modifier: control
+            keycode: char_t
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: menudown}
+                    {send: down}
+                ]
+            }
+        }
+        {
+            name: delete_one_character_backward
+            modifier: none
+            keycode: backspace
+            mode: [emacs, vi_insert]
+            event: {edit: backspace}
+        }
+        {
+            name: delete_one_word_backward
+            modifier: control
+            keycode: backspace
+            mode: [emacs, vi_insert]
+            event: {edit: backspaceword}
+        }
+        {
+            name: delete_one_character_forward
+            modifier: none
+            keycode: delete
+            mode: [emacs, vi_insert]
+            event: {edit: delete}
+        }
+        {
+            name: delete_one_character_forward
+            modifier: control
+            keycode: delete
+            mode: [emacs, vi_insert]
+            event: {edit: delete}
+        }
+        {
+            name: delete_one_character_forward
+            modifier: control
+            keycode: char_h
+            mode: [emacs, vi_insert]
+            event: {edit: backspace}
+        }
+        {
+            name: delete_one_word_backward
+            modifier: control
+            keycode: char_w
+            mode: [emacs, vi_insert]
+            event: {edit: backspaceword}
+        }
+        {
+            name: move_left
+            modifier: none
+            keycode: backspace
+            mode: vi_normal
+            event: {edit: moveleft}
+        }
+        {
+            name: newline_or_run_command
+            modifier: none
+            keycode: enter
+            mode: emacs
+            event: {send: enter}
+        }
+        {
+            name: move_left
+            modifier: control
+            keycode: char_b
+            mode: emacs
+            event: {
+                until: [
+                    {send: menuleft}
+                    {send: left}
+                ]
+            }
+        }
+        {
+            name: move_right_or_take_history_hint
+            modifier: control
+            keycode: char_f
+            mode: emacs
+            event: {
+                until: [
+                    {send: historyhintcomplete}
+                    {send: menuright}
+                    {send: right}
+                ]
+            }
+        }
+        {
+            name: redo_change
+            modifier: control
+            keycode: char_g
+            mode: emacs
+            event: {edit: redo}
+        }
+        {
+            name: undo_change
+            modifier: control
+            keycode: char_z
+            mode: emacs
+            event: {edit: undo}
+        }
+        {
+            name: paste_before
+            modifier: control
+            keycode: char_y
+            mode: emacs
+            event: {edit: pastecutbufferbefore}
+        }
+        {
+            name: cut_word_left
+            modifier: control
+            keycode: char_w
+            mode: emacs
+            event: {edit: cutwordleft}
+        }
+        {
+            name: cut_line_to_end
+            modifier: control
+            keycode: char_k
+            mode: emacs
+            event: {edit: cuttoend}
+        }
+        {
+            name: cut_line_from_start
+            modifier: control
+            keycode: char_u
+            mode: emacs
+            event: {edit: cutfromstart}
+        }
+        {
+            name: swap_graphemes
+            modifier: control
+            keycode: char_t
+            mode: emacs
+            event: {edit: swapgraphemes}
+        }
+        {
+            name: move_one_word_left
+            modifier: alt
+            keycode: left
+            mode: emacs
+            event: {edit: movewordleft}
+        }
+        {
+            name: move_one_word_right_or_take_history_hint
+            modifier: alt
+            keycode: right
+            mode: emacs
+            event: {
+                until: [
+                    {send: historyhintwordcomplete}
+                    {edit: movewordright}
+                ]
+            }
+        }
+        {
+            name: move_one_word_left
+            modifier: alt
+            keycode: char_b
+            mode: emacs
+            event: {edit: movewordleft}
+        }
+        {
+            name: move_one_word_right_or_take_history_hint
+            modifier: alt
+            keycode: char_f
+            mode: emacs
+            event: {
+                until: [
+                    {send: historyhintwordcomplete}
+                    {edit: movewordright}
+                ]
+            }
+        }
+        {
+            name: delete_one_word_forward
+            modifier: alt
+            keycode: delete
+            mode: emacs
+            event: {edit: deleteword}
+        }
+        {
+            name: delete_one_word_backward
+            modifier: alt
+            keycode: backspace
+            mode: emacs
+            event: {edit: backspaceword}
+        }
+        {
+            name: delete_one_word_backward
+            modifier: alt
+            keycode: char_m
+            mode: emacs
+            event: {edit: backspaceword}
+        }
+        {
+            name: cut_word_to_right
+            modifier: alt
+            keycode: char_d
+            mode: emacs
+            event: {edit: cutwordright}
+        }
+        {
+            name: upper_case_word
+            modifier: alt
+            keycode: char_u
+            mode: emacs
+            event: {edit: uppercaseword}
+        }
+        {
+            name: lower_case_word
+            modifier: alt
+            keycode: char_l
+            mode: emacs
+            event: {edit: lowercaseword}
+        }
+        {
+            name: capitalize_char
+            modifier: alt
+            keycode: char_c
+            mode: emacs
+            event: {edit: capitalizechar}
+        }
+    ]
+}

nushell/config/mount.nu

@@ -0,0 +1,65 @@
+# startx checks if disks are mounted
+def startx [] {
+    # I'm used to running startx right after I login, to this first mount my
+    # disks and then runs startx.
+    mount-disk
+
+    # Then I run startx
+    /bin/startx
+}
+
+# mount my encrypted disks
+def mount-disk [] {
+
+    # If there is no $env.PRIMARY_DISK_UUID, we don't have to decrypt / mount anything
+    if not ("PRIMARY_DISK_UUID" in $env) {
+        return
+    }
+
+    # In my home on my encrypted partition, I have an empty file in ~/.mounted,
+    # this way, I can easily check if my encrypted partition is mounted or not.
+    if ("~/.mounted"| path exists) {
+        print -en "already mounted\n"
+        return
+    }
+
+    mut passphrase = ""
+
+    # On my computer, I have two disks, one NVMe with my OS, and one HDD with
+    # more space. I want three attempts at typing the passphrase.
+    for retry in [1, 2, 3] {
+
+        # Because they're encrypted with the same passphrase, I read the
+        # passphrase once, and then decrypt both disks.
+        sudo echo -n
+        let local_passphrase = (input -s "Enter your passphrase: ")
+        print -en "\n"
+
+        # Mount the NVMe encrypted partition
+        let mounted = do { $local_passphrase | sudo cryptsetup luksOpen ("/dev/disk/by-uuid/" + $env.PRIMARY_DISK_UUID) luks } | complete
+
+        # If mounted correctly, break this loop and mount other partitions.
+        if $mounted.exit_code == 0 {
+            print -en (ansi green_bold) "Passphrase correct\n" (ansi reset)
+            $passphrase = $local_passphrase
+            break
+        } else if $retry == 3 {
+            # If the third attempt failed, exit
+            error make {msg: "couldn't decrypt disk"}
+        } else {
+            print -en (ansi red_bold) "Passphrase incorrect, please try again\n" (ansi reset)
+        }
+    }
+
+    sudo mount /dev/mapper/luks /home
+
+    if ("SECONDARY_DISK_UUID" in $env) {
+        $passphrase | sudo cryptsetup luksOpen ("/dev/disk/by-uuid/" + $env.SECONDARY_DISK_UUID) luks2
+        sudo mount /dev/mapper/luks2 /mnt
+    }
+
+    # Some services cannot be started on boot because my encrypted drives are
+    # not mounted yet, so I mount them here.
+    systemctl start --user pueued
+    sudo systemctl start docker
+}

nushell/config/pass.nu

@@ -0,0 +1,38 @@
+# pass aliases / completion
+
+def _pass_completion [] {
+    _ls ~/.password-store/**/* | each { |x|
+        if $x.type == "file" {
+            $x.name
+                | path parse
+                | update extension ""
+                | get parent stem
+                | str join "/"
+        } else {
+            $x.name + "/"
+        }
+        | split row '/'
+        | skip 4
+        | str join "/"
+    }
+    | prepend git
+    | prepend insert
+}
+
+export extern "pass" [ host?: string@_pass_completion ]
+
+# pass shortcut
+def p [ ...arg: string@_pass_completion ] {
+    for a in $arg {
+        pass $a
+    }
+}
+
+# pass with copy
+def pc [ arg: string@_pass_completion ] { pass --clip $arg }
+
+# open pdf encrypted file
+def ppdf [p: string] {
+    pc thomas/key/pdf
+    pueue add evince $p
+}

nushell/config/ssh.nu

@@ -0,0 +1,11 @@
+# ssh completion
+def _ssh_hosts [] {
+    open ~/.ssh/config
+        | lines
+        | find -ir "host "
+        | each { $in | split row " " | get 1 }
+}
+
+export extern "ssh" [
+    host?: string@_ssh_hosts
+]

nushell/config/tfetch.nu

@@ -0,0 +1,16 @@
+# nushell puts prompt at bottom of terminal on resize, so it's preferable to start on the bottom of the terminal
+
+let has_tfetch = not (which tfetch | is-empty)
+
+# tfetch takes 19 lines, 21 with prompt
+let height = (stty size | split row " " | get 0 | into int) - (if $has_tfetch { 21 } else { 0 })
+
+# skip lines so that the prompt starts at the bottom of the terminal
+for i in 0..<$height {
+    print -n "\n"
+}
+
+# Start tfetch
+if $has_tfetch {
+    tfetch
+}

nushell/config/update.nu

@@ -0,0 +1,25 @@
+# update completion
+def _update_args [] {
+    [
+        system
+        rust
+        wasm
+        npm
+        dotfiles
+        neovim
+        check
+        startup
+        last-update
+        postpone
+        force-unlock
+    ]
+}
+
+# update system
+def u [arg?: string@_update_args] {
+    if $arg == null {
+        ^update
+    } else {
+        ^update $arg
+    }
+}

nushell/config/xrandr.nu

@@ -0,0 +1,66 @@
+# xrandr wrapper for nushell
+def xrandr [] {
+    mut output = []
+    mut current_screen = {
+        name: ""
+        connected: false
+        on: false
+        primary: false
+        resolution: null
+        position: null
+        resolutions: []
+    }
+
+    let lines = ^xrandr | lines
+    let length = $lines | length
+
+    # We skip the first line
+    for i in 1..<$length {
+
+        let line = $lines | get $i
+        let split = $line | split row -r '\s+'
+
+        # This will be true whether the screen is connected or not
+        if $line =~ "connected" {
+
+            if $current_screen.name != "" {
+                $output = ($output | append $current_screen)
+                $current_screen.resolutions = []
+                $current_screen.on = false
+                $current_screen.resolution = null
+                $current_screen.position = null
+            }
+
+            $current_screen.name = ($split | get 0)
+            $current_screen.connected = (($split | get 1) != "disconnected")
+            $current_screen.primary = (($split | get 2) == "primary")
+
+            let resolution = if $current_screen.primary {
+                ($split | get 3 | split column -c '+' | get column1 | get 0)
+            } else {
+                ($split | get 2 | split column -c '+' | get column1 | get 0)
+            }
+
+            if not ($resolution | str starts-with "(") {
+                $current_screen.on = true
+                $current_screen.resolution = $resolution
+
+                $current_screen.position = if $current_screen.primary {
+                    ($split | get 3 | split column -c '+' | each { "+" + $in.column2 + "+" + $in.column3 } | get 0)
+                } else {
+                    ($split | get 2 | split column -c '+' | each { "+" + $in.column2 + "+" + $in.column3 } | get 0)
+                }
+            }
+
+
+        } else {
+            $current_screen.resolutions = ($current_screen.resolutions | append ($split | get 1))
+        }
+    }
+
+    if $current_screen.name != "" {
+        $output = ($output | append $current_screen)
+    }
+
+    $output
+}

nushell/env.nu

@@ -0,0 +1,257 @@
+# Nushell Environment Config File
+#
+# version = "0.86.0"
+
+def create_left_prompt [] {
+    let home =  $nu.home-path
+
+    # Perform tilde substitution on dir
+    # To determine if the prefix of the path matches the home dir, we split the current path into
+    # segments, and compare those with the segments of the home dir. In cases where the current dir
+    # is a parent of the home dir (e.g. `/home`, homedir is `/home/user`), this comparison will
+    # also evaluate to true. Inside the condition, we attempt to str replace `$home` with `~`.
+    # Inside the condition, either:
+    # 1. The home prefix will be replaced
+    # 2. The current dir is a parent of the home dir, so it will be uneffected by the str replace
+    let dir = (
+        if ($env.PWD | path split | zip ($home | path split) | all { $in.0 == $in.1 }) {
+            ($env.PWD | str replace $home "~")
+        } else {
+            $env.PWD
+        }
+    )
+
+    # Arrow of prompt
+    let arrow_color = if "SSH_CLIENT" in $env {
+        ansi green_bold
+    } else {
+        ansi magenta_bold
+    }
+
+    let first_line_arrow = "┌──"
+    let second_line_arrow = "└▷"
+
+    # Time
+    let time_color = ansi magenta_bold
+    let time_segment = date now | format date ' [%H:%M] '
+
+    # Name of the current user
+    let username_color = ansi magenta_bold
+    let username = $env.USER
+
+    # Delimiter between user and hostname, then hostname and cwd
+    let delimiter_color = ansi yellow_bold
+    let first_delimiter = "@"
+    let second_delimiter = "::"
+
+    # Hostname
+    let hostname_color = ansi green_bold
+    let hostname = (sys).host.hostname
+
+    # Current director
+    let dir_color = ansi blue_bold
+    let reset_ansi = ansi reset
+
+    # Current git branch, with * if things are not commited
+    let git_color = [(ansi reset), (ansi yellow)] | str join
+    let git_branch = do { git rev-parse --abbrev-ref HEAD }
+      | complete
+      | update stdout ($in.stdout | str trim -c "\n")
+
+    let git_status = do { git status -s } | complete | get stdout | str trim -c "\n"
+
+    let git_changed = if $git_status == "" {
+        ""
+    } else {
+        "*"
+    }
+
+    let git_branch_content = if $git_branch.exit_code == 0 {
+        [$git_color, " ‹", $git_branch.stdout, $git_changed, "›"] | str join
+    } else {
+        ""
+    }
+
+    # Current kube
+    let kube_color = ansi cyan_bold
+
+    let kube = if ("KUBECONFIG" in $env) {
+        let kube_name = $env.KUBECONFIG | path dirname | path basename
+        [$kube_color, " ‹", $kube_name, "›"] | str join
+
+    } else {
+        ""
+    }
+
+    [
+        $arrow_color
+        $first_line_arrow
+        $time_color
+        $time_segment
+        $username_color
+        $username
+        $delimiter_color
+        $first_delimiter
+        $hostname_color
+        $hostname
+        $delimiter_color
+        $second_delimiter
+        $dir_color
+        $dir
+        $git_branch_content
+        $kube
+        "\n"
+        $reset_ansi
+        $arrow_color
+        $second_line_arrow
+    ] | str join
+}
+
+def create_right_prompt [] {
+    let last_exit_code = if ($env.LAST_EXIT_CODE != 0) {([
+        "\e[B"
+        (ansi red_bold)
+        ($env.LAST_EXIT_CODE)
+        " ↵ "
+    ] | str join)
+    } else {([
+        "\e[B"
+        (ansi green_bold)
+        ($env.LAST_EXIT_CODE)
+        " ↵ "
+    ] | str join)
+    }
+
+    ([$last_exit_code] | str join)
+}
+
+# Use nushell functions to define your right and left prompt
+$env.PROMPT_COMMAND = {|| create_left_prompt }
+# FIXME: This default is not implemented in rust code as of 2023-09-08.
+$env.PROMPT_COMMAND_RIGHT = {|| create_right_prompt }
+
+# The prompt indicators are environmental variables that represent
+# the state of the prompt
+$env.PROMPT_INDICATOR = {|| "  " }
+$env.PROMPT_INDICATOR_VI_INSERT = {|| ": " }
+$env.PROMPT_INDICATOR_VI_NORMAL = {|| "> " }
+$env.PROMPT_MULTILINE_INDICATOR = {|| "::: " }
+
+# If you want previously entered commands to have a different prompt from the usual one,
+# you can uncomment one or more of the following lines.
+# This can be useful if you have a 2-line prompt and it's taking up a lot of space
+# because every command entered takes up 2 lines instead of 1. You can then uncomment
+# the line below so that previously entered commands show with a single `🚀`.
+# $env.TRANSIENT_PROMPT_COMMAND = {|| "🚀 " }
+# $env.TRANSIENT_PROMPT_INDICATOR = {|| "" }
+# $env.TRANSIENT_PROMPT_INDICATOR_VI_INSERT = {|| "" }
+# $env.TRANSIENT_PROMPT_INDICATOR_VI_NORMAL = {|| "" }
+# $env.TRANSIENT_PROMPT_MULTILINE_INDICATOR = {|| "" }
+# $env.TRANSIENT_PROMPT_COMMAND_RIGHT = {|| "" }
+
+# Specifies how environment variables are:
+# - converted from a string to a value on Nushell startup (from_string)
+# - converted from a value back to a string when running external commands (to_string)
+# Note: The conversions happen *after* config.nu is loaded
+$env.ENV_CONVERSIONS = {
+    "PATH": {
+        from_string: { |s| $s | split row (char esep) | path expand --no-symlink }
+        to_string: { |v| $v | path expand --no-symlink | str join (char esep) }
+    }
+    "Path": {
+        from_string: { |s| $s | split row (char esep) | path expand --no-symlink }
+        to_string: { |v| $v | path expand --no-symlink | str join (char esep) }
+    }
+}
+
+# Directories to search for scripts when calling source or use
+$env.NU_LIB_DIRS = [
+    # FIXME: This default is not implemented in rust code as of 2023-09-06.
+    ($nu.default-config-dir | path join 'scripts') # add <nushell-config-dir>/scripts
+]
+
+# Directories to search for plugin binaries when calling register
+$env.NU_PLUGIN_DIRS = [
+    # FIXME: This default is not implemented in rust code as of 2023-09-06.
+    ($nu.default-config-dir | path join 'plugins') # add <nushell-config-dir>/plugins
+]
+
+# LS_COLORS so that ls mimics the colors of exa
+$env.LS_COLORS = ([
+    # File types
+    "ex=1;32"            # Executables
+    "di=1;34"            # Directories
+    "ln=36"              # Links
+    "or=31"              # Orphan
+
+    # Media types
+    "*.pdf=32"           # PDF files
+
+    # Images
+    "*.webp=35"          # Webp image
+    "*.png=35"           # PNG image
+    "*.jpg=35"           # JPG image
+
+    # Music
+    "*.ogg=36"           # OGG sound
+    "*.mp3=36"           # MP3 sound
+
+    # Videos
+    "*.mp4=1;35"         # MP4 video
+    "*.avi=1;35"         # AVI video
+    "*.webm=1;35"        # WebM video
+
+    # Bold yellow: source code
+    "*.c=1;33"           # C source
+    "*.h=1;33"           # C header
+    "*.cpp=1;33"         # C++ source
+    "*.hpp=1;33"         # C++ header
+    "*.inl=1;33"         # C++ include
+    "*.cxx=1;33"         # C++ include
+    "*.py=1;33"          # Python
+    "*.js=1;33"          # JavaScript
+    "*.ts=1;33"          # TypeScript
+    "*.rs=1;33"          # Rust
+    "*.elm=1;33"         # Elm
+    "*.nu=1;33"          # Nushell
+
+    # Build / doc files
+    "*Makefile=1;4;33"   # Makefile
+    "*Dockerfile=1;4;33" # Dockerfile
+    "*.md=1;4;33"        # Markdown
+    "*.toml=1;4;33"      # Toml
+] | str join ":")
+
+# French by default
+$env.LANG = fr_FR.UTF-8
+
+# Gnome Keyring Daemon
+$env.GNOME_KEYRING_DAEMON = '/run/user/1000/keyring'
+
+# Text file editor
+$env.EDITOR = nvim
+
+# Backtrace for rust
+$env.RUST_BACKTRACE = full
+
+# Gclone env
+$env.GCLONE_PATH = $env.HOME + '/git'
+$env.GCLONE_FORCE_SSH = true
+
+# Python virtual env
+$env.VIRTUAL_ENV = $env.HOME + '/.venv'
+
+# Don't put ugly go directory in my home
+$env.GOPATH = $env.HOME + '/.go'
+
+# To add entries to PATH (on Windows you might use Path), you can use the following pattern:
+# $env.PATH = ($env.PATH | split row (char esep) | prepend '/some/path')
+$env.PATH = ($env.PATH
+    | split row (char esep)
+    | prepend ($env.HOME + '/.config/polymny/bin')
+    | prepend ($env.HOME + '/.config/dotfiles/bin')
+    | prepend ($env.HOME + '/.config/dotfiles/bin-extra')
+    | prepend ($env.HOME + '/.cargo/bin')
+    | prepend ($env.HOME + '/.npmbin/bin')
+    | prepend ($env.HOME + '/.venv/bin')
+)