Where to get it

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

YAML's Always More Labor

Thanks to @cptpiepmatz, Nushell's YAML support got a proper rebuild. We now use a stable, modern, maintained implementation that no longer tries to make YAML 1.1, the scary one, and YAML 1.2 behave like one big YAML-shaped compromise.

The two specs are now handled separately, from yaml defaults to YAML 1.2, tags work more deliberately, multi-document streams are supported, anchors and merge keys behave properly, and to yaml is clearer about values that cannot round-trip.

Take a look at all the examples here.

Ah, the $ans.last pipeline took so long to run

Ever had your last pipeline take forever, only to realize you forgot to assign the result to a variable? Worry no longer. Thanks to @fdncred, Nushell now has $ans, a Nushell-specific answer variable heavily inspired by calculators.

$ans keeps track of the last REPL result, including the output, duration, exit code, and the command you typed. Storing the output is opt-in: set $env.config.max_last_result_size to a filesize of your choosing, and $ans.last will keep up to that much of the previous pipeline result.

That means if your pipeline took 15 minutes and you do not want to run it again, you can finally breathe, do a quick let took_too_long = $ans.last, and you're golden. Take a closer look here.

Helix mode!

Alongside Vim mode, Nushell now has helix edit mode too. Set it with $env.config.edit_mode = helix, and that's it. You get a selection-first, Helix/Kakoune-style editing experience with normal, select, and insert modes.

Thanks to @kronberger-droid for the work here. More details are here.

Lots of internal wrangling

This release does not have a huge pile of public user-facing additions, but there was a lot of work inside Nushell. Be in awe of the long list of things happening in the ✨ Hall of Fame ✨, and also check out the long list of fixes.

As always, a big shoutout to everyone contributing and making Nushell better. The internals may not always get the flashiest highlight section, but they are doing a lot of heavy lifting this time.

Changes

Breaking changes

YAML got a proper rework

YAML has been a problem child for quite some time now. This release replaces the old serde_yaml-based implementation with a new one built on serde-saphyr and granit-parser. With that we now get clearer YAML behavior, better round-tripping, proper tag support, multi-document streams, anchors, aliases, merge keys, and a few new options for configuring how the output should look like.

Breaking changes

The big breaking change is that Nu no longer tries to parse YAML as an awkward mix of YAML 1.1 and YAML 1.2. We now default to YAML 1.2, which is usually the the less crazy choice. If your files or scripts relied on old YAML 1.1 scalar magic, pass --spec 1.1.

use std/assert

# Default YAML 1.2 behavior: these stay strings.
assert equal ("yes" | from yaml) "yes"
assert equal ("off" | from yaml --spec 1.2) "off"

# YAML 1.1 keeps the classic YAML oddities.
assert equal ("yes" | from yaml --spec 1.1) true
assert equal ("off" | from yaml --spec 1.1) false

This specifically breaks octal numbers. In the 1.1 spec, a value is interpreted as an octal number if it starts with the 0 digit. It is then parsed as an octal value. If the value is not valid octal, it is instead returned as a string.

The 1.2 spec made this much more sensible by allowing leading zeros on regular numbers and requiring octal numbers to use the 0o prefix.

use std/assert

# YAML 1.1 uses a leading zero as an octal indicator.
assert equal ("0247" | from yaml --spec 1.1) 0o247
assert equal ("0o247" | from yaml --spec 1.1) "0o247"

# YAML 1.2 replaced that with the `0o` prefix.
assert equal ("0247" | from yaml --spec 1.2) 0247
assert equal ("0o247" | from yaml --spec 1.2) 0o247

Did you know that YAML 1.1 supports sexagesimal values like 190:20:30? No, well in the 1.1 spec these as base-60 numbers that can be used to represent time but noone knows that, so 1.2 got rid of them. And as Nushell now defaults to 1.2 we interpret these as strings.

use std/assert

