Nushell 0.114.1

Today, we're releasing version 0.114.1 of Nu. This patch release fixes issues found after enforce-runtime-annotations became opt-out in the last version, improving runtime type checks and error reporting.

Where to get it

Nu 0.114.1 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.

Highlights and themes of this release

Follow-up fixes for runtime annotation checks

In Nushell 0.114.0, we promoted enforce-runtime-annotations from an opt-in experimental option to an opt-out experimental option. That is the usual path for experimental options: more people try them, we get better feedback, and the feature gets closer to being stable.

As expected, that wider testing found some rough edges. Some came from invalid signatures, some from type checks that were too strict, and some from checks that were simply not accurate enough. We are tracking those reports in issue #18528, and this patch release fixes a number of them, mostly thanks to @Bahex. Thank you!

More issues may still turn up. Please report them if you run into anything suspicious. If enforce-runtime-annotations blocks your workflow, you can disable just that option before Nushell starts:

NU_EXPERIMENTAL_OPTIONS=enforce-runtime-annotations=false nu

Or pass it as a command-line flag:

nu --experimental-options enforce-runtime-annotations=false

See the nu-experimental user documentation for more details.

We still encourage everyone to keep as many experimental options enabled as possible. It helps us find bugs earlier and make Nushell better for future releases.

Changes

Bug fixes

More helpful errors for failed assignments with enforce-runtime-annotations

With enforce-runtime-annotations enabled, assignments with incorrect types raise errors.

Previously this error was nu::shell::cant_convert originally used for unsuccessful type coercions of command arguments. Unfortunately, this error only pointed at the assigned values origin and not at the failed assignment.

This error has been switched to nu::shell::type_mismatch and now points to the failed assignment in addition to the value's origin.

Example 1

mut execution_time = -1
$execution_time = $env.CMD_DURATION_MS

Error: nu::shell::cant_convert

  × Can't convert to int.
   ╭─[Host Environment Variables:1:1]
 1 │ "ALLUSERSPROFILE"="C:\\ProgramData"
   · ▲
   · ╰── can't convert string to int
 2 │ "ANDROID_AVD_HOME"="B:\\AndroidAVDs"
   ╰────

