Nushell 0.108.0

Today, we're releasing version 0.108.0 of Nu. This release adds an optional MCP server for AI agents, new experimental options (pipefail and enforce-runtime-annotations), smarter completions with per-command completers, clearer errors and better streaming behavior, reorder-cell-paths enabled by default, and stronger CustomValue support.

Where to get it

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

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

Table of contents

• Highlights and themes of this release
  • Let AI agents use Nushell commands
  • More cool experiments
  • Tab, tab, tab... Aha!
  • Fish out error sources
  • Smarter CustomValues
• Changes
  • Breaking changes
    • into value is now detect type, and into value now converts custom values to plain values
    • Collecting a stream that contains errors now raises an error itself
    • Errors raised in nested each calls preserve their context
    • Changes to EditCommands
    • Vi Mode Text Objects
    • Other breaking changes
  • Additions
    • Promoted reorder-cell-paths to opt-out
    • Pipefail
    • Enforce Assignment Type Annotations at Runtime
    • --endian flag for format bits
    • Guess no more! More completions in built-in commands
    • Simple syntax for simple completions
    • Command-wide completion handler
    • for loops no longer collect their source
    • Streams of Streams
    • Arbitrary Pipeline Metadata
    • HTTP Response Metadata
    • Add $nu.is-lsp to help with printing in lsp mode
    • New Configuration Option: $env.config.table.batch_duration
    • New Configuration Option: $env.config.table.stream_page_size
    • Table literal columns support variables
    • Add %J and %Q format specifiers for compact date/time formatting
    • Add configuration for columnar menu traversal direction
    • Nushell MCP Server
    • Add --chars to str length command
    • The to md command now always returns valid Markdown tables
    • New switches are available for to md
    • compact your records
    • Breaking changes
    • collect removes source metadata
    • strings and globs can now be implicitly cast between each other
    • Other additions
  • Other changes
    • Add run pr and download pr to toolkit
    • Add network feature to top-level crate
    • Improved error messages for binary literals
    • Polars 50.1 upgrade
    • Additional changes
  • Bug fixes
    • Aliases are now expanded before being sent to external completers
    • Discard path add input
    • Fixed IR evaluation error caused by redirecting output of branched blocks
    • Dotnu completion refactor, fixes path with space for both dotnu module path and external executable
    • boolean coloring in light theme
    • changed fallback for unknown color names
    • Improve collection type inference
    • Using break/continue outside loops raises a compile error
    • Windows device path fixes
    • Clean up error handlers when jumping outside of try blocks
    • Other fixes
• Notes for plugin developers
  • Allow saving CustomValues
  • Pass optional and casing to follow path methods for CustomValue
• Hall of fame
• Full changelog

Highlights and themes of this release [toc]

Let AI agents use Nushell commands [toc]

Thanks to @ayax79, this release adds an MCP server for Nushell, allowing AI agents to run Nushell commands.