assert equal ("190:20:30" | from yaml) "190:20:30"
assert equal ("190:20:30" | from yaml --spec 1.1) 685230

assert equal ("02472256" | from yaml) 2472256
assert equal ("02472256" | from yaml --spec 1.1) 685230

from yaml is stricter about mapping keys now, too. Nushell record keys are strings, so plain YAML keys that resolve to booleans, numbers, or null are rejected by default. If you want the old loose behavior, use --key-resolution verbatim and Nushell will keep the original key text.

'true: enabled' | from yaml
# Error: YAML key resolves to a boolean, but Nushell record keys are strings

'true: enabled' | from yaml --key-resolution verbatim
# => {true: enabled}

Tags also mean tags now. Previously, tagged scalars weren't really handled properly, often they were just ignored and handled as plain strings but in YAML they describe the data, usually as some types. Now unknown tags error by default but you can use --ignore-tags to just ignore the tags and deal with them yourself.

'Key: !Sub ${AWS::StackName}' | from yaml
# Error: unknown YAML tag

'Key: !Sub ${AWS::StackName}' | from yaml --ignore-tags
# => {Key: "${AWS::StackName}"}

to yaml is also more specific about values that cannot round-trip. By default it errors instead of quietly turning them into something else. If that is unwanted, choose the behavior explicitly with --non-roundtrip null or --non-roundtrip lossy. The --serialize flag is still available but will probably be deprecated in the future.

{|| $in } | to yaml
# Error: closures are not round-trippable through YAML

{|| $in } | to yaml --non-roundtrip null
# => null

{|| $in } | to yaml --serialize
# => !closure "{|| $in }"

One more relevant breaking change: generated YAML may not look exactly like it did before. The new serializer quotes strings more carefully, writes tags for Nushell-specific values, and lets you configure indentation. If you depended on a specific YAML output, you might need to check that.

Tags and round-tripping

Nushell now understands standard YAML tags like !!timestamp,!!binary, !!omap, !!pairs, and !!set. It also writes Nushell-specific local tags for values that YAML did not define globally, such as filesizes, durations, ranges, globs, and cell paths.

name: Cargo.toml
size: !filesize 17515
modified: !!timestamp 2026-08-14T23:30:19.144306+02:00
path: !cell-path $.items.0.name

Here, !filesize and !cell-path are Nushell tags, while !!timestamp is a standard YAML tag. When you read this back with from yaml, those fields come back as proper typed values instead of plain strings or integers.

If you want the YAML version and Nushell tag prefix written out explicitly, use to yaml --add-directives or to yaml -d.

ls | where name == Cargo.toml | first | to yaml --add-directives

%YAML 1.2
%TAG ! tag:nushell.sh,2026:

Nushell

