Nushell 0.114.0

Today, we're releasing version 0.114.0 of Nu. This release brings sharper type checking, POSIX-style -- option parsing, the new run command for pipeline-friendly scripts, and nice built-in support for working with Semantic Versioning.

Where to get it

Nu 0.114.0 is available as pre-built binaries or from crates.io. If you have Rust installed you can install it using cargo install nu.

As part of this release, we also publish a set of optional plugins you can install and use with Nushell.

Table of contents

Highlights and themes of this release [toc]

The type checker got new glasses [toc]

@Bahex continued tightening up Nushell's type system this release. Commands can now infer output types from pipeline input more precisely, $in gets typed from the surrounding pipeline, optional values carry their nothing-ness more honestly, and let bindings in pipelines no longer have to shrug and call everything any.

This means some mistakes move from "surprise, runtime error" to "hey, maybe fix that before running it". Very rude of the parser, but also very helpful.

There is also one important default change: enforce-runtime-annotations is now opt-out, so runtime assignment annotations get checked by default.

Read the details in the first type system entry, the second type system entry, and the note about enforce-runtime-annotations.

-- means "no really, stop parsing flags" [toc]

Thanks to @fdncred, Nushell commands now understand the classic POSIX -- end-of-options delimiter. If you need to pass -weird, --looks-like-a-flag, or similar gremlins as plain positional values, you can now do that without trying to outsmart the parser.

def greet [--upper, name] { if $upper { $name | str uppercase } else { $name } }
greet -- -Alice

That -Alice is now just Alice having a dash day, not an accidental flag.

Take a look at the main -- option parsing entry and the follow-up --wrapped fix.

Scripts can join the pipeline with run [toc]

The new run command from @fdncred lets a Nushell script behave like a pipeline stage. Pipe data in, let the script transform it, and pipe the result onward. Tiny reusable pipeline workers, basically.

"Hello Nushell!" | run shout.nu | str camel-case

Scripts can be simple bare pipeline transforms or define a main entry point, and they run in isolation so their local bits do not leak back into your session.

See more examples here.

SemVer is a real value now [toc]

Nushell now has semantic version support, also from @fdncred. You can parse SemVer strings, turn them into records, build them back up, sort them correctly, and bump versions without doing string surgery with safety scissors.

'1.2.3-alpha.1' | into semver | semver bump release

If your scripts deal with releases, package versions, or "is 1.10.0 bigger than 1.2.0?" moments, this should make life nicer.

Read the full SemVer tour here.

Changes [toc]

Breaking changes [toc]

Submodules are no longer implicitly imported [toc]

PR #18303 by @Bahex

Importing a module no longer implicitly imports its exported sub-modules.

export module foo {
    export def bar [] {}

    export module sub {
        export def baz [] {}
    }
}

use foo
foo bar      # valid
foo sub baz  # invalid, `sub` is not implicitly imported

To have your modules keep the old behavior, you will need to export the modules contents explicitly:

export module foo {
    export def bar [] {}

    export module sub {
        export def baz [] {}
    }
    export use sub
}

use foo
foo bar      # valid
foo sub baz  # valid

Type System Improvements [toc]

PR #18430 by @Bahex

This release comes with a handful of improvements to the type system, specifically the parse time type checking. But beware! Type annotations that previously seemed fine might raise errors, as they might have been passing only because typing information was insufficient to check it at parse time.

Commands' output types are now inferred based on pipeline input type.

let str = "foo" | str uppercase
let str_list = ["foo", "bar" ] | str uppercase

scope variables
| where name starts-with '$str'
| select name type

╭───┬───────────┬──────╮
│ # │   name    │ type │
├───┼───────────┼──────┤
│ 0 │ $str      │ any  │
│ 1 │ $str_list │ any  │
╰───┴───────────┴──────╯

╭───┬───────────┬──────────────╮
│ # │   name    │     type     │
├───┼───────────┼──────────────┤
│ 0 │ $str      │ string       │
│ 1 │ $str_list │ list<string> │
╰───┴───────────┴──────────────╯

Optional parameters' type now reflects the fact it might be null

The (parse time) types of optional parameters and flags without a default value are now a union of their type T and nothing

• with no default value the type is oneof<T, nothing>
• with a default value type is T

Demonstrating with LSP inlay hints:

    1  def foo [opt_param?: int] {
    2    let var: int = $opt_param
    3  }
    ~

    1  def foo [opt_param?: int] {
    2    let var: oneof<int, nothing> = $opt_param
    3  }
    ~

    1  def foo [opt_param?: int = 42] {
    2    let var: int = $opt_param
    3  }
    ~

More precise type widening

More type information is preserved. e.g.:

let list = [["a" "b" "c"] [1 2 3]]
let elem = $list.0

Previously $elem's type would be list<oneof<int, string>>, now $elem's type is oneof<list<int>, list<string>>.

Operator type checking now accounts of oneof types

Nushell as language tries to strike a careful balance between correctness and convenience. One should be able to trust nu's type system will help them write correct and robust scripts, but nu shouldn't shouldn't get in the way of a nice REPL experience.

Because of that, some operations that might be invalid but aren't definitely so do not raise parse errors and such checks are delegated to runtime.

For example int's can only be added with int's and float's, yet the following code does not raise parse time error.

def foo [anything: any] {
    10 + $anything
}

But previously, despite being oneof<int, nothing> being specific than any, would be rejected by the type checker for addition to ints.

def foo [maybe_int: oneof<int, nothing>] {
    10 + $maybe_int
}

