# Nushell 0.7.0

Nushell, or Nu for short, is a new shell that takes a modern, structured approach to your commandline. It works seamlessly with the data from your filesystem, operating system, and a growing number of file formats to make it easy to build powerful commandline pipelines.

We're happy to announce the 0.7.0 release of Nu. This release has a couple new features, bugfixes, and lots of internal improvements on the way to upcoming features.

# Where to get it

Nu 0.7.0 is available as pre-built binaries (opens new window) or from crates.io (opens new window). If you have Rust installed you can install it using cargo install nu (or if you want all stable features cargo install nu --features=stable).

# Ranges (wycats, sebastian-xyz)

We've added ranges as new fundamental type in Nu. To use it, use <number>..<number>. Currently, you can use it with the new range command, which lets you do commands like:

ls | range 3..5

And return rows 3 through 5 of the table that ls gives you.

# Autocomplete improvements (jonathandturner)

As we improve the parser, we are getting more opportunities to do more with the results. One feature we added recently is the ability to autocomplete flags for internal commands.

For example, if you want to see what's available for the config command, you can now type config -- and then immediately use the <tab> key to cycle through possible options.

# Nu becomes multiple crates (wycats, jonathandturner)

Part of a big effort to get Nu ready for script support is to refactor the current codebase to make it cleaner and easier to work with.

For the last few weeks, a big part of this refactor involved splitting our growing monolith of a codebase into separate sub-crates that work together to give the same functionality. As we've done so, we've been able to clean up some of the interfaces between the code. The end result is something that already is easier to work with, and we're excited about what this means for future development.

One side effect of this work is that we've now separated out the plugins from the main nu crate. This gives you more options to configure your Nu setup how you want, as each optional crate can be separately installed.

From cargo, you can install the main crate with:

cargo install nu

Then, you can install the plugins the same way. You can find them because they have a name starting with nu_plugin_. For example, to install the textview plugin:

cargo install nu_plugin_textview

The current set of plugins includes:

  • nu_plugin_average
  • nu_plugin_binaryview
  • nu_plugin_fetch
  • nu_plugin_inc
  • nu_plugin_match
  • nu_plugin_post
  • nu_plugin_ps
  • nu_plugin_str
  • nu_plugin_sum
  • nu_plugin_sys
  • nu_plugin_textview
  • nu_plugin_tree

By default, Nu will install a small set of these plugins ("sys", "ps", "textview", "inc", "str"). You can optionally turn this off using:

cargo install nu --no-default-features

# Introducing: stable and unstable features

Another part of the current refactor work is that we're splitting the "stable" and "unstable" features up. This lets us experiment a bit easier before a command becomes a stable part of the releases.

Now, to install all the stable features, you can use:

cargo install nu --features=stable

If you want to get both stable and unstable features, use:

cargo install nu --all-features

Warning: unless you're working on Nu itself you may not want to install all features currently, as you'll see that we're working on an internal tracing tool.

# Moving the book(s) (sebastian-xyz)

We've been hard at working building up the websites. In the previous release, we talked about "nushell.sh" and the new website there. Since then, we've consolidated the books into the new website. Please update your book links to point to the new site:

# Command improvements

# Embed -> Wrap (jonathandturner, andrasio)

For better readability, we've renamed the embed command to wrap. As the name implies, you can now wrap one table with another. You can also use wrap to create a table from a stream of values.

For example, you may have a list of strings you want to turn into a table:

> ls | get name
────┬────────────────────
 #  │ <value>
────┼────────────────────
  0 │ target
  1 │ CODE_OF_CONDUCT.md
  2 │ .cargo
  3 │ src
  4 │ features.toml
  5 │ TODO.md

We can now name this table using wrap:

> ls | get name | wrap filename
────┬────────────────────
 #  │ filename
────┼────────────────────
  0 │ target
  1 │ CODE_OF_CONDUCT.md
  2 │ .cargo
  3 │ src
  4 │ features.toml
  5 │ TODO.md

# Internal improvements (wycats, jonathandturner, thibran, thegedge)

Though not visible as additional new features, a group of us has been at work refactoring and cleaning up Nu's internals. This should help us both fix some long-standing bugs as well as make way for new features in the future.

We've also internally introduced a new "line" type, which represents strings that carry a line ending with them. This helps us more easily traffic string data through the system and know how best to output it at the end of the pipeline.

# Bugfixes

Of course, with each release, there are the usual bugfixes. We've improved tilde expansion (naufraghi), how internal pipelines are handled (thegedge), and more.

# Improved docs (tchak, coolshaurya, sebastian-xyz)

A big "thank you!" for folks continuing to work on the on-going command documentation efforts. Already, we're seeing people read about the commands (opens new window) on the new website to help them learn Nu, which is great!

# What's next?

You might have noticed that with 0.7.0, we're seemingly getting close to 1.0. What happens after 0.9.0? Are we going to take the leap?

In short, not just yet. After 0.9.0, we'll release 0.10.0. Nu is maturing, but it isn't quite ready for the big One-Point-Oh. We'll continue maturing it until it's ready to make the move.