• @kronberger-droid:

  • chore(reedline): bumped to latest reedline commit 6b9115d (#18829)
  • fix(config): matched unnamed keybindings by the key they bind (#18828)
  • fix(completion): stopped the cache reordering the answer it stands in for (#18806)
  • bumped reedline to e4fe8ed (#18798)

• @fdncred:

  • added cli key to $ans record, renamed last_result_size to max_last_result_size (#18827)
  • bug: made $ans work better with TUIs (#18820)
  • fix: allowed semver to have coloring, added --loose flag (#18819)
  • reduced ast footprint, increased ir footprint - phase 0 (#18808)
  • updated deps (#18802)
  • Allowed all built-in commands with --regex to use LRU (#18797)
  • updated uu-utils crates to v0.10.0 (#18795)
  • allowed parameters with # to be passed (#18782)
  • upgraded kdl to support --spec 1 or --spec 2 (#18779)
  • added $ans record for storing the last result from the repl (#18729)

• @Bahex:

  • Fixed module item completion (#18826)

• @cpea2506:

  • bumped devicons to 0.6.13 (#18817)

• @Mrfiregem:

  • Showed deprecation entries in scope commands output (#18815)

• @hexbinoct:

  • Lexed quotes inside interpolated string subexpressions (#18812)

• @latent-9:

  • fix(stor): rejected a missing file in stor import instead of discarding the in-memory database (#18809)

• @app/dependabot:

  • build(deps): bumped bytesize from 2.4.0 to 2.7.0 (#18825)
  • build(deps): bumped taiki-e/install-action from 2.85.8 to 2.85.11 (#18824)
  • build(deps): bumped actions-rust-lang/setup-rust-toolchain from 1.12.0 to 1.17.0 (#18823)
  • build(deps): bumped Swatinem/rust-cache from 2.9.1 to 2.9.2 (#18822)

reedline

• @kronberger-droid:

  • fix(painter): stopped trimming the newline that ends a multi-line prompt (#1147)
  • chore: raised rust-version to the 1.95 the locked deps requirements (#1146)
  • fix(painter): stopped gating the exit erase on after-cursor text (#1145)
  • fix(engine): decided menu completions once the completer answers (#1144)
  • fix(painter): pinned the cursor when a line fills the terminal width (#1141)
  • feat(helix)!: added helix edit mode behind a feature flag (#1138)
  • fix(painter): didn't re-use a bottom-flush prompt anchor after a scroll (#1133)

• @james-kassabian:

  • Took the external-print anchor from the terminal, not a count (#1139)

Documentation

• @orthonormalremy:

  • converted the direnv export PATH to a list before loading it into env (#2223)

• @idzikovsky:

  • Fixed missing word in style guide for surrounding constructs (#2222)

• @app/dependabot:

  • bumped js-yaml from 3.15.0 to 3.15.1 (#2221)

Tree-sitter

• @app/dependabot:
  • chore(deps-dev): bumped js-yaml from 4.3.0 to 4.3.1 (#255)

nufmt

• @fdncred:
  • batched fixes (#212)

VSCode Extension

• @mst-mkt:
  • fix: fixed Syntax highlighting broken for bare string values in records (#237)

New nu-parser

• @InnocentZero:
  • Fixed type inferencing in partial if blocks (#73)
  • Added oneof<...> type declarations (#71)

Nushell

• @Bahex:

  • feat(format duration/filesize): added completions for units (#18783)

• @cacdu:

  • fix(save): gave actionable error when structured data has no serializer (#18773)

• @cptpiepmatz:

  • removed nu! and updated tests (#18776)
  • more updated tests (#18768)

• @fdncred:

  • bumped deps (#18780)
  • updated nushell to latest reedline commit 60d99674 (#18775)
  • fixed math max empty list vs empty string (#18772)
  • fixed color config fallbacks (#18770)
  • improved lex/parse errors (#18702)

• @ian-h-chamberlain:

  • supported CLI args for commandline (nu -c) scripts (#18576)

• @oh-summy:

  • fix(help): documented list input support for hash md5/sha256 (#18638)

• @pheenty:

  • treated empty string as an invalid path in path type (#18785)

• @philocalyst:

  • reworked how completer works (#18761)
  • async prompt updating (#18660)

• @Totara-thib:

  • pinned CI actions to commit SHAs and declared workflow permissions (#18787)

• @app/dependabot:

  • build(deps): bumped http from 1.4.0 to 1.5.0 (#18784)

reedline

• @kronberger-droid:

  • test(editor): kept case-transform selections inside the buffer (#1140)

• @matystroia:

  • feat(vi): added u, U visual mode commands (#1087)

• @sim590:

  • feat(vi): supported deleting chars backward with X (#1067)

Documentation

• @davidpavlovschi:

  • Fixed incorrect claim that a module file cannot match its directory name (#2219)

• @app/dependabot:

  • Bumped postcss from 8.5.16 to 8.5.25 (#2218)
  • Bumped undici from 7.28.0 to 7.29.0 (#2217)
  • Bumped seroval from 1.5.0 to 1.5.6 (#2214)

Nushell

• @cptpiepmatz:

  • stabilized unreliable tests in CI (#18756)
  • refactored a handful of tests to use test() (#18748)
  • refactored open tests (#18740)
  • updated the help text of test binaries (#18739)
  • updated kitest (#18727)
  • stopped running CI on lower layers of stacked PRs (#18720)
  • removed --testbin from nu (#18719)
  • updated internal commands tests (#18718)
  • updated external commands tests (#18717)
  • updated eval tests (#18716)
  • updated run external tests (#18715)
  • updated redirection tests (#18714)
  • refactored most test files that used nu --testbin (#18713)
  • refactored some tests (#18712)

• @Bahex:

  • made error make raise errors for invalid labels (#18755)
  • stopped lines from prematurely collecting output for string value input (#18753)
  • fixed the job spawn closure so it runs with an empty pipeline, not null (#18752)
  • fixed generate to handle null input the same as an empty pipeline (#18751)

• @fdncred:

  • updated math commands to handle records and support cell path rest params (#18754)
  • updated doc_config.nu and tweaked the explore section (#18750)
  • made $env.config show default configuration when not set even with nu -n (#18747)
  • fixed startup with dangling symlinks (#18726)
  • fixed ls ** when using the dc-glob experimental option (#18724)
  • added more consistency with null types (#18709)

• @xtqqczze:

  • bumped num-bigint from 0.4.6 to 0.4.8 (#18746)

• @danielcadev:

  • fixed save to serialize structured data to text files (#18735)
  • fixed RHS pipeline input type checking (issue #18682) (#18723)

• @ayax79:

  • added lazy and expression support for polars rolling (#18730)

• @ZayanKhan-12:

  • fixed devdocs links in AGENTS.md (#18721)

• @rvhelden:

  • passed Stack to the IR debugger instruction callbacks (#18708)

reedline

• @philocalyst:
  • strengthened contracts around completions (#1136)

Documentation

• @cptpiepmatz:

  • fixed the --experimental-options typo in the ExperimentalOption element (#2213)

• @NotTheDr01ds:

  • caught up on TWiN (again) (#2212)

• @ColumbusLabs:

  • documented passing arguments to external commands (#2211)

• @app/dependabot:

  • bumped immutable from 5.1.5 to 5.1.9 (#2210)

Tree-sitter

• @app/dependabot:
  • bumped flatted from 3.3.3 to 3.4.3 (#254)
  • bumped js-yaml from 4.1.1 to 4.3.0 (#253)

Awesome Nu

• @fhalim:
  • added nu_plugin_todoist (#170)

Nushell

• @fdncred:

  • added splashboard to .gitignore (#18701)
  • bumped reedline dep to latest commit 7eb9bf2 (#18695)
  • updated fff-search to 0.10.1 and tokio to 1.53.1 (#18693)
  • updated agent.md (#18683)
  • bumped nushell to latest reedline commit a2c6e124 (#18681)
  • updated some dependencies (#18678)
  • disallowed keywords from being shadowed (#18662)
  • fixed is-terminal OS detection and added is-redirected for pipeline destinations (#18661)
  • updated nushell to latest reedline commit (#18655)
  • added idx watch command (#18639)
  • fixed bug where ls with dc-glob would fail with literal * name files (#18632)
  • expanded paths for --config-home parameter also ensured xdg is absolute (#18629)
  • disallowed export main from modules with keyword names (#18619)

• @pyz4:

  • fixed date floor/ceil rounding for durations >= 1day (#18696)

• @kronberger-droid:

  • bumped reedline to latest commit 83c17a2 (#18694)
  • bumped reedline to latest commit (#18685)

• @Alb-O:

  • refactored idx: removed import/export, kept single live index (#18679)
  • fixed idx: kept watched imports live (#18674)
  • fixed idx: excluded tombstoned entries (#18673)
  • avoided cloning list values for performance (#18636)

• @philocalyst:

  • updated to use CompletionResult (#18671)

• @ahmojo:

  • fixed parser: restored scopes before interpolation fallback (#18666)

• @cptpiepmatz:

  • updated terminal tests (#18663)

• @Bahex:

  • updated some tests to use the new test infra (#18651)
  • replaced built-in date floor/ceil commands with nu rewrites (#18640)

• @Tyarel8:

  • added new duration_max_unit config option (#18650)

• @cablehead:

  • fixed engine: preserved metadata and streams through early return (#18625)

• @app/dependabot:

  • bumped aws-config from 1.8.15 to 1.10.0 (#18689)
  • bumped actions/setup-python from 6 to 7 (#18688)
  • bumped actions/labeler from 6 to 7 (#18687)

Documentation

• @fdncred:

  • added ide_completion_menu (#2208)

• @ninjack-dev:

  • fixed incorrect update date overriding publish date in Atom feed (#2207)
  • fixed pubDate not being added to RSS entries (#2206)

Awesome Nu

• @casedami:
  • added nu_plugin_todu (#169)

nufmt

• @HigherOrderLogic:

  • preserved comments at the end of multiline pipeline (#210)
  • added clippy to devShell (#209)

• @Mrfiregem:

  • fixed: don't use exclusive range operator before step (#208)

reedline

• @fdncred:

  • updated some dependencies (#1129)

• @kronberger-droid:

  • refactored prompt: used nu_ansi_term::Color throughout Prompt Trait (#1128)
  • split Extend into CoverLanding vs Span (#1113)

• @casedami:

  • fixed: dont expand abbr eagerly on submit (#1125)

• @philocalyst:

  • made Reedline aware of the status of completors (#1123)
  • fixed for surfaced unlayout in Nushell (#1122)

• @easyinplay:

  • fixed floor word_end to char boundary in abbreviation expansion (panic on multibyte char before cursor) (#1121)

• @eitsupi:

  • added typed inherent methods and JSON filter to SqliteBackedHistory (#1112)

Nu_Scripts

• @nextgenthemes:

  • fixed folder name (#1271)

• @AucaCoyan:

  • replaced str downcase for str lowercase (#1270)

Nushell

• @fdncred:

  • fixed par-each hang bug (#18628)
  • updated nushell to latest reedline commit (#18617)
  • Reverted "Add uutils ln command" (#18605)
  • fixed: stop run from trying to parse big non-text files (#18603)
  • made stor and query db more thread-safe (#18569)
  • mut and par-each optimizations for performance (#18566)
  • added const eval in match arms (#18559)
  • Added matrix commands (#18553)

• @pyz4:

  • feat(date): added new commands date floor and date ceil (#18620)

• @pheenty:

  • added lacy tool into the list of projects that support nushell (#18618)

• @Alb-O:

  • fixed: unsigned binary overflow in into int (#18615)
  • perf: avoided cloning binary values (#18572)

• @coyaSONG:

  • Migrated ulimit tests to the new harness (#8670) (#18614)

• @sid-6581:

  • fixed: fix submodule import in test_docker.nu (#18606)

• @Bahex:

  • Added CompleteResult type for working with complete in tests (#18604)
  • Added test_value! macro (#18582)
  • fixed: uname signature, and added detailed column info (#18568)

• @kobihikri:

  • ci: pinned milestone-action to a full commit SHA (#18601)

• @m-novotny:

  • Fixed default configuration links (#18598) (#18599)

• @drbrain:

  • Allowed PluginCommand::get_dynamic_completion() to use EngineInterface::get_plugin_config() (#18587)

• @cptpiepmatz:

  • Also triggered CI on ready_for_review (#18586)
  • Removed all tests that use nu_with_plugins! (#18585)
  • Stopped running CI for draft PRs (#18584)
  • After patch release (#18577)
  • Prepared patch release (#18575)
  • Added test dependencies via test attribute #[deps(...)] (#18570)

• @alerque:

  • Bumped pin of transient dependency causing unsound transmute (#18581)

• @dmatos2012:

  • Added uutils ln command (#18571)

• @Mrfiregem:

  • feat(into semver): added cell-path support (#18567)

• @app/dependabot:

  • build(deps): bumped humantime from 2.3.0 to 2.4.0 (#18548)

Documentation

• @Kissaki:

  • Added missing code fencing in lang-guide pipelines.md (#2205)
  • Fixed code fencing (#2204)
  • Consistently used present tense (#2203)
  • For semicolon stdout redirection, contrasted external to internal (#2202)
  • Fixed fr typo (#2201)
  • Fixed outdated output redirection docs (#2200)
  • Added missing word in v0.110.0 post (#2197)

• @cptpiepmatz:

  • Added release notes for v0.114.1 (#2198)

Awesome Nu

• @idanarye:
  • Added nu_plugin_handlebars (#168)

nufmt

• @fdncred:

  • fixed ci build problem (#206)

• @KP64:

  • chore: added nix metadata (#205)

reedline

• @maxim-uvarov:

  • Added with_persistent_menus option (#1118)

• @philocalyst:

  • Added asynchronous prompt updates (#1117)

Nu_Scripts

• @Tyarel8:

  • feat(task): printed actual command in log (#1268)

• @alightgoesout:

  • Updated jj completions for version 0.43.0 (#1267)

NUPM

• @neurolag:
  • Migrated to New Commands (#136)

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

Nushell

• @Bahex:

  • fixed type comparisons between table and list<oneof> (#18560)
  • relaxed assignability of list types (#18555)
  • fixed closure's input type to not inherit from scope (#18540)
  • fixed input listen's output type (#18535)
  • fixed assignment errors to point to the assignment (#18531)
  • added from xlsx/ods datetime fixes (#18516)

• @cptpiepmatz:

  • updated crossbeam crates via cargo update (#18554)
  • prepared release (#18524)
  • fixed locally running test suite by disabling colors (#18517)

• @Alb-O:

  • fixed parser to infer for loop items from iterable unions (#18551)
  • fixed search context help example in idx (#18550)

• @fdncred:

  • added list input type to more date commands (#18536)

• @hexbinoct:

  • fixed run binding that forwarded flags to the wrong parameter (#18533)

• @Juhan280:

  • fixed MCP to initialize start_time only in MCP mode to avoid cargo warning (#18530)

• @stormasm:

  • added "nu-test-support/os" to dev dependencies (#18518)

Documentation

• @Kissaki:

  • improved v0.114.0 release post text (#2196)

• @Alb-O:

  • updated 0.114 release notes for structured MCP output (#2195)

• @cptpiepmatz:

  • fixed overflowing content on 0.114 blog post (#2193)
  • prepared release notes for v0.114.0 (#2192)

• @hustcer:

  • upgraded vuepress and related plugins (#2191)
  • refreshed command docs for v0.114 (#2190)

nufmt

• @xav-ie:

  • fixed comment loss and misplacement in match arms, nested records, and raw strings (#203)

• @momomuchu:

  • tracked single-quoted strings and skipped comments when detecting missing record commas (#202)

reedline

• @cptpiepmatz:
  • bumped minor version (#1116)

Integrations

• @weirdan:
  • imported entire std/assert module (#76)

NUPM

• @neurolag:
  • fixed nushell 114 (#135)
  • fixed Git Registry installations (#134)

VSCode Extension

• @mst-mkt:
  • fixed syntax highlighting for variable declarations with type annotations (#234)

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:

  • Ignored cargo audit errors about quickxml (#18513)
  • Feature gated the nu-heavy-utils crate (#18476)

• @fdncred:

  • fixed nu --plugins handling (#18500)
  • allowed idx find and idx search to show hits relative to cwd (#18477)
  • bumped reedline to 4d20caf (#18474)
  • added semver as a custom value type with support commands (#18473)
  • added a few new commands (union, intersect, difference, permutations, combinations) (#18467)

• @Alb-O:

  • added structured evaluate output (#18499)

• @pheenty:

  • suggested command categories in help messages (#18498)
  • fixed multiple search items help message (#18482)
  • added math cbrt builtin (#18481)

• @yertto:

  • added –prefer-integers flag for whole-number float conversion (#18497)

• @Himanshu121865:

  • Fixed --content-type flag being ignored for JSON body variants (#17640) (#18496)
  • Fixed showing target command name instead of alias name (#18351) (#18483)

• @Bahex:

  • fixed toolkit run pr runtime type checking issue (#18489)
  • Made error record passed to the catch block have more details (#18479)
  • Made even more type system improvements (#18450)
  • Made assortment of std improvements (#18449)
  • Made from ods and from xlsx consistent (breaking change) (#18436)

• @cacdu:

  • Fixed math errors propagation from table columns instead of silencing them (#18480)

• @kronberger-droid:

  • Bumped reedline to 4a5ebce (#18478)

• @jlcrochet:

  • Improved input list streaming stability/perf and rendering (#18462)

• @Juhan280:

  • Refactored to remove deprecated features of grid command (#18276)

• @app/dependabot:

  • bumped lsp-server from 0.7.9 to 0.8.0 (#18505)
  • bumped quick-xml from 0.40.1 to 0.41.0 (#18503)

Documentation

• @app/dependabot:
  • bumped js-yaml from 3.14.2 to 3.15.0 (#2189)

reedline

• @kronberger-droid:

  • Added a pull request template (#1115)
  • Added visual mode on a unified Cursor + rest-policy model (breaking change) (#1109)

• @MerlijnW70:

  • Fixed abbreviation expansion inserting a double trailing space (#1111)

Nu_Scripts

• @tonythethompson:

  • Fixed scale-minmax-table failing on current Nu (undefined column2, deprecated merge) (#1265)

• @rossnomann:

  • Added git cherry to git-completions (#1264)

Tree-sitter

• @blindFS:
  • Fixed dot in flag identifier (#250)

Nushell

• @fdncred:

  • bumped rusqlite to 0.40.1 (#18469)
  • added new log-level perf so we can more easily see only performance logging (#18468)
  • bumped reedline to commit 31a91c3 (#18455)
  • bumped quinn-proto (#18453)
  • bumped fff-search deps to 0.9.6 (#18448)
  • fixed idx search 'Lyrics[' bug (#18447)
  • respected table mode passed on cli for scripts and repl (#18446)
  • allowed is-terminal to detect redirection (#18443)
  • refactored pushdown code into a query_plan to make it easier to add more pushdown filters (#18398)

• @maximilize:

  • added regression test for non-block for body (#13746) (#18466)
  • fixed compile: clone $in register for binary-op RHS to avoid clobbering LHS (#18323) (#18465)

• @Juhan280:

  • refactored logging: simplified CLI filter parsing to allow target or module paths (#18464)

• @hexbinoct:

  • fixed usize underflow on insert/upsert into a nested path of an empty list (#18463)

• @flying-sheep:

  • added --right to split row and split column (#18444)

• @cptpiepmatz:

  • serialized Range via string representation (#18442)
  • fixed CI not testing doctests (#18441)

• @Tyarel8:

  • added navigation shortcuts to explore config (#18440)

• @Bahex:

  • made row-conditions parse {} as closure, not record (#18438)
  • improved type system (#18430)
  • made experimental option enforce-runtime-annotations opt out (#18359)

• @stuartcarnie:

  • fixed SIGABRT from broken stdout/stderr on parent exit (#18428)

• @mkatychev:

  • added lsp feature flag to executable (#18148)

• @app/dependabot:

  • bumped bytes from 1.11.1 to 1.12.0 (#18459)
  • bumped rmcp from 1.7.0 to 1.8.0 (#18458)
  • bumped actions/checkout from 6 to 7 (#18457)