Error: nu::shell::type_mismatch

  × Type mismatch.
   ╭─[repl_entry #3:1:17]
 1 │ $execution_time = $env.CMD_DURATION_MS
   ·                 ┬
   ·                 ╰── expected int, got string
   ╰────

Example 2

# delibarete type erasure
# we need to bypass parse-time
# type checking for this example
let stuff: any = {
	foo: "bar"
}

mut x = 1

$x = $stuff.foo

Error: nu::shell::cant_convert

  × Can't convert to int.
   ╭─[repl_entry #5:1:24]
 1 │ let stuff: any = {foo: "bar"}
   ·                        ──┬──
   ·                          ╰── can't convert string to int
   ╰────

Error: nu::shell::type_mismatch

  × Type mismatch.
   ╭─[repl_entry #5:1:24]
 1 │ let stuff: any = {foo: "bar"}
   ·                        ──┬──
   ·                          ╰── the value is a string
   ╰────
   ╭─[repl_entry #7:1:4]
 1 │ $x = $stuff.foo
   ·    ┬
   ·    ╰── expected int, got string
   ╰────

Closure's input type is not inherited from the surrounding scope

With last release, pipeline input type and how it affects various expressions are being tracked in a lot more cases.

In fact, at least one too many:

def mk-add-suffix [suffix: string]: nothing -> closure {
	{|| $in ++ $suffix }
}

Error: nu::parser::operator_unsupported_type

  × The '++' operator does not work on values of type 'nothing'.
   ╭─[repl_entry #8:2:5]
 1 │ def mk-add-suffix [suffix: string]: nothing -> closure {
 2 │ {|| $in ++ $suffix }}
   ·     ─┬─ ─┬
   ·      │   ╰── does not support 'nothing'
   ·      ╰── nothing
   ╰────

This is now fixed, and closures' input type will be inferred as any, the way it was before 0.114.0.

Add list input type to more date commands

Allow more date commands to have a list as input -> output. These are the commands that were updated:

• date humanize
• date from-human
• date to-timezone
• format date
• into datetime

Other fixes

• Fixed input listen's output type signature to match actual returned value. With the incorrect signature (and enforce-runtime-annotations on) let x = input listen would raise an error due to $x's inferred type (based on input listen's signature) not matching the value assigned to it.
• Type checking treats table and list<record> as compatible (provided the columns aren't disjoint), but that did not extend to list<oneof<record, ...>>. This has been fixed.
• Runtime type checking of non-stream pipeline data is now more accurate.
• Fixed uname's output type signature to match its actual output. Previously it was table, now it's record<...> and also includes its columns.
• Fixed an issue where run script.nu --some-flag could bind the value to the wrong flag of the script's main when main declared multiple flags, causing shifted positional arguments or a value being accepted into a flag of the wrong type. Flags passed to run are now matched to main parameters by name. (#18533)
• Fixed an incorrect idx search --help example. (#18550)
• Type checking of lists are relaxed. (#18555)
• Fixed an issue in for loops where type of the looping variable was inferred incorrectly when iterating over a value/stream with a union type (oneof<list, table, binary>). This could manifest as a runtime type checking error with enforce-runtime-annotations enabled. (#18551)

Hall of fame

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

| author | change | link | |

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.

Highlights and themes of this release

The type checker got new glasses

@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"

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

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

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

Breaking changes

Submodules are no longer implicitly imported

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 module's 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

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 for oneof types

Nushell as a 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 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 a parse-time error.

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

But previously, despite oneof<int, nothing> being more specific than any, it 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

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

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

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, the 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 the 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

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 on 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

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

In the last release, the 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 the grid command are 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

• 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 its 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

• 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

KDL format support

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

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

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

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

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

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

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

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

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

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

• 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

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

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

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

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

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

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

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

• 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

Deprecate str upcase/str downcase and add str uppercase/str lowercase

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

• 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

More idiomatic YAML output with smarter string quoting

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

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

• polar implode now supports the flag --maintain-order
• polars is-in now supports the flag --maintain-order
• polars pivot now 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

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

• "Command not found" error messages will now suggest the 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)
• http post/put/patch/delete now respects --content-type for JSON-variant MIME types like application/json-patch+json. (#18496)

Bug fixes

idx dependency update and command reliability improvements

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

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

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

Structured nu-mcp evaluation output

The MCP evaluate tool keeps evaluated Nushell values structured in output, so output data is fully unescaped instead of a wrapped string. Successful and error responses are also mirrored as MCP structuredContent JSON for clients that support structured tool output.

{
  "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-06-30T06:52:27.000000+00:00,output:{a:1,b:[2,3]}}"
      }
    ],
    "structuredContent": {
      "cwd": "/Users/fdncred/src/nushell",
      "history_index": 0,
      "timestamp": "2026-06-30T06:52:27.000000+00:00",
      "output": {
        "a": 1,
        "b": [2, 3]
      }
    },
    "isError": false
  }
}

Improved errors for negative indices in cell paths

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

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

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

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

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

stor open returns the custom value SQLiteDatabase, yet its 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

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

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

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

Ctrl+C is more responsive in from json, from kdl, and from xml. They 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

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

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

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

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

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

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

• 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

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

| author | change | link | |

Nushell

• @cptpiepmatz:

  • serialized CellPath via string representation (#18434)

• @Bahex:

  • refactored the parser to consolidate spread operator checking logic (#18422)
  • refactored type checking code (#18393)
  • added non UTF-8 text support for url encode/url decode (#18314)

• @leeewee:

  • fixed str index-of --grapheme-clusters panic on a sub-grapheme needle (#18418)

• @fdncred:

  • allowed ctrl+c to work better on from json (#18414)
  • added new random pass command (#18410)
  • fixed a bug in the end-of-options functionality (#18408)
  • reverted "pin ratatui-widgets to 0.3.0 to prevent need for --locked" (#18397)
  • pinned ratatui-widgets to 0.3.0 to prevent need for --locked (#18395)

• @Alb-O:

  • saved ~100 tokens in evaluate_tool.md instructions (#18413)

• @WindSoilder:

  • fixed flatten not renaming for later parent conflicting columns (#18407)

• @kronberger-droid:

  • added support for reedline menu input/output modes and list description position (#18404)
  • added support for reedline's verb-based edit commands in keybindings (Reedlines #1100) (#18396)

• @Tyarel8:

  • deleted deprecated stdlib copy and paste (#18403)
  • also used experimental_options env variable when loading config (#18392)
  • refactored exit logic (#18389)

• @madjar:

  • used the response body for the error message (#18387)

• @blindFS:

  • fixed leading pipe character in a pipeline (#18386)

• @app/dependabot:

  • bumped bytesize from 2.3.1 to 2.4.0 (#18421)
  • bumped itertools from 0.14.0 to 0.15.0 (#18420)
  • bumped sysinfo from 0.38.4 to 0.39.3 (#18380)

Documentation

• @casedami:

  • added abbreviations section to reedline (#2182)

• @NotTheDr01ds:

  • TWiN 355 (#2181)

• @ethan-hawksley:

  • fixed a handful of grammar errors and typos (#2180)

Awesome Nu

• @lassoColombo:
  • added nu-http-client-generator and nu-http-client-collection (#166)

reedline

• @blindFS:

  • fixed tmux history dedup (#1105)

• @stormasm:

  • removed old JT links that are no longer live or available (#1104)

• @kronberger-droid:

  • fixed vi mode to complete pending key sequence before custom keybindings (#1103)
  • fixed vi mode to stop dot-repeat recording itself (#1102)

• @philocalyst:

  • added non-blocking completions in reedline (#1093)

• @ymcx:

  • restored "Fix move to line start in multi-line history entries" (#1078)

Nu_Scripts

• @VioletsOleander:
  • fixed support for git add completion for file name that contains whitespace (#1259)

Nushell

• @ayax79:

  • allowed polars selectors as input for all commands that accept expressions as input (#18394)
  • introduced Polars bitwise commands (#18383)
  • fixed overshadowing breaking aliases (#18349)
  • upgraded Polars to 0.54 (#18345)

• @fdncred:

  • fixed a problem with glob and rm (#18391)
  • refactored parser from one big file to smaller files (#18388)
  • fixed dc-glob issue with using relative paths vs absolute (#18378)
  • added case-insensitivity to dc-glob and glob command to avoid breaking changes (#18376)
  • fixed a bug with dc-glob and /some/path/wildcard* (#18375)
  • allowed dc-glob to expand tilde (#18373)
  • updated custom command --wrapped to not always convert to glob (#18372)
  • allowed --context to be one of int or range (#18368)
  • patched windows globbing in the wrong place (#18367)
  • added context for the idx search command (#18366)
  • fixed input/output and example for plugin list (#18357)
  • added category, search-terms, examples to toolkit.nu (#18350)
  • handled float ranges better (#18348)

• @casedami:

  • fixed: use new highlighter api for better abbr expansion (#18390)

• @cptpiepmatz:

  • made Debug for Value more compact by default (#18377)
  • exposed NuTester internals (#18371)
  • made nu-test-support compile without os feature (#18361)

• @Ashif-107:

  • deprecated str upcase/str downcase and added str uppercase/str lowercase (#18364)

• @blindFS:

  • fixed(parser): a regression of parse_unit_value where [.foons] not return early (#18363)

• @Bahex:

  • fixed stor return type (#18355)
  • fixed(use): module descriptions should be properly formatted (#18343)

• @zelshahawy:

  • fixed typos in developer docs (#18354)

• @app/dependabot:

  • bumped kdl from 6.5.0 to 6.7.1 (#18382)
  • bumped mq-markdown from 0.5.26 to 0.6.0 (#18381)
  • bumped crate-ci/typos from 1.47.1 to 1.47.2 (#18379)
  • bumped crate-ci/typos from 1.46.3 to 1.47.1 (#18336)

reedline

• @kronberger-droid:

  • fixed(editor): made horizontal grapheme motion line-aware via rest policy (#1101)
  • refactored(editor): unified motions on a verb + target vocabulary (#1100)
  • tests(painter): added wrapper enum to allow tests to write to sink (#1098)

• @Alb-O:

  • fixed(painting): preserved leading CRLF in no-color rendering (#1097)

• @casedami:

  • refactored: abbreviation expansion trait logic (#1094)

• @reubeno:

  • perf: minimized cursor::position queries (#1090)

• @a-rookie-of-C-language:

  • feat(list_menu): added DescriptionPosition to control description place… (#1044)

Documentation

• @guluo2016:

  • updated plugin list docs: replaced is_running with status field (#2179)

• @NotTheDr01ds:

  • TWiN 354 (#2178)

Nushell

• @Bahex:

  • fixed(table): alignments of expand and header_on_separator (#18344)
  • feat(ansi gradient): added completions for named gradients (#18342)
  • refactored: get_locale_from_env_vars in nu-utils (#18313)
  • consolidated column handling: record & table; SyntaxShape & Type (#18308)
  • made submodules no longer implicitly imported (#18303)

• @puneetdixit200:

  • fixed ANSI-aware truncation in input list (#18310) (#18340)

• @fdncred:

  • added --full-reparse/-f to run command (#18339)
  • chore: updated Rust version to 1.94.1 in Cargo.toml and rust-toolchain.toml (#18335)
  • prevented --output from being used in config_mode in explore config command (#18327)
  • bumped uu_* deps to 0.9.0 (#18322)
  • updated ignore to really ignore 😃 (#18306)
  • updated REPL loop to synchronize cursor position and buffer contents (#18301)
  • implemented POSIX Guideline 10 -- end-of-options delimiter (#18299)

• @LeonidasZhak:

  • docs: added binary data examples to hash md5/sha256 (#18338)

• @dmtrKovalenko:

  • chore: upgraded to fff 0.9 and reenabled watcher (#18332)

• @Mrfiregem:

  • fixed simple Clippy error (#18331)
  • fix(completions): subcommand completions are now wrapped in quotes for which (#18295)

• @ian-h-chamberlain:

  • fixed nix flake build (rust toolchain + workspace package version) (#18330)
  • nu_style: supported fixed color lookups (#18325)

• @zhiburt:

  • bumped tabled to 0.21 (#18320)

• @stormasm:

  • removed warning on PipelineMetadata (#18317)

• @ayax79:

  • introduced polars map-batches (#18312)

• @cptpiepmatz:

  • fixed packaging (#18311)
  • bumped to 0.113.1 (#18307)
  • bumped to dev version (#18274)

• @hustcer:

  • chore: fixed nightly release workflow & upgraded Nu for workflows (#18304)

• @sholderbach:

  • chore: omitted some unnecessary allocations from the parser (#18285)

• @guluo2016:

  • fixed inaccurate error message when using negative index in cell path (#18282)

• @cho-minsung:

  • fix(math abs): returned overflow error instead of panicking on i64::MIN (#18275)

• @app/dependabot:

  • build(deps): bumped crate-ci/typos from 1.46.2 to 1.46.3 (#18294)

reedline

• @kronberger-droid:

  • refactor(completer)!: no longer require Send on the Completer trait (#1092)
  • test(vi): expanded parse_event coverage as refactor safety net (#1091)
  • added InputMode / OutputMode enums for menu settings (#1071)

• @skull-squadron:

  • fixed default prompt path (#929)

Nu_Scripts

• @kaascevich:

  • added swift-bundler completion script (#1258)

• @Hentioe:

  • git-completions: added more short options (#1257)

Documentation

• @cptpiepmatz:

  • release notes for v0.113.1 (#2177)

• @NotTheDr01ds:

  • TWiN 353 (#2176)

• @samoylovfp:

  • documented the percent sigil (#2167)

Where to get it

Nu 0.113.1 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.

Changes

Other changes

More idiomatic YAML output with smarter string quoting

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

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

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

string: |-
  Hello
  world

Bug fixes

idx dependency update and command reliability improvements

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. There's no way to override this in the current version.

Other fixes

• 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)

Hall of fame

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

| author | change | link | |

An as-expected slower-than-usual week due to 0.113's release (Yay!). That said, your future reedline prompts may be slightly less boxy, and definitely more brackety, in the future with @speicherwerk's > change in Reedline #1043.

And a random shout-out to @Kissaki - Thank you for your continued improvements to Nushell and our Documentation!

And as always, thank you to all our Nushell contributors, whether first-timers or Nushell greybeards, young or old, human or dependabot.

Nushell

• @fdncred:

  • refactored YAML handling to improve quoting logic and add support for multiline strings (#18298)
  • updated to 0.8.4, added follow-symlinks, fixed idx family bugs (#18284)

• @Bahex:

  • consolidated version and other metadata in top level Cargo.toml (#18286)
  • made peek return the actual type of values (#18268)

• @cptpiepmatz:

  • prepared release (#18273)
  • fixed some build issues (#18270)

reedline

• @kronberger-droid:

  • added selection styling example (#1088)

• @Juhan280:

  • removed deprecated functions and Display impl (#1086)

• @cptpiepmatz:

  • bumped minor version (#1085)

• @speicherwerk:

  • updated default prompt to use > character (#1043)

Documentation

• @Kissaki:

  • fixed fileop anchor links (#2174)

• @cptpiepmatz:

  • added release notes for v0.113.0 (#2173)

• @fdncred:

  • reverted "support extracting nu code snippets into standalone .nu files for better downstream trackability" (#2171)

• @NotTheDr01ds:

  • published TWiN 352 (#2170)

• @hustcer:

  • refreshed command docs for v0.113 (#2168)

• @app/dependabot:

  • bumped tmp from 0.2.5 to 0.2.7 (#2175)

VSCode Extension

• @mst-mkt:
  • fixed syntax highlighting broken for record keys containing brackets (#232)

Nu_Scripts

• @Tyarel8:

  • refactored output handling of task log in task.nu (#1256)

• @hhfgy1:

  • fixed scoop to handle non-UTF-8 encoding in scoop list output (#1255)

nufmt

• @fdncred:
  • fixed side-comments, added tabs or spaces functionality (#197)

Where to get it

Nu 0.113.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.

Highlights and themes of this release

Fast file search with idx

@fdncred introduced a new idx command family for in-memory indexing and search. It gives you fast file and directory lookup (idx files, idx dirs, idx find) and even content search (idx search) without having to rescan every time.

You can also export and import snapshots, which is especially handy when you want to persist an index and restore it later.

idx init . --wait
idx find config --files
idx search --regex 'def\s+main'

Take a look at all the commands here.

Stream detective mode: peek

Working with streams is one of Nushell's superpowers, and now you can inspect them without forcing a collect. The new peek command from @Bahex exposes metadata and sample values so you can make smarter pipeline decisions while keeping stream behavior intact.

.. | peek 1 | metadata access {|md|
    if $md.peek.stream {
        # keep streaming
    } else {
        $in
    }
}

See the detailed examples here.

Verbose file operations now return tables

Verbose filesystem commands are now much easier to script against, with improvements from @WindSoilder. Instead of only human-readable text, mkdir -v, mv -v, and rm -v now return structured table data you can filter, transform, and report on directly.

mkdir -v foo bar | where created == true
mv -v before.txt after.txt | get 0.message
rm -v missing.txt existing.txt | where deleted == false

Read more about mkdir/mv here and rm here.

Markdown, now with less AST noise

With work by @fdncred, from md now defaults to a more concise, human-friendly output mode, which makes it much nicer for day-to-day markdown processing. The previous full AST-style output is still available when you need deep detail via --verbose.

If you've been experimenting with markdown parsing since the last release, this should feel a lot more ergonomic out of the box.

Read more here.

Changes

Breaking changes

Updated kill signal shorthand handling

Allow kill -0 to show an error instead of killing nushell. Disallow commands like kill -9 pid because syntax should be kill -s 9 pid.

> kill -0
Error: nu::shell::incorrect_value

  × Incorrect value.
   ╭─[repl_entry #2:1:1]
 1 │ kill -0
   · ──┬─ ─┬
   ·   │   ╰── negative pid shorthand is not supported; use `kill -s 0 <pid>`
   ·   ╰── encountered here
   ╰────

Removed implicit line splitting of byte streams in parse

parse command, when receiving byte or string stream input (i.e. from an external process or file), used to implicitly split the input into lines. With this release it will collect such streams before processing them.

While the line-by-line behavior is closer to how tools like sed, grep and awk operate, it was confusing as parse worked differently between working with a string stream input and working with a string value input.

1. one
2. two and
   a half
3. three
4. four and
   some more

open file.txt
| parse -r r#'(?ms)^(?<n>\d+)\. (?<text>.*?)(?=$\s^\d|\Z)'#

╭───┬───┬──────────╮
│ # │ n │   text   │
├───┼───┼──────────┤
│ 0 │ 1 │ one      │
│ 1 │ 2 │ two and  │
│ 2 │ 3 │ three    │
│ 3 │ 4 │ four and │
╰───┴───┴──────────╯

╭───┬───┬──────────────╮
│ # │ n │     text     │
├───┼───┼──────────────┤
│ 0 │ 1 │ one          │
│ 1 │ 2 │ two and      │
│   │   │    a half    │
│ 2 │ 3 │ three        │
│ 3 │ 4 │ four and     │
│   │   │    some more │
╰───┴───┴──────────────╯

To process the input line-by-line all you need to do is run the stream through lines:

.. | lines | parse -r '...'

mkdir -v now returns a table

Previously mkdir -v returned a string, now it returns a table.

> let x = mkdir -v foo bar
mkdir: created directory '/tmp/foo'
mkdir: created directory '/tmp/bar'
> $x
foo bar

> let x = mkdir -v foo bar
> $x
╭───┬──────────┬─────────┬───────╮
│ # │   path   │ created │ error │
├───┼──────────┼─────────┼───────┤
│ 0 │ /tmp/foo │ true    │       │
│ 1 │ /tmp/bar │ true    │       │
╰───┴──────────┴─────────┴───────╯

> touch before.txt
> mv -v before.txt after.txt
╭───┬─────────────────┬────────────────┬────────────────────╮
│ # │     source      │  destination   │      message       │
├───┼─────────────────┼────────────────┼────────────────────┤
│ 0 │ /tmp/before.txt │ /tmp/after.txt │ mv-verbose-renamed │
╰───┴─────────────────┴────────────────┴────────────────────╯

Other breaking changes

• from xlsx now supports --header-row for specifying the 0-indexed index of the row from which to read column names. Default is the first non-empty row, which is a breaking change. Specify --header-row null for legacy behavior (i.e., no header). (#18189)

Additions

Preserve TOML comments when saving files

TOML files now preserve comments, formatting, and inline tables when modified and saved.

open Cargo.toml
| update version "1.1.0"
| save Cargo.toml

This should keep all comments intact.

Enhance ansi gradient command with named gradients and improved options

You can now use named gradients with ansi gradient.

> 'Nushell Gradient!' | ansi gradient --fgnamed rainbow
Nushell Gradient!

> ansi gradient --list
╭────┬───────────┬──────────────────╮
│  # │   name    │       text       │
├────┼───────────┼──────────────────┤
│  0 │ atlast    │ Nushell Gradient │
│  1 │ crystal   │ Nushell Gradient │
│  2 │ teen      │ Nushell Gradient │
│  3 │ mind      │ Nushell Gradient │
│  4 │ morning   │ Nushell Gradient │
│  5 │ vice      │ Nushell Gradient │
│  6 │ passion   │ Nushell Gradient │
│  7 │ fruit     │ Nushell Gradient │
│  8 │ retro     │ Nushell Gradient │
│  9 │ summer    │ Nushell Gradient │
│ 10 │ rainbow   │ Nushell Gradient │
│ 11 │ pastel    │ Nushell Gradient │
│ 12 │ monsoon   │ Nushell Gradient │
│ 13 │ forest    │ Nushell Gradient │
│ 14 │ instagram │ Nushell Gradient │
╰────┴───────────┴──────────────────╯

New commands for vi normal mode

Added two new commands to the vi normal modes:

• o: inserts a newline below the cursor and enters insert mode
• O: inserts a newline above the cursor and enters insert mode

Their respective edit commands are InsertNewlineBelow and InsertNewlineAbove.

Terminal emulator progress bars via std-rfc/pb

Added a new module to std-rfc/pb, it wraps the OSC 9;4 escape sequences for setting progress bars in the terminal (some terminals don't support any/some of the commands).

Example:

use std-rfc/pb

try {
	0..<10 | each {|x| sleep 200ms ; pb set-idx $x 10 }
} catch {
	pb error
} finally {
	pb clear
}