To use it, compile Nushell with the mcp feature (it's not included by default), then start the server with:

nu --mcp

This is a brand new feature and will keep evolving as we refine it. You can join the discussion on our Discord server in #ai-with-nu.

More cool experiments [toc]

This release brings two new experimental options. You can read more about experimental features here.

First, pipefail, added by @WindSoilder. When enabled, $env.LAST_EXIT_CODE will be set to the exit code of the rightmost command in a pipeline that exited with a non-zero status, or zero if all commands succeeded. When used together with $env.config.display_errors.exit_code = true, Nushell will also report which command failed. See some examples here.

Second, enforce-runtime-annotations, added by @mkatychev. When enabled, Nushell will catch errors at runtime when assigning values to type-annotated variables. Without it, type annotations are only checked at parse time. This helps catch tricky type errors during execution. Read more about it here.

We also promoted one of our experimental options from opt-in to opt-out, so it’s now enabled by default: reorder-cell-paths. It improves performance by reordering how cell-paths are evaluated, making lookups faster. If it causes any issues, you can disable it by setting reorder-cell-paths=false in your experimental options. More info here.

Learn how to enable experimental options.

Tab, tab, tab... Aha! [toc]

Thanks to @Bahex, tab completion just got a lot smarter! A ton of built-in commands now come with handy suggestions. Custom commands can use a new, easy syntax to add their own completions. And for full control, you can now pick which completer to use by adding the @complete attribute to your commands.

Fish out error sources [toc]

Some errors hiding inside other commands weren’t showing up quite right. @Bahex fixed that by making stream collection raise an error when the stream itself contains one. Errors inside each calls also now keep their full context, making it easier to track down what went wrong.

Smarter CustomValues [toc]

CustomValues let plugin authors introduce their own data types without being limited to Nushell's built-in Values. Until now, though, they often lagged behind in functionality. Thanks to @cptpiepmatz, they’re now much closer to behaving like regular Values.

They now support both the $value! syntax added by @Bahex in 0.105.0 and the older $value? syntax. Plugin authors can now decide exactly how these should behave for their custom types.

On top of that, CustomValues now work with the save command. Plugin authors can define how their custom data should be saved, which is often more complex than for built-in types.

See the notes for plugin developers for more details.

Changes [toc]

Breaking changes [toc]

into value is now detect type, and into value now converts custom values to plain values (#16697) [toc]

Until 0.107, into value tried to detect the types of table cells. It converted strings into typed values, which is where the name came from. But it didn't match the purpose of the other into commands. This command is now called detect type but it doesn't operate on cells anymore, so you have to call update cells {detect type} to use that functionality again. With that we can also use that command on non-table types to try to infer the types. The into value name is now used for converting custom values from plugins into native Nushell values.

The table command already showed the base Nushell value:

> custom-value generate | table
I used to be a custom value! My data was (abc)

> custom-value generate | describe
CoolCustomValue

> custom-value generate | into value | describe
string

Collecting a stream that contains errors now raises an error itself (#16738) [toc]

Previously, if an error was returned as a stream item and you collected that stream into a value, you would and up with a list that has an error item which you wouldn't know about until you interacted with that specific item.

You could even end up with a list entirely made up of errors:

let items = 1..10 | each {|n| error make { msg: $"Error ($n)" } }
items | describe
# list<error>

With this release that's no longer the case:

let items = 1..10 | each {|n| error make { msg: $"Error ($n)" } }

Error: nu::shell::eval_block_with_input

  × Eval block failed with pipeline input
   ╭─[entry #4:1:13]
 1 │ let items = 1..10 | each {|n| error make { msg: $"Error ($n)" } }
   ·             ──┬──
   ·               ╰── source value
   ╰────

Error:
  × Error 1
   ╭─[entry #4:1:31]
 1 │ let items = 1..10 | each {|n| error make { msg: $"Error ($n)" } }
   ·                               ─────┬────
   ·                                    ╰── originates from here
   ╰────

Simply attempting to collect such a stream immediately re-throws the first error encountered.

This also has the effect of preserving the context of errors raised some nested command calls like...

Errors raised in nested each calls preserve their context [toc]

Previously, errors raised in nested each calls (and other commands that returned streams) could lose their outer/caller context.

If the closure returned a stream, errors in the stream were not properly chained and lost this context. Running the following code:

0..1 | each {
    0..1 | each {|e|
        error make {msg: boom}
    }
}

we get:

Error: nu::shell::eval_block_with_input

  × Eval block failed with pipeline input
   ╭─[source:2:2]
 1 │ 0..1 | each {
 2 │     0..1 | each {|e|
   ·     ──┬─
   ·       ╰── source value
 3 │         error make {msg: boom}
   ╰────

Error:
  × boom
   ╭─[source:3:3]
 2 │     0..1 | each {|e|
 3 │         error make {msg: boom}
   ·         ─────┬────
   ·              ╰── originates from here
 4 │     }
   ╰────

Error: nu::shell::eval_block_with_input

  × Eval block failed with pipeline input
   ╭─[source:1:1]
 1 │ 0..1 | each {
   · ──┬─
   ·   ╰── source value
 2 │     0..1 | each {|e|
   ╰────

Error: nu::shell::eval_block_with_input

  × Eval block failed with pipeline input
   ╭─[source:2:2]
 1 │ 0..1 | each {
 2 │     0..1 | each {|e|
   ·     ──┬─
   ·       ╰── source value
 3 │         error make {msg: boom}
   ╰────

Error:
  × boom
   ╭─[source:3:3]
 2 │     0..1 | each {|e|
 3 │         error make {msg: boom}
   ·         ─────┬────
   ·              ╰── originates from here
 4 │     }
   ╰────

Changes to EditCommands (#16841) [toc]

• renamed cutinside to cutinsidepair
• renamed yankinside to copyinsidepair
• added cutaroundpair
• added copyaroundpair
• added cuttextobject
• added copytextobject

Vi Mode Text Objects (#16841) [toc]

Vi mode now supports inner and around (i and a) text objects for:

• word, bound to w (a sequence of letters, digits and underscores, separated with white space)
• WORD, bound to W (a sequence of non-blank characters, separated with white space)
• brackets, bound to b (any of ( ), [ ], { })
• quotes, bound to q (any of " ", ' ', ``)

Existing "pair" motions for specific matching pairs (e.g. di( or ci") are also extended to support "around" versions (e.g. da( or ca") that cover the pair characters.

Additionally, the pair motions will now jump to the next pair if non are found within search range.

• For symmetric pairs like quotes, searching is restricted to the current line.
• For asymmetric pairs like brackets, search is multi-line across the whole buffer.

Symmetric pairs search does not do any parsing or matching of pairs based on language/groupings. It simply searches for the previous and next matching characters.

Other breaking changes [toc]

• The LSP session is no longer marked as interactive ($nu.is-interactive == false) (#16580)

• The Polars plugin's value types are renamed to be prefixed with polars_ (e.g. polars_dataframe) (#16819)

Additions [toc]

nu --experimental-options '[foo,bar=false]'

NU_EXPERIMENTAL_OPTIONS="foo,bar=false" nu

nu --experimental-options '[all]'
NU_EXPERIMENTAL_OPTIONS="all" nu

Promoted reorder-cell-paths to opt-out (#16795) [toc]

In Nushell 0.106.0, experimental options were added, first of which is reorder-cell-paths. With this release reorder-cell-paths is promoted to being opt-out, meaning that by default this experimental option is enabled now.

This option improves cell-path accesses by reordering how the cell-path should be evaluated without modifying the output in any way.

If you experience any trouble with this, you can disable it via passing reorder-cell-paths=false via the command-line argument or environment variable.

Pipefail (#16449) [toc]

This release adds a new experimental option: pipefail.

When enabled, $env.LAST_EXIT_CODE will be set to the exit code of rightmost command in the pipeline which exit with a non-zero status, or zero if all commands in the pipeline exit successfully.

> ^false | print aa
aa
> $env.LAST_EXIT_CODE
1

Using it together with $env.config.display_errors.exit_code = true will report the command that failed:

> $env.config.display_errors.exit_code = true
> ^ls | ^false | print aa
aa

aa
Error: nu::shell::non_zero_exit_code

  × External command had a non-zero exit code
   ╭─[entry #3:1:8]
 1 │ ^ls | ^false | print aa
   ·        ──┬──
   ·          ╰── exited with code 1
   ╰────

Enforce Assignment Type Annotations at Runtime (#16079) [toc]

Nushell is perfectly capable of catching type errors at parse time...

let table1: table<a: string> = [{a: "foo"}]
let table2: table<b: string> = $table1

Error: nu::parser::type_mismatch

  × Type mismatch.
   ╭─[entry #1:2:32]
 1 │ let table1: table<a: string> = [{a: "foo"}]
 2 │ let table2: table<b: string> = $table1
   ·                                ───┬───
   ·                                   ╰── expected table<b: string>, found table<a: string>
   ╰────

But only if the relevant types are known at parse time.

let table1: table  = ({a: 1} | into record | to nuon | from nuon);
let table2: table<b: string> = $table1
# * crickets *

Which can lead to some unexpected results:

let x: table<b: string> = ({a: 1} | to nuon | from nuon)
$x | describe
# record<a: int>

This release adds a new experimental option: enforce-runtime-annotations

When it's enabled, nushell can catch this class of type errors at runtime, and throw a cant_convert error:

Error: nu::shell::cant_convert

  × Can't convert to table.
   ╭─[entry #9:1:56]
 1 │ let table1: table  = ({a: 1} | into record | to nuon | from nuon);
   ·                                                        ────┬────
   ·                                                            ╰── can't convert record<a: int> to table
 2 │ let table2: table<b: string> = $table1
   ╰────

This would be a breaking change for scripts where any coercion/conversions previously ignored field constraints for records and tables, which is why it's being phased in with an experimental option.

mut a: record<b: int> = {b:1}; $a.b += 3; $a.b -= 2; $a.b *= 10; $a.b /= 4; $a.b
# 5.0

mut a: record<b: int> = {b:1}
$a.b += 3
$a.b -= 2
$a.b *= 10
$a.b /= 4
$a.b

Error: nu::shell::cant_convert

  × Can't convert to record<b: int>.
   ╭─[entry #1:5:1]
 4 │ $a.b *= 10
 5 │ $a.b /= 4
   · ─┬
   ·  ╰── can't convert record<b: float> to record<b: int>
 6 │ $a.b
   ╰────

let x: record<b: int> = ({a: 1} | to nuon | from nuon)
$x | describe
# record<a: int>

let x: record<b: int> = ({a: 1} | to nuon | from nuon)
$x | describe

Error: nu::shell::cant_convert

  × Can't convert to record<b: int>.
   ╭─[entry #2:1:45]
 1 │ let x: record<b: int> = ({a: 1} | to nuon | from nuon)
   ·                                             ────┬────
   ·                                                 ╰── can't convert record<a: int> to record<b: int>
 2 │ $x | describe
   ╰────

--endian flag for format bits (#16574) [toc]

format bits used to output in native endian, until Nu 0.107.0 (#16435) changed it to big endian. Now, you will be able to choose the behavior with --endian (use format bits --endian native to get the original behavior from before Nu 0.107.0).

~> 258 | format bits
00000001 00000010

~> 258 | format bits --endian little # (or `--endian native` in a little endian system)
00000010 00000001

Guess no more! More completions in built-in commands (#16383) [toc]

Thanks to some recent improvements behind the scenes, nushell built-in commands that expect a specific set of values now suggests these values.

The following commands now have suggestions:

• random uuid --version <...> --namespace <...>
• into int --endian <...>
• into duration --unit <...>
• into datetime --timezone <...>
• histogram --percentage-type <...>
• http* --redirect-mode <...>
• fill --alignment <...>
• cal --week-start <...>
• date to-timezone <...>
• attr deprecated --report <...>
• merge deep --strategy <...>
• from csv, from tsv: --trim <...>
• table --theme <...>
• split list --split <...>

Simple syntax for simple completions (#16789) [toc]

Custom completions are powerful, able to provide dynamic completions based on what's written on the command line so far.

But you don't always need that power. In fact, for most cases a simple static list of options is enough.

To make it simpler and more concise to meet this need, this release adds a new way to define completions for command parameters:

def go [
    direction: string@[ left up right down ]
] {
    $direction
}

Completions can be provided as a list of strings inline in the command signature, or stored in a const variable and used like that.

const directions = [ left up right down ]

def go [ direction: string@$directions ] {
    $direction
}

Command-wide completion handler (#16765) [toc]

There is big difference between custom completions that can be specified in a command's signature, and the "global" external completer ($env.config.completions.external.completer).

The former is added to individual parameters, while the latter provides completions for all arguments of (external) commands.

This makes using custom commands that wrap external commands awkward. The global external completer won't provide completions for the wrapper command and adding completions to that command uses a completely different API. It would be nice to be able to use the external completer's API for custom completions, or use the external completer for wrapper commands...

@complete external

Now it's possible to explicitly enable the global external completer for extern and custom command definitions:

@complete external
def --wrapped jc [...args] {
    ^jc ...$args | from json
}

@complete <completer>

Instead of using the external completer, command-wide custom completers can be used for specific commands:

def carapace-completer [spans: list<string>] {
    ^carapace ..
}

@complete carapace-completer
def --env get-env [name] { $env | get $name }

@complete carapace-completer
def --env set-env [name, value] { load-env { $name: $value } }

@complete carapace-completer
def --env unset-env [name] { hide-env $name }

Combined with extern definitions, this makes it trivial to use specific completion sources for specific commands:

def fish-completer [spans: list<string>] {
	^fish ..
}

@complete fish-completer
extern git []

@complete fish-completer
extern asdf []

Yes, you can remove the match expression from your external completer!

{|spans: list<string>|

    # ...

    # no need for this anymore!
    match $spans.0 {
        # fish completes commits and branch names in a nicer way
        git => $fish_completer
        # carapace doesn't have completions for asdf
        asdf => $fish_completer
        _ => $carapace_completer
    } | do $in $spans

def fish-completer [spans: list<string>] {
	^fish --command $"complete '--do-complete=($spans | str replace --all "'" "\\'" | str join ' ')'"
	| from tsv --flexible --noheaders --no-infer
	| rename value description
	| update value {|row|
		let value = $row.value
		let need_quote = ['\' ',' '[' ']' '(' ')' ' ' '\t' "'" '"' "`"] | any { $in in $value }
		if ($need_quote and ($value | path exists)) {
			let expanded_path = if ($value starts-with ~) { $value | path expand --no-symlink } else { $value }
			$'"($expanded_path | str replace --all "\"" "\\\"")"'
		} else { $value }
	}
}

for loops no longer collect their source (#16593) [toc]

Previously, for loops only worked with values (ranges, lists, etc), so using them with streaming commands would collect the whole stream before iteration could start. Now it also works with streams too!

This makes it possible to use it with slow or unbounded streams:

for event in (watch . --glob=**/*.rs) {
	cargo test
}

Streams of Streams (#16735) [toc]

When you run each over a list (or stream), it can only return a single item for each input. When we need to create multiple values from a single input, we can just return a list in the closure and run the output through flatten.

each { .. } | flatten

When the closure itself generates a stream however, that pattern can be inadequate, as the stream has to be collected into a list, just to be flattened afterwards. This might increase memory usage, and result in unnecessary waits.

To address this, each has a new flag: --flatten

each --flatten does not wait to collect closure output to ensure returning a single output item for each input, instead the stream from the closure is directly passed through. Here's a demonstration of differences:

def slow-source [range: range] {
    $range | each {|e| sleep 0.1sec; $e }
}

0..5..<25
| each {|e| slow-source ($e)..<($e + 5) }
| flatten
| each {|e| print $e; $e}
| ignore

#
def slow-source [range: range] {
    $range | each {|e| sleep 0.1sec; $e }
}

0..5..<25
| each --flatten {|e| slow-source ($e)..<($e + 5) }
| each {|e| print $e; $e}
| ignore

Arbitrary Pipeline Metadata (#16821) [toc]

In addition to existing metadata fields (content_type, source, span), it's now possible to attach arbitrary metadata fields to pipeline data using metadata set --merge:

"data" | metadata set --merge {custom_key: "value"} | metadata | get custom_key

Combined with metadata access, this makes it possible to carry extra data with streams, without impacting the stream data itself.

HTTP Response Metadata (#16821) [toc]

All http commands now attach response data (previously only accessible with http * --full) as metadata to their output streams. This can be accessed under the http_response field within the pipeline metadata:

• status - HTTP status code
• headers - Response headers as [{name, value}, ...]
• urls - Redirect history

Accessing this metadata after the response completes may not offer much benefit.

http get https://api.example.com | metadata | get http_response.status
# => 200

Where it shines is accessing it alongside the streaming response body using metadata access:

http get --allow-errors https://api.example.com/events.jsonl
| metadata access {|meta|
    if $meta.http_response.status != 200 {
        error make {msg: "failed"}
    } else { }
  }
| lines
| each { from json }
| where event_type == "error"

Add $nu.is-lsp to help with printing in lsp mode (#16635) [toc]

When nushell is launched with the --lsp flag, nushell will set $nu.is-lsp to true so that users can programmatically know when nushell is in LSP mode.

When in LSP mode, the print command will only print to stderr. This is done to prevent the LSP from misbehaving when it sees text that isn't JSON-RPC in stdout, which is being listened to by the LSP.

New Configuration Option: $env.config.table.batch_duration (#16629) [toc]

It is now possible to configure the batch duration for the table command.

The table command (and by proxy the default pipeline output) handles streaming in batches to avoid long wait times until any data is visible. With the $env.config.table.batch_duration option, it is now possible to define this time it will collect a batch. This is by default 1 second as it was previously a hard-coded value.

Default setting and previous output:

1..=6 | each {|i| sleep 1sec; $i | into string | $"after ($in) sec"}
# ╭───┬─────────────╮
# │ 0 │ after 1 sec │
# ╰───┴─────────────╯
# ╭───┬─────────────╮
# │ 1 │ after 2 sec │
# ╰───┴─────────────╯
# ╭───┬─────────────╮
# │ 2 │ after 3 sec │
# ╰───┴─────────────╯
# ╭───┬─────────────╮
# │ 3 │ after 4 sec │
# ╰───┴─────────────╯
# ╭───┬─────────────╮
# │ 4 │ after 5 sec │
# ╰───┴─────────────╯
# ╭───┬─────────────╮
# │ 5 │ after 6 sec │
# ╰───┴─────────────╯

Configured to wait for two seconds:

$env.config.table.batch_duration = 2sec
1..=6 | each {|i| sleep 1sec; $i | into string | $"after ($in) sec"}
# ╭───┬─────────────╮
# │ 0 │ after 1 sec │
# │ 1 │ after 2 sec │
# ╰───┴─────────────╯
# ╭───┬─────────────╮
# │ 2 │ after 3 sec │
# │ 3 │ after 4 sec │
# ╰───┴─────────────╯
# ╭───┬─────────────╮
# │ 4 │ after 5 sec │
# │ 5 │ after 6 sec │
# ╰───┴─────────────╯

New Configuration Option: $env.config.table.stream_page_size (#16629) [toc]

It is now possible to configure the maximum page size of streamed data in the table command.

The table command (and by proxy the default pipeline output) chunks streamed data into separate tables according to the stream page size which can now be set via $env.config.table.stream_page_size. By default it's 1000, so (if fast enough) it will collect 1000 entries into a single table and then start a new table.

Default setting and previous output:

1..4 | each {"item " + ($in | into string)}
# ╭───┬────────╮
# │ 0 │ item 1 │
# │ 1 │ item 2 │
# │ 2 │ item 3 │
# │ 3 │ item 4 │
# ╰───┴────────╯

Configured to page at maximum 2 entries:

$env.config.table.stream_page_size = 2
1..4 | each {"item " + ($in | into string)}
# ╭───┬────────╮
# │ 0 │ item 1 │
# │ 1 │ item 2 │
# ╰───┴────────╯
# ╭───┬────────╮
# │ 2 │ item 3 │
# │ 3 │ item 4 │
# ╰───┴────────╯

Table literal columns support variables (#16669) [toc]

Table literals can now have variables in the column names list. For example, this is now allowed:

> let column_name = 'column0'
[[    $column_name    column1  ];
 [    foo             bar      ]
 [    baz             car      ]
 [    far             fit      ]]
╭───┬─────────┬─────────╮
│ # │ column0 │ column1 │
├───┼─────────┼─────────┤
│ 0 │ foo     │ bar     │
│ 1 │ baz     │ car     │
│ 2 │ far     │ fit     │
╰───┴─────────┴─────────╯

Add %J and %Q format specifiers for compact date/time formatting (#16588) [toc]

The format date and into datetime commands now support two new format specifiers for creating compact, sortable date and time components:

• %J produces compact dates in YYYYMMDD format (e.g., 20250918)
• %Q produces compact times in HHMMSS format (e.g., 131144)

These can be used individually for date-only or time-only formatting, or combined for full timestamps (%J_%Q produces 20250918_131144), providing more flexibility than a single combined format.

Perfect for:

• Backup file naming with custom separators
• Log file timestamps with flexible formatting
• Date-only or time-only compact representations
• Any scenario requiring sortable, human-readable date/time components

Both commands use the same format specifications, ensuring consistency when parsing and formatting dates.

This addition is fully backward compatible - all existing format specifiers continue to work unchanged.

Add configuration for columnar menu traversal direction (#16724) [toc]

The feature makes it possible to choose the direction that items are placed in the columnar menu. With the default value of "horizontal", items are ordered left-to-right in each row, with later items appearing in rows below earlier items.

1   2   3   4
5   6   7   8
9   10

With the value set to "vertical", items are ordered top-to-bottom in each column, with later items appearing in columns to the right of earlier items.

1   4   7   10
2   5   8
3   6   9

The configuration option is currently called "tab_traversal" with a default value of "horizontal".

In order to toggle horizontal or vertical, add or update the completion_menu in your config.nu

# Example - Completion menu configuration
$env.config.menus ++= [{
    name: completion_menu
    only_buffer_difference: false     # Search is done on the text written after activating the menu
    marker: "| "                      # Indicator that appears with the menu is active
    type: {
        layout: columnar              # Type of menu
        columns: 4                    # Number of columns where the options are displayed
        col_width: 20                 # Optional value. If missing all the screen width is used to calculate column width
        col_padding: 2                # Padding between columns
        tab_traversal: "horizontal"   # Direction in which pressing <Tab> will cycle through options, "horizontal" or "vertical"
    }
    style: {
        text: green                   # Text style
        selected_text: green_reverse  # Text style for selected option
        description_text: yellow      # Text style for description
    }
}]

Nushell MCP Server (#16693, #16758, #16839, #16857) [toc]

When compiled with the "mcp" feature (not a part of the default feature set), the nushell binary can be used as a local (stdio) MCP server.

To start the nushell MCP server

nu --mcp

This will allow a local AI agent to use MCP to execute native nushell commands and external commands.

Add --chars to str length command (#16768) [toc]

The str length command now has a --chars flag to allow you to count characters.

> 'hällo' | str length --chars
  5

The to md command now always returns valid Markdown tables (#16681) [toc]

Previously, a command like this:

> [['foo' 'bar']; ['1 | 2' 'a | b']] | to md
|foo|bar|
|-|-|
|1 | 2|a | b|

would generate an invalid table, since the | characters inside the cell content were not escaped.

Now, such special characters are automatically escaped, ensuring the output always follows proper Markdown table syntax:

> [['foo' 'bar']; ['1 | 2' 'a | b']] | to md
| foo | bar |
| --- | --- |
| 1 \| 2 | a \| b |

New switches are available for to md (#16681) [toc]

• --escape-md | -m escape all Markdown special characters
• --escape-html | -t escape HTML special characters
• --escape-all | -a escape both HTML and Markdown

compact your records (#16810) [toc]

compact can now be used to remove null or --empty items from records too.

Breaking changes [toc]

collect removes source metadata (#16821) [toc]

collect now removes source metadata field even when content_type is set. Previously: both were preserved, now only content_type is preserved.

strings and globs can now be implicitly cast between each other (#16079) [toc]

Previously string types were not able to be coerced into glob types (and vice versa). They are now subtypes of each other.

Before:

> def spam [foo: glob] { echo $foo }; let f = 'aa'; spam $f
Error: nu::shell::cant_convert

  × Can't convert to glob.
   ╭─[entry #109:1:56]
 1 │ def spam [foo: glob] { echo $foo }; let f = 'aa'; spam $f
   ·                                                        ─┬
   ·                                                         ╰── can't convert string to glob
   ╰────

Now:

> def spam [foo: glob] { echo $foo }; let f = 'aa'; spam $f
aa

Other additions [toc]

• Added support for exabyte and exbibyte filesize format. (#16689)

• Experimental options now provide two new fields since and issue which refer to when the experimental option was introduced and an issue on Github that tracks the status of that issue. You can see them via debug experimental-options. (#16142)

• New operators: not-starts-with and not-ends-with. Added for parity with other comparison operators. (#16852)

• Added file completions for command redirections (o>>, e>, ...) (#16831)

Other changes [toc]

Add run pr and download pr to toolkit (#16770) [toc]

The toolkit in the Nushell repository can now download and run PRs by downloading artifacts from CI runs. It can be run like this:

use toolkit
toolkit run pr <number>

Add network feature to top-level crate (#16686) [toc]

Nushell can now be compiled without network related commands.

If you are manually building Nushell without default features (cargo build --no-default-features) you will now need to pass --features network to get access the network commands.

Improved error messages for binary literals (#16688) [toc]

Previously, a generic shell error is thrown for invalid binary strings. Now, an improve error message is thrown for invalid binary, hexadecimal, and octal strings.

0b[121]

Error: nu::parser::invalid_binary_string

  × Invalid binary string.
   ╭─[entry #3:1:1]
 1 │ 0b[121]
   · ───┬───
   ·    ╰── invalid binary string
   ╰────
  help: binary strings may contain only 0 or 1.

Polars 50.1 upgrade (#16703) [toc]

• polars fetch has been removed due to no longer being supported on LazyFrame
• introduced flag --drop-nulls to polars dummies
• introduced flag --separator to polars dummies
• introduced flag --strict to polars integer
• introduced flag --base to polars integer
• introduced flag --dtype to polars integer
• introduced flag --stable to polars pivot
• polars pivot will no longer perform a stable pivot by default, the flag --stable must be passed in to perform a stable pivot.
• Introduced flag --time-zone to polars as-datetime
• Introduced flag --time-unit to polars as-datetime

Additional changes [toc]

• The which command now lists all commands (internal and external) when no argument is passed to it (#16551)

Bug fixes [toc]

Aliases are now expanded before being sent to external completers (#16640) [toc]

Before this change, when an external completer was invoked for an alias, the first argument sent to the completer would be the alias itself instead of the aliased command.

For example, with an alias defined as alias gl = git log, typing gl branch_name and pressing TAB would send the arguments gl, log, branch_name to the external completer.

After this change, the alias is expanded and the arguments sent to the external completer will be git, log, branch_name.

Discard path add input (#16606) [toc]

Previously path add (from std/util) could fail if it was fed any input.

> use std/util 'path add'
> ls | each {} | path add
Error: nu::shell::incompatible_parameters

  × Incompatible parameters.
    ╭─[std/util/mod.nu:18:17]
 17 │ ]: [nothing -> nothing, nothing -> list<path>] {
 18 │     let span = (metadata $paths).span
    ·                 ────┬─── ───┬──
    ·                     │       ╰── but a positional metadata expression was also given
    ·                     ╰── pipeline input was provided
 19 │     let paths = $paths | flatten
    ╰────

Now any input to path add will be discarded. It's still possible to pass it with $in:

[a b c] | each {|p| $env.HOME | path join $p } | path add $in

Fixed IR evaluation error caused by redirecting output of branched blocks (#16676) [toc]

The following commands will no longer raise ir-eval errors:

• if true { echo "hey" } out> /dev/null
• if false { echo "hey" } else { echo "ho" } out> /dev/null
• try { 1/0 } catch { echo "hi" } out> /dev/null

Dotnu completion refactor, fixes path with space for both dotnu module path and external executable (#16715) [toc]

Module path completion for command use/source now behaviors in the same manner of basic file completion, which is less error prone when dealing with paths with spaces or other special characters.

Fixed the bug of empty result of external executable path completion at the head of a pipeline when the path prefix contains spaces.

boolean coloring in light theme (#16722) [toc]

When using std/config light-theme, booleans inside structures are now colored in dark cyan instead of white, which was very hard to read in combination with a light terminal background.

changed fallback for unknown color names (#16722) [toc]

If some named color in $env.config.color_config is misspelled or otherwise unknown to nu, the corresponding element is now colored using the terminal's default (as in ansi reset) instead of white.

Improve collection type inference (#16530) [toc]

Fixes order-dependent table type inference bugs and introduces similar type widening for lists:

def get_type [] { scope variables | where name == "$foo" | first | get type }

let foo = [ [bar]; [ { baz: 1 } ], [ { baz: 1, extra: true } ] ]
get_type # table<bar: record<baz: int, extra: bool>> -> table<bar: record<baz: int>>

let foo = [ [bar]; [ { baz: 1, extra: true } ], [ { baz: 1 } ] ]
get_type # table<bar: any> -> table<bar: record<baz: int>>

let foo = [ { baz: 1 }, { baz: 1, extra: true } ]
get_type # list<any> -> list<record<baz: int>>

Using break/continue outside loops raises a compile error (#16740) [toc]

Previously this error wasn't caught during compilation, and manifested as a runtime error when the execution reached the invalid break/continue call.

> let fn = { break }
> do $fn
Tried to execute 'run' for the 'break' command: this code path should never be reached in IR mode
Error:   × Main thread panicked.
  ├─▶ at crates/nu-cmd-lang/src/core_commands/break_.rs:45:9
  ╰─▶ internal error: entered unreachable code
  help: set the `RUST_BACKTRACE=1` environment variable to display a backtrace.

> let fn = { break }
Error: nu::compile::not_in_a_loop

  × 'break' can only be used inside a loop
   ╭─[entry #4:1:12]
 1 │ let fn = { break }
   ·            ──┬──
   ·              ╰── can't be used outside of a loop
   ╰────

Windows device path fixes (#16775) [toc]

• On Windows, UNC and device paths no longer get a trailing \ appended when being cast to path
• On Windows, open, save and source now work with device paths like \\.\NUL or \\.\CON, as well as reserved device names like NUL and CON. Using full device paths is recommended.

Clean up error handlers when jumping outside of try blocks (#16838) [toc]

Previously, jumping out of a try block (possible with break/continue commands) did not clean up the error handler properly the way exiting it normally does.

So when an error was thrown afterwards, the error handler would catch it and continue execution in the catch block...

                 do {
                     loop {
                         try {         throwing an error jumps
                 ┌───────────break     into the catch block!!
                 │       } catch {◄───────────────────────────┐
 break jumps out │           print 'jumped to catch block'    │
 of the loop     │           return                           │
 as expected     │       }                                    │
                 └──►}                                        │
                     error make -u {msg: "success"}───────────┘
                 }

This was due to a miscompilation bug, which is now fixed.

Other fixes [toc]

• compact --empty now recognizes 0 byte binary values as empty (#16810)

• Fixed associative equality comparison for floats. (#16549)

• The ** (power) operator now parses as right-associative instead of left-associative, matching standard mathematical behavior. (#16552)

• port <start> <end> on Windows now properly finds open TCP ports. (#16546)

• Fixed a panic when durations were created with a value outside of the supported value range with certain unit suffixes. (#16594)

• Fixes an issue in std help externs - it was using a column that is no longer present. (#16590)

• The LSP should now work better with unsaved files and with overlays used as prefixes (ex. overlay use foo as bar --prefix) (#16568)

• Variables defined as custom command arguments show now be available to autocomplete inside that command. (#16531)

• Fixed building nu-command by itself. (#16616)

• for and while loop blocks starting with a range literal no longer causes a compiler error (#16764)

• Some attr subcommands had incorrect output signatures, which are now fixed. (#16774)

• For commands expecting directory arguments, regular files will no longer be suggested as completions as a fallback for when no directory can be suggested. (#16846)

Notes for plugin developers [toc]

Allow saving CustomValues (#16692) [toc]

CustomValue now supports a save method. Implementors can use it to make their values savable to disk.

Pass optional and casing to follow path methods for CustomValue (#16736) [toc]

Plugin authors that use CustomValue can now access the optional and casing fields in their follow_path_int and follow_path_string methods to add behavior for optional access or case sensitivity.

Hall of fame [toc]

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

Full changelog [toc]