Error: nu::parser::operator_unsupported_type

  × The '+' operator does not work on values of type 'oneof<int, nothing>'.
   ╭─[repl_entry #2:2:8]
 1 │ def foo [maybe_int: oneof<int, nothing>] {
 2 │     10 + $maybe_int
   ·        ┬ ─────┬────
   ·        │      ╰── oneof<int, nothing>
   ·        ╰── does not support 'oneof<int, nothing>'
 3 │ }
   ╰────

Now, as long as the two operands have a possibility of being valid for an operation the parse time type checker will accept the expression, leaving errors to runtime type checking.

Promoted enforce-runtime-annotations to opt-out [toc]

PR #18359 by @Bahex

In Nushell 0.108.0, enforce-runtime-annotations experimental option was added. With this release enforce-runtime-annotations is promoted to being opt-out, meaning that by default this experimental option is enabled now.

This option enforces type checking of let assignments at runtime, catching type errors that might have been missed in parse time type checking due to insufficient type information.

If you experience any trouble with this, you can disable it via the command-line argument:

nu --experimental-options '[enforce-runtime-annotations=false]'

or via the environment variable:

NU_EXPERIMENTAL_OPTIONS="enforce-runtime-annotations=false" nu

Reedline vi mode improvements [toc]

PR #18478 by @kronberger-droid

Vi mode now has a proper visual mode: press v to start a selection, then use motions together with d, c, y, or r, including selections that span multiple lines. In vi normal mode, the caret now rests on the last grapheme instead of after it, and h and l can move across line boundaries. Visual mode also has its own prompt indicator, which defaults to the vi-normal indicator.

Changes to spreadsheet commands: from xlsx & from ods [toc]

PR #18436 by @Bahex

This release comes with various improvements to from xlsx and from ods commands, and makes them behave as similarly as the file formats themselves allow.

More accurate command signatures

These commands' signatures previously incorrectly indicated that they return tables. They return records that contain tables, with a table for each sheet in the file.

Also, signature of the from ods command previously had string as its input type rather than binary. This has been fixed.

Support for more data types

Previously importing datetime values were supported only for xlsx files.

This release not only adds that for ods files as well, but also broadens the datetime formats that can be imported.

Aside from that, values that couldn't be properly coerced to nushell types were simply imported as null. Now those values are imported as string or float depending on the source data.

Finer control over spreadsheet headers

Last release changed from xlsx to use the first row of a sheet as the imported table's headers, and added a new flag, --header-row, to control which row should be used as the header or if any row should become the headers at all.

This release removes it.

Don't worry! Instead of the --header-row flag, from xlsx and from ods get two new flags that will provide finer control over how spreadsheets are imported:

• --noheaders: What it says on the tin, identical to same flag on from csv, from tsv and from ssv commands.
• --first-row: This is where it gets a little interesting. from xlsx and from ods skip reading all leading empty rows. This is how it has worked for a long time. --first-row=0 allows you to turn that off and keep those empty lines. It can also be used to start reading from an arbitrary row: --first-row $n

Let's see how this works with an example:

• The contents of the file, with all the conveniences like skipping empty rows or auto headers off:

  open example.xlsx --raw
  | from xlsx --noheaders --first-row 0

  ╭────────┬───────────────────────────────────────────────╮
  │        │ ╭───┬─────────┬─────────┬─────────┬─────────╮ │
  │ Sheet1 │ │ # │ column0 │ column1 │ column2 │ column3 │ │
  │        │ ├───┼─────────┼─────────┼─────────┼─────────┤ │
  │        │ │ 0 │         │         │         │         │ │
  │        │ │ 1 │         │         │         │         │ │
  │        │ │ 2 │         │         │         │         │ │
  │        │ │ 3 │ a       │ b       │ c       │ d       │ │
  │        │ │ 4 │    0.00 │    1.00 │    2.00 │    3.00 │ │
  │        │ │ 5 │   10.00 │   11.00 │   12.00 │   13.00 │ │
  │        │ │ 6 │   20.00 │   21.00 │   22.00 │   23.00 │ │
  │        │ │ 7 │   30.00 │   31.00 │   32.00 │   33.00 │ │
  │        │ ╰───┴─────────┴─────────┴─────────┴─────────╯ │
  ╰────────┴───────────────────────────────────────────────╯

• How it is imported by default:

  open example.xlsx
  # or `open example.xlsx --raw | from xlsx`

  ╭────────┬───────────────────────────────────────╮
  │        │ ╭───┬───────┬───────┬───────┬───────╮ │
  │ Sheet1 │ │ # │   a   │   b   │   c   │   d   │ │
  │        │ ├───┼───────┼───────┼───────┼───────┤ │
  │        │ │ 0 │  0.00 │  1.00 │  2.00 │  3.00 │ │
  │        │ │ 1 │ 10.00 │ 11.00 │ 12.00 │ 13.00 │ │
  │        │ │ 2 │ 20.00 │ 21.00 │ 22.00 │ 23.00 │ │
  │        │ │ 3 │ 30.00 │ 31.00 │ 32.00 │ 33.00 │ │
  │        │ ╰───┴───────┴───────┴───────┴───────╯ │
  ╰────────┴───────────────────────────────────────╯

  Most of the time, this is what you want.
• Or if your file doesn't have any headers and all the rows are data:

  open example.xlsx --raw | from xlsx --noheaders

  ╭────────┬───────────────────────────────────────────────╮
  │        │ ╭───┬─────────┬─────────┬─────────┬─────────╮ │
  │ Sheet1 │ │ # │ column0 │ column1 │ column2 │ column3 │ │
  │        │ ├───┼─────────┼─────────┼─────────┼─────────┤ │
  │        │ │ 0 │ a       │ b       │ c       │ d       │ │
  │        │ │ 1 │    0.00 │    1.00 │    2.00 │    3.00 │ │
  │        │ │ 2 │   10.00 │   11.00 │   12.00 │   13.00 │ │
  │        │ │ 3 │   20.00 │   21.00 │   22.00 │   23.00 │ │
  │        │ │ 4 │   30.00 │   31.00 │   32.00 │   33.00 │ │
  │        │ ╰───┴─────────┴─────────┴─────────┴─────────╯ │
  ╰────────┴───────────────────────────────────────────────╯

Type System Improvements [toc]

PR #18450 by @Bahex

Typed $in

$in variable is now typed based on the pipeline input type of the surrounding expression.

Error: nu::shell::operator_incompatible_types

  × Types 'int' and 'string' are not compatible for the '+' operator.
   ╭─[source:1:5]
 1 │ 2 | $in + "foo"
   ·     ─┬─ ┬ ──┬──
   ·      │  │   ╰── string
   ·      │  ╰── does not operate between 'int' and 'string'
   ·      ╰── int
   ╰────

Error: nu::parser::operator_incompatible_types

  × Types 'int' and 'string' are not compatible for the '+' operator.
   ╭─[source:1:5]
 1 │ 2 | $in + "foo"
   ·     ─┬─ ┬ ──┬──
   ·      │  │   ╰── string
   ·      │  ╰── does not operate between 'int' and 'string'
   ·      ╰── int
   ╰────

Better type inference of let bindings

let bindings in the middle of a pipeline, or at the end of it, are now properly typed based ont the pipeline input type.

You can observe this using scope variables:

42 | let x

scope variables
| where name == '$x'
| select name type

╭───┬──────┬──────╮
│ # │ name │ type │
├───┼──────┼──────┤
│ 0 │ $x   │ int  │
╰───┴──────┴──────╯

or with LSP type hints:

42 | let var: int

This type information is of course passed through to the rest of the pipeline:

def accepts-int []: int -> int {}

"foo" | let x | accepts-int

Error: nu::shell::only_supports_this_input_type

  × Input type not supported.
   ╭─[source:3:9]
 2 │
 3 │ "foo" | let x | accepts-int
   ·         ─┬─     ─────┬─────
   ·          │           ╰── only int input data is supported
   ·          ╰── input type: string
   ╰────

Command definitions

Type checking and inference inside def blocks are now affected by the commands input/output signatures.

def accepts-int []: int -> int {}

def foo []: string -> any {
    accepts-int
}

Error: nu::parser::input_type_mismatch

  × Command does not support string input.
   ╭─[source:4:2]
 3 │ def foo []: string -> any {
 4 │     accepts-int
   ·     ─────┬─────
   ·          ╰── command doesn't support string input
 5 │ }
   ╰────

if-else, match

Conditionals (if, match) are now properly typed:

• output of the expression is a union of all possible output types (based on the branches)

  if $x == $y {
      42
  } else {
      "foo"
  }
  | let out  # oneof<int, string>
  
  match $x {
      1 => 1,
      2 => "foo",
      _ => { {a: 1} }
  }
  | let out  # oneof<int, string, record<a: int>>

• without a fallback (a final else branch for if chains, a wildcard pattern for match expressions) the output types of conditional expressions include nothing

  if $x == $y {
      42
  }
  | let out  # oneof<int, nothing>
  
  match $x {
      1 => 1,
      2 => "foo",
  }
  | let out  # oneof<int, string, nothing>

• branch blocks get pipeline input type information

  [1, 2, 3]
  | if true {
      let input  # list<int>
      $input | into string
  } else {
      # pass through
  }
  | let out  # oneof<list<string>, list<int>>

Errors with more details and file relative spans [toc]

PR #18479 by @Bahex

The error record you receive in try {..} catch {..} blocks no longer has a json field. A new field named details takes its place instead. It holds the same information as the json field but requires no deserialization stop like from json.

There is one small but significant difference: the error labels now have additional location field in addition to span. location contains the name of the file the label points to, with start and end offsets that are relative to the file itself.

use std/assert

export def wrong [] {
  assert equal (2 + 2) 5
}

> use example.nu
> wrong
Error: nu::shell::error

  × These are not equal.
   ╭─[/tmp/example.nu:4:16]
 3 │ export def wrong [] {
 4 │   assert equal (2 + 2) 5
   ·                ───┬─── ┬
   ·                   │    ╰── right: 5
   ·                   ╰── left: 4
 5 │ }
   ╰────

> try { wrong } catch { get details }
╭─────────────────┬────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ msg             │ These are not equal.                                                                               │
│                 │ ╭───┬──────────┬────────────────────┬────────────────────────────────────────────────────╮         │
│ labels          │ │ # │   text   │        span        │                      location                      │         │
│                 │ ├───┼──────────┼────────────────────┼────────────────────────────────────────────────────┤         │
│                 │ │ 0 │ left: 4  │ ╭───────┬────────╮ │ ╭───────┬────────────────────────────────────────╮ │         │
│                 │ │   │          │ │ start │ 170639 │ │ │ file  │ D:\Projects\nushell\scratch\example.nu │ │         │
│                 │ │   │          │ │ end   │ 170646 │ │ │ start │ 56                                     │ │         │
│                 │ │   │          │ ╰───────┴────────╯ │ │ end   │ 63                                     │ │         │
│                 │ │   │          │                    │ ╰───────┴────────────────────────────────────────╯ │         │
│                 │ │ 1 │ right: 5 │ ╭───────┬────────╮ │ ╭───────┬────────────────────────────────────────╮ │         │
│                 │ │   │          │ │ start │ 170647 │ │ │ file  │ D:\Projects\nushell\scratch\example.nu │ │         │
│                 │ │   │          │ │ end   │ 170648 │ │ │ start │ 64                                     │ │         │
│                 │ │   │          │ ╰───────┴────────╯ │ │ end   │ 65                                     │ │         │
│                 │ │   │          │                    │ ╰───────┴────────────────────────────────────────╯ │         │
│                 │ ╰───┴──────────┴────────────────────┴────────────────────────────────────────────────────╯         │
│ code            │                                                                                                    │
│ url             │                                                                                                    │
│ help            │                                                                                                    │
│ inner           │ [list 0 items]                                                                                     │
╰─────────────────┴────────────────────────────────────────────────────────────────────────────────────────────────────╯

With these file relative spans, making external tools for reporting nushell errors should be much easier.

Removed deprecated grid record input support [toc]

PR #18276 by @Juhan280

In the last release, grid command was modified to accept a column name argument rather than implicitly displaying the name column. The implicit assumption of name was deprecated, along with accepting a single record rather than a table. These deprecated behaviors of grid command is removed with this release.

# This will no longer work.
{ name: test } | grid

# And should be updated to receive tables and include the column name as an argument.
[{ name: test }] | grid name

Standard library improvements [toc]

PR #18449 by @Bahex

• Following general type system improvements, standard library commands now also have more accurate type annotations.

• std/iter find-index returns null instead of -1 when failing to find a suitable element

std/iter scan now has the same signature as reduce

Previously iter scan always needed an initial value to start off of (equivalent to reduce's --fold), and to compensate for it a --noinit flag to remove that initial value from the output.

Now it's signature is identical to reduce:

[1 2 3] | iter scan 0 {|x, y| $x + $y}

[1 2 3] | iter scan 0 --noinit {|x, y| $x + $y}

[1 2 3] | iter scan --fold 0 {|x, y| $x + $y}

[1 2 3] | iter scan {|x, y| $x + $y}

[0, 1, 3, 6]

[1, 3, 6]

More streaming

The following commands now stream:

• std/iter:
  • intersperse
  • flat-map
• std-rfc/conversion
  • into list
• std-rfc/tables
  • select column-slices
  • reject column-slices

These commands don't really "stream", in that they don't return a stream. Instead they now avoid eagerly collecting input streams:

• std-rfc/conversions
  • name-values: strictly an internal change with possible performance benefits
• std-rfc/iter
  • only: will at most consume 2 items from the input

Other breaking changes [toc]

• We changed how "hits" are displayed by making them relative to the cwd in the hopes that it makes them more usable. It works this way for idx find and idx search. (#18477)

Additions [toc]

KDL format support [toc]

PR #18219 by @abdelkadouss

This release adds support for KDL v2.0.0 with to kdl and from kdl commands.

> '
hello 1 2 3

// Comment
world prop=string-value {
	child 1
	child 2
	child #inf
}
'
| from kdl
╭───┬───────┬────────────────┬─────────────────────────┬──────────────────────────────────────────────────────────────────╮
│ # │ name  │      args      │          props          │                             children                             │
├───┼───────┼────────────────┼─────────────────────────┼──────────────────────────────────────────────────────────────────┤
│ 0 │ hello │ ╭───┬───╮      │ {record 0 fields}       │ [list 0 items]                                                   │
│   │       │ │ 0 │ 1 │      │                         │                                                                  │
│   │       │ │ 1 │ 2 │      │                         │                                                                  │
│   │       │ │ 2 │ 3 │      │                         │                                                                  │
│   │       │ ╰───┴───╯      │                         │                                                                  │
│ 1 │ world │ [list 0 items] │ ╭──────┬──────────────╮ │ ╭───┬───────┬─────────────┬───────────────────┬────────────────╮ │
│   │       │                │ │ prop │ string-value │ │ │ # │ name  │    args     │       props       │    children    │ │
│   │       │                │ ╰──────┴──────────────╯ │ ├───┼───────┼─────────────┼───────────────────┼────────────────┤ │
│   │       │                │                         │ │ 0 │ child │ ╭───┬───╮   │ {record 0 fields} │ [list 0 items] │ │
│   │       │                │                         │ │   │       │ │ 0 │ 1 │   │                   │                │ │
│   │       │                │                         │ │   │       │ ╰───┴───╯   │                   │                │ │
│   │       │                │                         │ │ 1 │ child │ ╭───┬───╮   │ {record 0 fields} │ [list 0 items] │ │
│   │       │                │                         │ │   │       │ │ 0 │ 2 │   │                   │                │ │
│   │       │                │                         │ │   │       │ ╰───┴───╯   │                   │                │ │
│   │       │                │                         │ │ 2 │ child │ ╭───┬─────╮ │ {record 0 fields} │ [list 0 items] │ │
│   │       │                │                         │ │   │       │ │ 0 │ inf │ │                   │                │ │
│   │       │                │                         │ │   │       │ ╰───┴─────╯ │                   │                │ │
│   │       │                │                         │ ╰───┴───────┴─────────────┴───────────────────┴────────────────╯ │
╰───┴───────┴────────────────┴─────────────────────────┴──────────────────────────────────────────────────────────────────╯

Introducing polars map-batches [toc]

PR #18312 by @ayax79

Provides a new polars command polars map-batches that provides the ability to map a custom Nushell closure over one or more dataframe columns.

> [[a b]; [1 4] [2 5] [3 6]]
| polars into-df
| polars map-batches --name out { [10 20 30] } a
╭───┬─────╮
│ # │ out │
├───┼─────┤
│ 0 │  10 │
│ 1 │  20 │
│ 2 │  30 │
╰───┴─────╯

> [[a b]; [1 4] [2 5] [3 6]]
| polars into-df
| polars map-batches {|cols| $cols | first | polars get a | each { $in * 2 }} a
╭───┬───╮
│ # │ a │
├───┼───┤
│ 0 │ 2 │
│ 1 │ 4 │
│ 2 │ 6 │
╰───┴───╯

> [[a b]; [1 4] [2 5] [3 6]]
| polars into-df
| polars map-batches --name a_plus_b { |cols|
    let a = $cols | get 0 | polars get a
    let b = $cols | get 1 | polars get b
    $a | zip $b | each { |pair| $pair.0 + $pair.1 }
} a b
╭───┬──────────╮
│ # │ a_plus_b │
├───┼──────────┤
│ 0 │        5 │
│ 1 │        7 │
│ 2 │        9 │
╰───┴──────────╯

Add commandline complete to invoke nushell completions [toc]

PR #17941 by @ian-h-chamberlain

Add commandline complete command. This can be used to obtain the suggestions that nushell itself would normally suggest. Some examples:

• commandline complete — return completions based on the current commandline contents (i.e. what would be suggested when pressing Tab)
• './a' | commandline complete --type directory — return directory paths relative to the current directory that start with a
• '%ls -' | commandline complete --detailed — return all flags the builtin ls command accepts, including their descriptions.

These completions can be used in custom command completions, for example to wrap a builtin command with additional options, or to obtain a list of suggested paths for further filtering or processing.

Add --pretty flag and align table columns in to nuon [toc]

PR #18121 by @i-api

to nuon now aligns table columns when using --indent, --tabs, or the new --pretty (-p) flag, making output easier to read. --pretty is shorthand for --indent 2.

> [[name, age]; [Alice, 30], [Bob, 25]] | to nuon --pretty
[
  [name,  age];
  [Alice, 30],
  [Bob,   25]
]

Added run command for using scripts in pipelines [toc]

PR #18271 by @fdncred

There's a new command named run that allows scripts to participate in a nushell pipeline with input and output.

It keeps execution isolated so script artifacts do not leak into the parent scope. Script resolution remains aligned with existing behavior (cwd / NU_LIB_DIRS / explicit paths); PATH-based lookup is not included at this time.

Script Forms Supported

Bare scripts (scripts without def main)

The script body is evaluated directly as a pipeline transform (using implicit or explicit $in as usual).

str uppercase

> "Hello Nushell!" | run run-script1.nu
HELLO NUSHELL!

Scripts with def main entry point

If a top-level def main is defined, run invokes that entrypoint.

def main [] {
  str length
}

> "Hello Nushell!" | run run-script2.nu
14

Scripts with full pipelines

> "Hello Nushell!" | run run-script1.nu | str camel-case
helloNushell
> "Hello Nushell!" | run run-script2.nu | $in + 5
19

Added POSIX-style -- option parsing for Nushell commands [toc]

PR #18299 by @fdncred

Nushell now supports the POSIX -- end-of-options delimiter for built-in commands, custom commands, and def --wrapped commands.

When -- appears in a command invocation, it stops all flag parsing. Any arguments after -- are treated as positional operands, even if they start with - or --. The -- token itself is consumed and does not appear in the command's arguments.

>  def greet [--upper, name] {
    if $upper { $name | str uppercase } else { $name }
}
> greet -- -Alice  # -Alice is now a positional, not an unknown flag
-Alice

> def process [...args] { $args }
> process -- --verbose -x foo  # -- consumed; args = ["--verbose", "-x", "foo"]
╭───┬───────────╮
│ 0 │ --verbose │
│ 1 │ -x        │
│ 2 │ foo       │
╰───┴───────────╯

> def --wrapped my-git [...args] { print ...$args }
> my-git commit -- -m "my message"  # -- NOT consumed; -m passed as operand
commit
--
-m
my message

For extern-declared known external commands, -- continues to be passed through to the external binary unchanged (as those programs manage their own argument parsing).

Added stream and error controls to ignore [toc]

PR #18306 by @fdncred

Update the ignore command with flags to control whether stderr, stdout, or both get consumed and if errors are show which update $env.LAST_EXIT_CODE. This should work on internal and external commands.

Existing behavior is the default when no new flags are provided to avoid breaking changes.

• Added --stderr (-e) to consume stderr while allowing stdout to pass through.
• Added --stdout (-o) to consume stdout while allowing stderr output through.
• Added --show-errors (-x) to show external/internal errors and set $env.LAST_EXIT_CODE (external exit code for external failures, 1 for internal failures).

Added --context support to idx search [toc]

PR #18366 by @fdncred

Add context to your idx search queries by using --context/-c and a nushell range. The range has to be in the form of negative_number..positive_number where negative_number is the before lines to show and the positive_number is the after lines to show in the with_context record key.

> idx search foo --context -3..5 | first
╭───────────────┬─────────────────────────────────────────────────────────────────────────────────────────────╮
│ relative_path │ crates\nu-utils\src\default_files\doc_config.nu                                             │
│ line_number   │ 249                                                                                         │
│ column        │ 51                                                                                          │
│ byte_offset   │ 10991                                                                                       │
│ line          │ # Example: If a directory contains only "forage", "food", and "forest",                     │
│               │ ╭───┬───────┬───────╮                                                                       │
│ matches       │ │ # │ start │  end  │                                                                       │
│               │ ├───┼───────┼───────┤                                                                       │
│               │ │ 0 │ 11042 │ 11045 │                                                                       │
│               │ ╰───┴───────┴───────╯                                                                       │
│               │ ╭───┬─────────────────────────────────────────────────────────────────────────────────────╮ │
│ with_context  │ │ 0 │ # Default: true                                                                     │ │
│               │ │ 1 │ $env.config.completions.partial = true                                              │ │
│               │ │ 2 │                                                                                     │ │
│               │ │ 3 │ # Example: If a directory contains only "forage", "food", and "forest",             │ │
│               │ │ 4 │ # typing "ls " and pressing Tab will partially complete the first matching letters. │ │
│               │ │ 5 │ # If the directory also includes "faster", only "f" would be partially completed.   │ │
│               │ │ 6 │                                                                                     │ │
│               │ │ 7 │ # completions.use_ls_colors (bool): Apply LS_COLORS to file/path completions.       │ │
│               │ │ 8 │ # true: Use LS_COLORS for styling file completions.                                 │ │
│               │ ╰───┴─────────────────────────────────────────────────────────────────────────────────────╯ │
╰───────────────┴─────────────────────────────────────────────────────────────────────────────────────────────╯

Allowed idx search --context to accept counts or ranges [toc]

PR #18368 by @fdncred

This change allows idx search --context to be supplied as either an int or as a range.

> idx search foo --context 2 | first
╭───────────────┬─────────────────────────────────────────────────────────────────────────────────────────────╮
│ relative_path │ crates\nu-utils\src\default_files\doc_config.nu                                             │
│ line_number   │ 249                                                                                         │
│ column        │ 51                                                                                          │
│ byte_offset   │ 10991                                                                                       │
│ line          │ # Example: If a directory contains only "forage", "food", and "forest",                     │
│               │ ╭───┬───────┬───────╮                                                                       │
│ matches       │ │ # │ start │  end  │                                                                       │
│               │ ├───┼───────┼───────┤                                                                       │
│               │ │ 0 │ 11042 │ 11045 │                                                                       │
│               │ ╰───┴───────┴───────╯                                                                       │
│               │ ╭───┬─────────────────────────────────────────────────────────────────────────────────────╮ │
│ with_context  │ │ 0 │ $env.config.completions.partial = true                                              │ │
│               │ │ 1 │                                                                                     │ │
│               │ │ 2 │ # Example: If a directory contains only "forage", "food", and "forest",             │ │
│               │ │ 3 │ # typing "ls " and pressing Tab will partially complete the first matching letters. │ │
│               │ │ 4 │ # If the directory also includes "faster", only "f" would be partially completed.   │ │
│               │ ╰───┴─────────────────────────────────────────────────────────────────────────────────────╯ │
╰───────────────┴─────────────────────────────────────────────────────────────────────────────────────────────╯

Introducing Polars bitwise commands [toc]

PR #18383 by @ayax79

Introducing polars bitwise commands:

• polars math bitwise-and - Perform an aggregation of bitwise ANDs over a column expression.
• polars math bitwise-count-ones - Compute the number of set bits for each element in an integer column expression.
• polars math bitwise-count-zeros - Compute the number of unset bits for each element in an integer column expression.
• polars math bitwise-leading-ones - Compute the number of leading set bits for each element in an integer column expression.
• polars math bitwise-leading-zeros - Compute the number of leading unset bits for each element in an integer column expression.
• polars math bitwise-or - Perform an aggregation of bitwise ORs over a column expression.
• polars math bitwise-trailing-ones - Compute the number of trailing set bits for each element in an integer column expression.
• polars math bitwise-trailing-zeros - Compute the number of trailing unset bits for each element in an integer column expression.
• polars math bitwise-xor - Perform an aggregation of bitwise XORs over a column expression.

Add non UTF-8 text support for url encode/url decode [toc]

PR #18314 by @Bahex

• url encode can now encode binary input too, adding support for encoding non UTF-8 texts

  > '£ rates' | encode iso-8859-1 | url encode
  %A3%20rates

• url decode can now decode inputs that do not evaluate to UTF-8 texts by returning a binary value (only with the --binary switch)

  > '%A3%20rates' | url decode --binary | decode iso-8859-1
  £ rates

Support reedline menu input/output modes and list description position [toc]

PR #18404 by @kronberger-droid

Reedline menus can now be configured with input_mode (diff, cursor_prefix, full_buffer) and output_mode (suggested_span, full_buffer, extend_to_end) to control what text the menu reads from the buffer and how an accepted suggestion is written back. List menus additionally accept description_position (before / after). The existing only_buffer_difference flag still works and is treated as a shorthand (true = diff, false = cursor_prefix).

Added random pass for generating passwords [toc]

PR #18410 by @fdncred

New command random pass generates random passwords.

> 0..10 | each {random pass}
╭────┬──────────────╮
│  0 │ WR9+*T4em#&2 │
│  1 │ >~z$0I-E<3&x │
│  2 │ "%uF9qafB%+{ │
│  3 │ VMI5h+T4,XcX │
│  4 │ B,diE+Z`#O6g │
│  5 │ 9fKehf4|F,xr │
│  6 │ 6d?nH1|HV^ck │
│  7 │ iH>5l?`P7q2x │
│  8 │ w>w2I(v67=9E │
│  9 │ QYqc}g8ux#!U │
│ 10 │ #Jla4UAoJ+<G │
╰────┴──────────────╯

random pass supports these flags.

Flags:
  -h, --help: Display the help message for this command
  -c, --chars <int>: Length of the generated password (default 12).
  -u, --no-uppercase: Exclude uppercase letters A-Z.
  -l, --no-lowercase: Exclude lowercase letters a-z.
  -n, --no-numbers: Exclude numbers 0-9.
  -s, --no-symbols: Exclude symbols like !@#$%.
  --include-ambiguous: Include ambiguous characters O, 0, l, 1.
  --include-similar: Include similar characters i, l, 1.
  --require-each-type: Guarantee at least one char from each enabled character type.

Allow is-terminal to detect redirection [toc]

PR #18443 by @fdncred

The is-terminal command can detect redirection now. It now defaults to --stdout.

> is-terminal
true
> is-terminal | $in
false
> is-terminal o> file
> open file
false
> let x = (is-terminal)
> $x
false

Added --right to split row and split column [toc]

PR #18444 by @flying-sheep

Both split row and split column now support --right, which modifies where splits are skipped, e.g.:

> 'some-package-1.0' | split row '-' --number 2
╭───┬─────────────╮
│ 0 │ some        │
│ 1 │ package-1.0 │
╰───┴─────────────╯
> 'some-package-1.0' | split row '-' --number 2 --right
╭───┬──────────────╮
│ 0 │ some-package │
│ 1 │ 1.0          │
╰───┴──────────────╯

Added some commands for set operations and combinations [toc]

PR #18467 by @fdncred

Added union, intersect, difference, combinations, and permutations as built-in filter commands. These provide immutable, functional list operations.

union: Returns a deduplicated list of unique elements present in either the input list or the given list.

> [1 2 3 4] | union [3 4 5 6]
╭───┬───╮
│ 0 │ 1 │
│ 1 │ 2 │
│ 2 │ 3 │
│ 3 │ 4 │
│ 4 │ 5 │
│ 5 │ 6 │
╰───┴───╯
> [{a:1} {a:2}] | union [{a:2} {a:3}]
╭───┬───╮
│ # │ a │
├───┼───┤
│ 0 │ 1 │
│ 1 │ 2 │
│ 2 │ 3 │
╰───┴───╯

intersect: Returns a deduplicated list of unique elements present in both the input list and the given list.

> [1 2 3 4] | intersect [3 4 5 6]
╭───┬───╮
│ 0 │ 3 │
│ 1 │ 4 │
╰───┴───╯
> [1 2 3] | intersect [4 5 6]
╭────────────╮
│ empty list │
╰────────────╯

difference: Returns a deduplicated list of unique elements present in the input list but not in the given list.

> [1 2 3 4] | difference [3 4 5 6]
╭───┬───╮
│ 0 │ 1 │
│ 1 │ 2 │
╰───┴───╯
> [{a:1} {a:2} {a:3}] | difference [{a:2} {a:4}]
╭───┬───╮
│ # │ a │
├───┼───┤
│ 0 │ 1 │
│ 1 │ 3 │
╰───┴───╯

combinations: Generates all combinations of a given size k from the input list, streamed lazily via ListStream. If k > n, returns an empty list.

> [1 2 3] | combinations 2
╭───┬───────────╮
│ 0 │ ╭───┬───╮ │
│   │ │ 0 │ 1 │ │
│   │ │ 1 │ 2 │ │
│   │ ╰───┴───╯ │
│ 1 │ ╭───┬───╮ │
│   │ │ 0 │ 1 │ │
│   │ │ 1 │ 3 │ │
│   │ ╰───┴───╯ │
│ 2 │ ╭───┬───╮ │
│   │ │ 0 │ 2 │ │
│   │ │ 1 │ 3 │ │
│   │ ╰───┴───╯ │
╰───┴───────────╯
> [1 2] | combinations 3
╭────────────╮
│ empty list │
╰────────────╯

permutations: Generates all permutations of the input list using Heap's algorithm, streamed lazily via ListStream.

> [1 2 3] | permutations
╭───┬───────────╮
│ 0 │ ╭───┬───╮ │
│   │ │ 0 │ 1 │ │
│   │ │ 1 │ 2 │ │
│   │ │ 2 │ 3 │ │
│   │ ╰───┴───╯ │
│ 1 │ ╭───┬───╮ │
│   │ │ 0 │ 2 │ │
│   │ │ 1 │ 1 │ │
│   │ │ 2 │ 3 │ │
│   │ ╰───┴───╯ │
│ 2 │ ╭───┬───╮ │
│   │ │ 0 │ 3 │ │
│   │ │ 1 │ 1 │ │
│   │ │ 2 │ 2 │ │
│   │ ╰───┴───╯ │
│ 3 │ ╭───┬───╮ │
│   │ │ 0 │ 1 │ │
│   │ │ 1 │ 3 │ │
│   │ │ 2 │ 2 │ │
│   │ ╰───┴───╯ │
│ 4 │ ╭───┬───╮ │
│   │ │ 0 │ 2 │ │
│   │ │ 1 │ 3 │ │
│   │ │ 2 │ 1 │ │
│   │ ╰───┴───╯ │
│ 5 │ ╭───┬───╮ │
│   │ │ 0 │ 3 │ │
│   │ │ 1 │ 2 │ │
│   │ │ 2 │ 1 │ │
│   │ ╰───┴───╯ │
╰───┴───────────╯
> [1 2] | permutations
╭───┬───────────╮
│ 0 │ ╭───┬───╮ │
│   │ │ 0 │ 1 │ │
│   │ │ 1 │ 2 │ │
│   │ ╰───┴───╯ │
│ 1 │ ╭───┬───╮ │
│   │ │ 0 │ 2 │ │
│   │ │ 1 │ 1 │ │
│   │ ╰───┴───╯ │
╰───┴───────────╯

Added semantic version parsing and commands [toc]

PR #18473 by @fdncred

Nushell now understands and allows you to work with Semantic Versioning. All functionality works through idiomatic Nushell patterns:

> '1.2.3' | into semver
1.2.3
> {major: 1, minor: 2, patch: 3} | into semver
1.2.3
> {major: 1, minor: 2, patch: 3} | into semver | describe
semver

> '1.2.3-alpha.1+build.2' | into semver | into record
╭───────────────────┬───────────────╮
│ major             │ 1             │
│ minor             │ 2             │
│ patch             │ 3             │
│ pre               │ alpha.1       │
│ build             │ build.2       │
│                   │ ╭───┬───────╮ │
│ pre_identifiers   │ │ 0 │ alpha │ │
│                   │ │ 1 │     1 │ │
│                   │ ╰───┴───────╯ │
│                   │ ╭───┬───────╮ │
│ build_identifiers │ │ 0 │ build │ │
│                   │ │ 1 │     2 │ │
│                   │ ╰───┴───────╯ │
╰───────────────────┴───────────────╯

> {major: 1, minor: 2, patch: 3, pre: "alpha.1"} | into semver
1.2.3-alpha.1

> '1.2.3' | into semver | semver bump major
2.0.0
> '1.2.3' | into semver | semver bump minor
1.3.0
> '1.2.3' | into semver | semver bump patch
1.2.4
> '1.2.3' | into semver | semver bump alpha
1.2.3-alpha.1
> '1.2.3-alpha.1' | into semver | semver bump alpha
1.2.3-alpha.2
> '1.2.3-alpha' | into semver | semver bump release
1.2.3
> '1.2.3' | semver bump major
2.0.0
> '1.2.3' | semver bump minor
1.3.0

| '1.2.3' | semver bump
alpha               beta                major               minor
patch               rc                  release

> let v = '1.2.3' | into semver
| $v.
build               major               minor               patch
pre

> ['2.0.0', '1.0.0', '1.2.3'] | each { into semver } | sort
╭───┬───────╮
│ 0 │ 1.0.0 │
│ 1 │ 1.2.3 │
│ 2 │ 2.0.0 │
╰───┴───────╯
> ['2.0.0', '1.0.0', '1.2.3'] | each { into semver } | sort --reverse
╭───┬───────╮
│ 0 │ 2.0.0 │
│ 1 │ 1.2.3 │
│ 2 │ 1.0.0 │
╰───┴───────╯

> try { '1.2.3' | into semver } | is-not-empty
true
> try { 'not-valid' | into semver } | is-not-empty
false

> '1.2.3' | into semver | $in in ('>=1.0.0' | into semver-range)
true
> '1.0.0' | into semver | $in in ('>=2.0.0' | into semver-range)
false
> '1.3.0-alpha' | into semver | $in in ('>=1.2.3' | into semver-range)
false

> '>=1.0.0' | into semver-range
>=1.0.0
> '^1.2.3' | into semver-range
^1.2.3
> '~1.2' | into semver-range
~1.2

> let v = '1.2.3' | into semver
> $v | describe
semver
> $v | describe -d
╭───────────────┬───────────────────────────────────────────────────────────────────────╮
│ type          │ custom                                                                │
│ detailed_type │ semver                                                                │
│ subtype       │ semver                                                                │
│ rust_type     │ &alloc::boxed::Box<dyn nu_protocol::value::custom_value::CustomValue> │
│ value         │ 1.2.3                                                                 │
╰───────────────┴───────────────────────────────────────────────────────────────────────╯

> [
  [string, semver, semver-range];
  ['1.2.3', ('1.2.3' | into semver), ('>=1.0.0' | into semver-range)]
]
╭───┬────────┬────────┬──────────────╮
│ # │ string │ semver │ semver-range │
├───┼────────┼────────┼──────────────┤
│ 0 │ 1.2.3  │ 1.2.3  │ >=1.0.0      │
╰───┴────────┴────────┴──────────────╯

$env.config.color_config.semver = "cyan_bold"
$env.config.color_config.semver-range = "cyan_bold"

from xlsx/from ods gets a --prefer-integers flag [toc]

PR #18497 by @yertto

xlsx and ods files store numbers as floats by default, even if they are not display with decimal points.

from xlsx and from ods now has a --prefer-integers (-i) flag that imports whole-number floats as integers.

This has no effect on non-whole floats.

> open --raw tests/fixtures/formats/sample_data.xlsx
| from xlsx
| get SalesOrders
| first 5
╭───┬─────────────┬─────────┬─────────┬────────┬───────┬───────────┬────────╮
│ # │  OrderDate  │ Region  │   Rep   │  Item  │ Units │ Unit Cost │ Total  │
├───┼─────────────┼─────────┼─────────┼────────┼───────┼───────────┼────────┤
│ 0 │ 8 years ago │ East    │ Jones   │ Pencil │ 95.00 │      1.99 │ 189.05 │
│ 1 │ 8 years ago │ Central │ Kivell  │ Binder │ 50.00 │     19.99 │ 999.50 │
│ 2 │ 8 years ago │ Central │ Jardine │ Pencil │ 36.00 │      4.99 │ 179.64 │
│ 3 │ 8 years ago │ Central │ Gill    │ Pen    │ 27.00 │     19.99 │ 539.73 │
│ 4 │ 8 years ago │ West    │ Sorvino │ Pencil │ 56.00 │      2.99 │ 167.44 │
╰───┴─────────────┴─────────┴─────────┴────────┴───────┴───────────┴────────╯

> open --raw tests/fixtures/formats/sample_data.xlsx
| from xlsx --prefer-integers
| get SalesOrders
| first 5
╭───┬─────────────┬─────────┬─────────┬────────┬───────┬───────────┬────────╮
│ # │  OrderDate  │ Region  │   Rep   │  Item  │ Units │ Unit Cost │ Total  │
├───┼─────────────┼─────────┼─────────┼────────┼───────┼───────────┼────────┤
│ 0 │ 8 years ago │ East    │ Jones   │ Pencil │    95 │      1.99 │ 189.05 │
│ 1 │ 8 years ago │ Central │ Kivell  │ Binder │    50 │     19.99 │ 999.50 │
│ 2 │ 8 years ago │ Central │ Jardine │ Pencil │    36 │      4.99 │ 179.64 │
│ 3 │ 8 years ago │ Central │ Gill    │ Pen    │    27 │     19.99 │ 539.73 │
│ 4 │ 8 years ago │ West    │ Sorvino │ Pencil │    56 │      2.99 │ 167.44 │
╰───┴─────────────┴─────────┴─────────┴────────┴───────┴───────────┴────────╯

Other additions [toc]

• Added math cbrt (cube root) function. (#18473)
• append can now take multiple values to append as rest parameters (#18218)
• Improve LS_COLORS support to commandline complete --detailed. (#18325)
• The idx init command uses content indexing by default. (#18332)
• Improved hash md5 and hash sha256 help examples to show hashing binary data. (#18338)
• Added completions to ansi gradient's --fgnamed and --bgnamed flags. (#18342)
• nu-highlight now clears content_type metadata (#18266)
• Keybinding edit events now support reedline's verb-based edit commands (move, extend, cut, copy, change, erase) combined with a motion and its parameters, enabling vi-style operator/motion keybindings to be expressed directly in config. The new commands and their fields are discoverable via keybindings list. (#18396)
• The http commands now use the response body as error message when getting an error response. (#18387)
• If the NU_EXPERIMENTAL_OPTIONS environment variable is set, it will be used when running nushell with the --login or --execute flags since they also load config. (#18392)
• Refactor commands that use sqlite pushdown so that it's easier to add other pushdown filters. (#18398)
• Added common navigation shortcuts to explore config command: hl to collapse/expand, and jk/ctrl+p/n to go up and down. (#18440)
• For those debugging startup performance, we added a new --log-level called perf that shows performance information. (#18468)

Deprecations [toc]

Deprecate str upcase/str downcase and add str uppercase/str lowercase [toc]

PR #18364 by @Ashif-107

Added str uppercase command to convert text to uppercase (replaces str upcase) Added str lowercase command to convert text to lowercase (replaces str downcase) Deprecated str upcase, using it shows a warning recommending str uppercase. Deprecated str downcase, using it shows a warning recommending str lowercase.

Other deprecations [toc]

• Removed the deprecated use std/clip copy and paste commands, they are now called copy52 and paste52 for the ones that use the terminal OSC 52, or you can use clip copy and clip paste from the experimental option native-clip that access the system clipboard directly. (#18403)

Other changes [toc]

More idiomatic YAML output with smarter string quoting [toc]

PR #18298 by @fdncred

The previous emitter always quoted string values, which produced valid YAML but was more conservative than necessary and less aligned with YAML 1.2 plain-scalar rules.

This change makes output:

• more readable
• closer to idiomatic YAML
• more spec-aligned for plain scalars
• still safe for roundtripping by quoting values that would otherwise be reinterpreted as non-strings

Before:

value: 'off'
path: '/dev/stdout'
listen: '0.0.0.0:8444,0.0.0.0:8445 ssl'
name: 'kong'
kind: 'Deployment'

After:

value: 'off'
path: /dev/stdout
listen: 0.0.0.0:8444,0.0.0.0:8445 ssl
name: kong
kind: Deployment

Multiline strings now emit as:

string: |-
  Hello
  world

Width-priority columns [toc]

PR #17850 by @fdncred

Added support for column width-priority hints in table rendering. Values can now carry --table-width-priority-columns metadata so the table command gives selected columns more space when fitting output to the terminal width.

Providing the metadata will cause the table command to render the output differently

> ps -l | select name command pid | first 2 | table
╭───┬──────────────────────────────────┬───────────────────────────────────────────────────────────────────────────┬─────╮
│ # │               name               │                                  command                                  │ ... │
├───┼──────────────────────────────────┼───────────────────────────────────────────────────────────────────────────┼─────┤
│ 0 │ GameInputRedistService.exe       │ C:\Program Files\Microsoft GameInput\x64\GameInputRedistService.exe       │ ... │
│   │                                  │ /session=\\.\pipe\GameInputServiceSession-002fb4627cd24645-00000001       │     │
│ 1 │ nvcontainer.exe                  │ C:\Program Files\NVIDIA Corporation\NvContainer\nvcontainer.exe -f        │ ... │
│   │                                  │ C:\ProgramData\NVIDIA Corporation\NVIDIA                                  │     │
│   │                                  │ App\NvContainer\NvContainerUser%d.log -d C:\Program Files\NVIDIA          │     │
│   │                                  │ Corporation\NvContainer\plugins\User -r -l 3 -p 30000 -c                  │     │
╰───┴──────────────────────────────────┴───────────────────────────────────────────────────────────────────────────┴─────╯
> ps -l | select name command pid | first 2 | metadata set -w [pid] | table
╭───┬────────────────────────────┬───────────────────────────────────────────────────────────────────────────────┬───────╮
│ # │            name            │                                    command                                    │  pid  │
├───┼────────────────────────────┼───────────────────────────────────────────────────────────────────────────────┼───────┤
│ 0 │ GameInputRedistService.exe │ C:\Program Files\Microsoft GameInput\x64\GameInputRedistService.exe           │ 12744 │
│   │                            │ /session=\\.\pipe\GameInputServiceSession-002fb4627cd24645-00000001           │       │
│ 1 │ nvcontainer.exe            │ C:\Program Files\NVIDIA Corporation\NvContainer\nvcontainer.exe -f            │ 12792 │
│   │                            │ C:\ProgramData\NVIDIA Corporation\NVIDIA                                      │       │
│   │                            │ App\NvContainer\NvContainerUser%d.log -d C:\Program Files\NVIDIA              │       │
│   │                            │ Corporation\NvContainer\plugins\User -r -l 3 -p 30000 -c                      │       │
╰───┴────────────────────────────┴───────────────────────────────────────────────────────────────────────────────┴───────╯

Polars upgrade 0.54 [toc]

PR #18345 by @ayax79

• polar implode now supports the flag --maintain-order
• polars is-in now supports the flag --maintain-order
• polars pivot not supports the flag --always-combine-names
• polars replace requires a --default <value> parameter when used with --strict and --return-dtype if the dtype has changed from the original dtype

New experimental globbing engine [toc]

PR #18109 by @fdncred

This release introduces a new experimental feature named dc-glob (named for Devyn Cairn's glob). Currently nushell has two separate globbing engines with varying features and platform support.

This engine is intended to replace the existing globbing engines, and standardize on something that works well on all platforms. In addition, this globbing engine seems to perform faster than the existing engines.

Additional changes [toc]

• "Command not found" error messages will now suggest full command from a category if you type just its ending, for example sqrt will suggest math sqrt. (#18498)
• Fixed plugin list --help to show the correct output type and example for the commands column, which contains each plugin command's name and description. (#18357)
• Added some @attrs to the toolkit.nu commands so that they show up in category, search-terms, and examples. I also homogenized help casing and punctuation. (#18350)
• Added support for feature gating LSP functionality, specifically enable it via --features lsp. (#18148)
• Improved the MCP evaluate tool response: evaluation outputs NUON directly instead of wrapping everything as a string. Successful and error responses are also available as MCP structuredContent JSON for clients that support structured tool output. (#18499)
• http post/put/patch/delete now respects --content-type for JSON-variant MIME types like application/json-patch+json. (#18496)

Bug fixes [toc]

idx dependency update and command reliability improvements [toc]

PR #18284 by @fdncred

Update the idx fff-search dependency and fix bugs.

• idx init . --wait now properly blocks
• idx init now has a --follow-links switch
• idx status reports accurate counts after indexing
• idx import fully restores snapshot for queries — The idx import command now properly restores snapshots to enable all query operations. Imported snapshots remain queryable even if the original project files have been deleted or moved.
• idx files works on imported snapshots
• idx files has a query parameter now for easy searching (renamed from path for consistency)
• idx dirs works on imported snapshots
• idx dirs has a query parameter now for easy searching
• idx find (fuzzy search) works on imported snapshots
• idx search (content search) works on imported snapshots
• changed output to nushell values for commands that return tables
• updated some help strings to be more helpful

Files are ignored during indexing due to the use of the ignore crate. These are the rules for ignore https://docs.rs/ignore/latest/ignore/struct.WalkBuilder.html#ignore-rules. There's no way to override this in the current version.

Subcommand completions are now wrapped in quotes for which [toc]

PR #18295 by @Mrfiregem

Tab completions for which and attr complete/@complete commands will now properly quote command names containing spaces.

> which 'path par
> which path parse
╭───┬─────────┬──────┬──────────╮
│ # │ command │ path │   type   │
├───┼─────────┼──────┼──────────┤
│ 0 │ path    │      │ built-in │
│ 1 │ parse   │      │ built-in │
╰───┴─────────┴──────┴──────────╯

> which 'path par
> which "path parse"
╭───┬────────────┬──────┬──────────╮
│ # │  command   │ path │   type   │
├───┼────────────┼──────┼──────────┤
│ 0 │ path parse │      │ built-in │
╰───┴────────────┴──────┴──────────╯

Fix nested update closure for table columns [toc]

PR #18205 by @fdncred

This fixes a bug where update with a nested column path and closure (for example rss_item.pubDate) could evaluate the closure against a projected list and write the same result back to every row.

> {
  rss_item: [
    [pubDate];
    [1773429600],
    [1774325700],
    [1775448000]
  ]
} | update rss_item.pubDate { into datetime -f "%s" }
╭──────────┬──────────────────────────────╮
│          │ ╭───┬──────────────────────╮ │
│ rss_item │ │ # │       pubDate        │ │
│          │ ├───┼──────────────────────┤ │
│          │ │ 0 │ ╭───┬──────────────╮ │ │
│          │ │   │ │ 0 │ 3 months ago │ │ │
│          │ │   │ │ 1 │ 3 months ago │ │ │
│          │ │   │ │ 2 │ 2 months ago │ │ │
│          │ │   │ ╰───┴──────────────╯ │ │
│          │ │ 1 │ ╭───┬──────────────╮ │ │
│          │ │   │ │ 0 │ 3 months ago │ │ │
│          │ │   │ │ 1 │ 3 months ago │ │ │
│          │ │   │ │ 2 │ 2 months ago │ │ │
│          │ │   │ ╰───┴──────────────╯ │ │
│          │ │ 2 │ ╭───┬──────────────╮ │ │
│          │ │   │ │ 0 │ 3 months ago │ │ │
│          │ │   │ │ 1 │ 3 months ago │ │ │
│          │ │   │ │ 2 │ 2 months ago │ │ │
│          │ │   │ ╰───┴──────────────╯ │ │
│          │ ╰───┴──────────────────────╯ │
╰──────────┴──────────────────────────────╯

> {
  rss_item: [
    [pubDate];
    [1773429600],
    [1774325700],
    [1775448000]
  ]
} | update rss_item.pubDate { into datetime -f "%s" }
╭──────────┬──────────────────────╮
│          │ ╭───┬──────────────╮ │
│ rss_item │ │ # │   pubDate    │ │
│          │ ├───┼──────────────┤ │
│          │ │ 0 │ 3 months ago │ │
│          │ │ 1 │ 3 months ago │ │
│          │ │ 2 │ 2 months ago │ │
│          │ ╰───┴──────────────╯ │
╰──────────┴──────────────────────╯

> { w: { x: [ { y: "1" } { y: "2" } ] } }
| update w.x.y { into float }
| to yaml
w:
  x:
    - 'y':
        - 1.0
        - 2.0
    - 'y':
        - 1.0
        - 2.0

> { w: { x: [ { y: "1" } { y: "2" } ] } }
| update w.x.y { into float }
| to yaml
w:
  x:
    - 'y': 1.0
    - 'y': 2.0

> [ [[a]; [1] [2]] ]
| update a {into float}
| to yaml
-
  - a:
      - 1.0
      - 2.0
  - a:
      - 1.0
      - 2.0

> [ [[a]; [1] [2]] ]
| update a {into float}
| to yaml
-
  - a: 1.0
  - a: 2.0

Reduced escaping in nu-mcp evaluation output [toc]

PR #18260 by @fdncred

Reduce the amount of escaping that nu-mcp does by using raw-strings.

{
  "jsonrpc": "2.0",
  "id": 3,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{cwd:/Users/fdncred/src/nushell,history_index:0,timestamp:2026-05-21T15:10:18.619935+00:00,output:\"\\\"[\n  {\n    \\\\\\\"name\\\\\\\": \\\\\\\"assets\\\\\\\",\n    \\\\\\\"type\\\\\\\": \\\\\\\"dir\\\\\\\",\n    \\\\\\\"size\\\\\\\": 160,\n    \\\\\\\"modified\\\\\\\": \\\\\\\"2024-09-14T07:06:47.316979108-05:00\\\\\\\"\n  },\n  {\n    \\\\\\\"name\\\\\\\": \\\\\\\"ast-grep\\\\\\\",\n    \\\\\\\"type\\\\\\\": \\\\\\\"dir\\\\\\\",\n    \\\\\\\"size\\\\\\\": 160,\n    \\\\\\\"modified\\\\\\\": \\\\\\\"2026-01-07T06:22:12.488582817-06:00\\\\\\\"\n  },\n  {\n    \\\\\\\"name\\\\\\\": \\\\\\\"benches\\\\\\\",\n    \\\\\\\"type\\\\\\\": \\\\\\\"dir\\\\\\\",\n    \\\\\\\"size\\\\\\\": 128,\n    \\\\\\\"modified\\\\\\\": \\\\\\\"2026-05-21T08:31:29.486599444-05:00\\\\\\\"\n  }\n]\\\"\"}"
      }
    ],
    "isError": false
  }
}

{
  "jsonrpc": "2.0",
  "id": 3,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{cwd:/Users/fdncred/src/nushell,history_index:0,timestamp:2026-05-21T15:20:18.004016+00:00,output:r#'[\n  {\n    \"name\": \"assets\",\n    \"type\": \"dir\",\n    \"size\": 160,\n    \"modified\": \"2024-09-14T07:06:47.316979108-05:00\"\n  },\n  {\n    \"name\": \"ast-grep\",\n    \"type\": \"dir\",\n    \"size\": 160,\n    \"modified\": \"2026-01-07T06:22:12.488582817-06:00\"\n  },\n  {\n    \"name\": \"benches\",\n    \"type\": \"dir\",\n    \"size\": 128,\n    \"modified\": \"2026-05-21T08:31:29.486599444-05:00\"\n  }\n]'#}"
      }
    ],
    "isError": false
  }
}

Improved errors for negative indices in cell paths [toc]

PR #18282 by @guluo2016

Improved error messages when negative indices are used in cell paths.

Previously, negative indices could produce misleading "Row number too large" errors (e.g., [["foo", "bar"], ["foo", "baz"]] | get 0.-1) or generic "NeedsPositiveValue" errors (e.g., ["foo", "bar", "baz"] | get (-1)).

Now Nushell reports clear messages such as "negative index is not supported in cell path" or "can't convert negative number to cell path".

Correctly parse oneof with a closure without pipe [toc]

PR #17795 by @pickx

oneof<..., table>

In some specific cases the parser could reject values provided to oneof typed parameters, such as rejecting table literal syntax for oneof<.., table>:

> def cmd [--flag: oneof<record, table>] {}
> cmd --flag [[foo]; 1]
Error: nu::parser::parse_mismatch_with_full_string_msg

  × Parse mismatch during operation.
   ╭─[repl_entry #17:1:12]
 1 │ cmd --flag [[foo]; 1]
   ·            ─────┬────
   ·                 ╰── expected oneof<record, table>
   ╰────

The parser no longer considers such code invalid.

oneof<..., closure>

Arguments of type oneof<..., closure>, could only be parsed as closures if they had a parameter list ({|| }).

> def cmd [--flag: oneof<list, closure>] {}
> cmd --flag {|| ls }
> cmd --flag { ls }
Error: nu::parser::parse_mismatch_with_full_string_msg

  × Parse mismatch during operation.
   ╭─[repl_entry #21:1:12]
 1 │ cmd --flag { ls }
   ·            ───┬──
   ·               ╰── expected non-block value: oneof<list<any>, closure()>
   ╰────

The parser now accepts calls like cmd --flag { ls }

Fixed table alignment with header_on_separator [toc]

PR #18344 by @Bahex

Alignment issues in table when header_on_separator is on are fixed:

╭─#─┬─align──┬────val─────╮
│ 0 │ _      │ __________ │
│ 1 │ left   │ a          │
│ 2 │ right  │          0 │
│ 3 │ left   │          a │
│ 4 │ center │     ∅      │
│ 5 │ left   │     a      │
│ 6 │ center │     ∅      │
│ 7 │ right  │          0 │
╰───┴────────┴────────────╯

╭─#─┬─align──┬────val─────╮
│ 0 │ _      │ __________ │
│ 1 │ left   │ a          │
│ 2 │ right  │          0 │
│ 3 │ left   │ a          │
│ 4 │ center │     ∅      │
│ 5 │ left   │ a          │
│ 6 │ center │     ∅      │
│ 7 │ right  │          0 │
╰───┴────────┴────────────╯

Add --full-reparse/-f to run command [toc]

PR #18339 by @fdncred

The run command now supports --full-reparse/-f, making workflows like watch . -g *.nu | where path ends-with test.nu | each -f { run -f ./test.nu } work as expected. Running scripts repeatedly is also fixed: starting with nu -n, then running run toolkit.nu twice now works, whereas previously a caching bug prevented the same file from being run more than once.

Improved default steps for fractional float ranges [toc]

PR #18348 by @fdncred

Float ranges without an explicit step now use more natural fractional steps, so 0.1..0.3 yields 0.1, 0.2, 0.3 instead of just 0.1. This also means 0.1..0.3 | last now correctly returns 0.3. Float range values are now rounded to match the step's decimal precision, which removes floating-point display artifacts like 0.30000000000000004 from serialized output.

> 0.1..0.3 | last
0.1
> 0.1..0.3 | to json -r
[0.1]

> 0.1..0.3 | last
0.3
> 0.1..0.3 | to json -r
[0.1,0.2,0.3]
> 0.001..0.005 | to json -r
[0.001,0.002,0.003,0.004,0.005]
> 0.0..0.5 | to json -r
[0.0,0.1,0.2,0.3,0.4,0.5]

Fixed stor open return type [toc]

PR #18355 by @Bahex

stor open returns the custom value SQLiteDatabase, yet it's signature had sqlite-in-memory as the return type. This causes problems with the enforce-runtime-annotations experimental option:

> let db = stor open
Error: nu::shell::cant_convert

  × Can't convert to sqlite-in-memory.
   ╭─[repl_entry #2:1:10]
 1 │ let db = stor open
   ·          ────┬────
   ·              ╰── can't convert SQLiteDatabase to sqlite-in-memory
   ╰────

The return type has been corrected to SQLiteDatabase.

Improved module descriptions in completions and LSP hovers [toc]

PR #18343 by @Bahex

Descriptions of module completions for use were previously not formatted. Instead of what you would get from help modules ..., the descriptions were the modules' doc comment as it appeared in the file (# and leading indent not removed).

Before:

> use c
      ╭───────╮ ╭─────────────────────────────────────────────╮
      │clip   │ │# Commands for interacting with the system   │
      ╰───────╯ │clipboard # # > These commands require your  │
                │terminal to support OSC 52 # > Terminal      │
                │multiplexers such as screen, tmux, zellij etc│
                │may interfere with this command              │
                ╰─────────────────────────────────────────────╯

After:

> use c
      ╭───────╮ ╭────────────────────────────────────────╮
      │clip   │ │Commands for interacting with the system│
      ╰───────╯ │clipboard                               │
                ╰────────────────────────────────────────╯

Fix aliases breaking when variables used in them are shadowed [toc]

PR #18349 by @ayax79

Shadowing variables used in aliases could cause the alias to stop working:

> let x = 10
> alias xx = print $x
> xx
10
> let x = 20
> xx
Error: nu::shell::variable_not_found

  × Variable not found
   ╭─[repl_entry #32:1:18]
 1 │ alias xx = print $x
   ·                  ─┬
   ·                   ╰── variable not found
   ╰────

Now aliases continue working with the original value of the variable:

> let x = 10
> alias xx = print $x
> xx
10
> let x = 20
> xx
10

Fixed a bug in -- option parsing [toc]

PR #18408 by @fdncred

Fixed a bug with how -- was handled with --wrapped custom commands. Now you can do things like this:

> def --wrapped example [--my-flag: string ...rest] {
  let rest = $rest | skip 1  # skip the '--' delimiter
  $rest | each { {type: ($in | describe) value: $in} } | print
  print $"--my-flag='($my_flag)'"
}
> example --my-flag="hi" -- true false 001 --my-flag="goodbye"
╭───┬────────┬───────────────────╮
│ # │  type  │       value       │
├───┼────────┼───────────────────┤
│ 0 │ string │ true              │
│ 1 │ string │ false             │
│ 2 │ string │ 001               │
│ 3 │ string │ --my-flag=goodbye │
╰───┴────────┴───────────────────╯
--my-flag='hi'

Improved Ctrl-C handling in from json [toc]

PR #18414 by @fdncred

Ctrl+C is more responsive in from json, from kdl, and from xml now respond promptly to Ctrl+C when parsing large files. Pressing Ctrl+C during parsing will interrupt the command and return to the prompt. It will also produce better parse-error messages and should now show a focused snippet of the source around the error location instead of dumping the entire file content.

Improved conflicting column names in flatten [toc]

PR #18407 by @WindSoilder

This pr fixes flatten renaming column behavior

> [[b, a]; [[[a]; [9]], 1]]
| flatten -a b
╭───┬───╮
│ # │ a │
├───┼───┤
│ 0 │ 1 │
╰───┴───╯

> [[b, a]; [[[a]; [9]], 1]]
| flatten -a b
╭───┬─────┬───╮
│ # │ b_a │ a │
├───┼─────┼───┤
│ 0 │   9 │ 1 │
╰───┴─────┴───╯

Row-conditions should parse {} as closure, not record [toc]

PR #18438 by @Bahex

Empty braces ({}) as row conditions are now parsed as empty closures rather than empty records.

> 1..3 | where {}
Error: nu::parser::type_mismatch

  × Type mismatch.
   ╭─[repl_entry #39:1:14]
 1 │ 1..3 | where {}
   ·              ─┬
   ·               ╰── expected bool, found record
   ╰────

> 1..3 | where {}
╭────────────╮
│ empty list │
╰────────────╯

Improved special-character handling in idx search [toc]

PR #18447 by @fdncred

Allow idx search 'Lyrics[' to work by taking [ literally instead of assuming it's a glob. Also added a couple examples explaining how idx search should work.

idx search 'arr[0]'

idx search pattern */tests/*

idx search pattern *.{rs,js}

Fixed table mode handling from CLI arguments [toc]

PR #18446 by @fdncred

Respect the table mode when passed in on the cli when running script so you can do things like this.

> '1..3 | each { { number: $in, comment: "hello" } }' | save script.nu
> nu -m "none" script.nu
 #   number   comment
 0        1   hello
 1        2   hello
 2        3   hello

Improved input list streaming and rendering [toc]

PR #18462 by @jlcrochet

input list no longer waits for streamed input to be fully collected before showing the first paint. It now stays responsive while items stream in and shows a live-updating count of collected items in the footer. In table mode, header cells now expand properly along with their columns when scrolling through the list, and control characters like tabs no longer throw off UI alignment during rendering.

Fixed nu --plugins handling [toc]

PR #18500 by @fdncred

The nushell cli parsing now supports the --plugins parameter in these variations

nu --plugins /path/to/nu_plugin_one --plugins /path/to/nu_plugin_two  # multiple --plugins params
nu --plugins '[/path/to/nu_plugin_one, /path/to/nu_plugin_two]'  # comma separation
nu --plugins '[/path/to/nu_plugin_one /path/to/nu_plugin_two]'  # no comma separation
nu --plugins '["/path/to plugin/nu_plugin_one", "/path/to plugin/nu_plugin_two"]'  # quoted paths, with or without commas

Other fixes [toc]

• Fixed a regression where commandline edit did not update the commandline in REPL on 0.113.0. commandline edit now correctly updates the visible prompt buffer again. (#18301)
• • Fixed an issue where math abs would crash Nushell when given the minimum 64-bit integer or duration; it now reports an overflow error instead. (#18275)
• bytes index-of doesn't panic on empty patterns anymore (#18254)
• When using explore config if you supply --output <file> when you're editing the config i.e. not using explore config in json mode, it will fail fast and let you know that isn't possible instead of you finding that out later. (#18327)
• Fix Nix package evaluation for building from flake. (#18330)
• Now, when you pass an interpolated string (e. g. $"($env.pwd)/foo", ~/($bar)) to a flag or argument of type glob they will be converted automatically just like with regular strings instead of throwing a type error. (#18263)
• Fixed an issue where lines failed on input containing invalid UTF-8. By default, lines now replaces invalid UTF-8 bytes and continues processing, and lines --strict can be used to fail on invalid UTF-8. (#18261)
• Fixed input list --fuzzy truncating ANSI-styled options too early because formatting escape sequences were counted as visible width. (#18340)
• Fixed an issue where uniq-by silently collapsed every value into a single row when given a list whose elements are not records/tables. uniq-by now reports an error in that case (e.g. [1 2 2] | uniq-by foo), and it also reports a missing column when any record in the input lacks the requested column, not just the first one. (#18309)
• bits shl and bits shr now default to an 8-byte word size when --number-bytes is not provided, so shifts such as 1 | bits shl 20 no longer fail because the input was auto-sized to one byte. (#18277)
• Fixed a regression where lists like [.foons] will cause parser error. (#18363)
• Works better with Windows now for things like glob c:\apps\*. (#18367)
• Fixed a regression where all custom commands with --wrapped where numbers and strings passed to externals as glob now everything is passed as string or glob or creates an error. (#18372)
• While using experimental option dc-glob, glob expands ~ as expected now. (#18373)
• Fixes a bug where glob .cargo/bin/nu* nor %ls .cargo/bin/nu* wouldn't work. (#18375)
• Fix a breaking change that allows glob to still work in case-insensitive mode when using the --ignore-case/-i when using the dc-glob experimental-option. (#18376)
• glob with dc-glob = true now emits absolute paths when absolute patterns are used. The simple example was doing glob ~/.cargo/bin/nu* from within ~/Downloads and making sure the results start with /Users/<username>/.cargo/bin/nu. Previously they incorrectly started with /Users/<username>/Downloads/nu* which was completely wrong. Thanks @Tyarel8 ! (#18378)
• Fix a bug with dcglob fixing a problem with rm. (#18391)
• All commands that can accept a polars expression can now accept a polars selector as input (#18394)
• Fixed a bug of AST flattening where leading pipe characters in a block may lead to wrong reedline renderings. (#18386)
• Small improvement in token-efficiency for the nu --mcp agent tool instructions. (#18413)
• • Fixed a panic in str index-of --grapheme-clusters when the search string matched inside a multi–code-point grapheme cluster (flag emoji, ZWJ sequence, skin-tone modifier, or combining mark); it now returns -1. (#18418)
• Typing exit in the repl will no longer use a different logic and will call the exit command normally. Furthermore, any invocation of exit (e.g. inside a keybind of custom command) will restore the terminal cursor to the state it was before rather than only in the aforementioned case. (#18389)
• Don't SIGABRT when closing your terminal or using nu as an MCP server. (#18428)
• Fixed an issue where inserting or upserting into a nested cell path of an empty list, such as [] | insert 0.0 1, produced a confusing error mentioning 18446744073709551615. It now reports a clear "Row number too large (empty content)" error. (#18463)
• • Fixed a compiler error (register_uninitialized) when the right-hand side of an and/or/comparison collects $in, for example ... | where $in.x > 0 and not ($in.x > 5). (#18465)
• nu --log-include or --log-exclude now accept module or target name correctly. Previously it accepted log level instead. (#18464)
• Fixed an issue where math avg, math sum, and other math commands on tables produced a generic "Unable to give a result with this input" error instead of the real underlying error. List and table inputs now produce consistent error messages. (#18480)
• help aliases now correctly shows the alias name (not the target command name) for aliases to internal commands. (#18483)

Hall of fame [toc]

Thanks to all the contributors below for helping us solve issues, improve documentation, refactor code, and more! 🙏

Full changelog [toc]