> ls | where name > 'f' && size > 1kb
```

### Parens to allow grouping

```
= (1 + 2) * (3 + 4)
21
```

## New parser logic (sophiajt)

Early in this release cycle, we began experimenting with different ways we could write the parser going forward. Being able to parse commands, where each command could dictate how the parser works for that command, is a special challenge of how Nu works. After a bit of experimenting, we found a way forward that quickly seemed to fix some of the long-standing bugs. Not only this, but it opened up the way for a set of new features.

If you find issues with this new parser logic where code that used to work no longer works, please let us know. This will help us work out any issues as we build new features on it.

## External improvements (thegedge, sophiajt)

With 0.13.0, we're taking a big step to making externals work in a way much more in-line with how internals work. This allows us to provide better support for variables, column paths, coloring, error handling, and more.

## Many bugfixes and improvements (DrSensor, thegedge, quebin31, jonathandturenr, avendesa, and more)

- Better docker publish for each release (DrSensor)
- Correctly delete symlinks (thegedge)
- Better path canonicalization (quebin31)
- Simplify `cp` and allow recursive copying (quebin31)
- Make trash optional (sophiajt)
- Add support for `$true` and `$false` (sophiajt)
- Fixes for a few path and `where`-related issues (avendesa)
- Plus fixes in our dependencies, many thanks to those crate owners!

## Pipeline blocks and the new `each` command (sophiajt)

Starting with 0.13.0, blocks can now contain pipelines (including `;`-separated multiple pipeline blocks). This allowed us to create the first command to take advantage of this: `each`. The new `each` command will run over each row in a table and do something for each. For example, let's say you wanted to convert each row of a table to separate JSON, rather than converting the whole table:

```
> ls | each { to-json }
```

## Breaking changes

With the math operations above, we're now changing the default type of syntax in a block. Where as before, the expanded version of where was:

(0.12.0)

```
> ls | where { $it.size > 10kb }
```

(0.13.0)

```
> ls | where { = $it.size > 10kb }
```

This is because blocks are now pipelines by default, so you need the extra `=` to switch into the math mode, which allows using the comparison operator `>`.

You can also still use the shorthand versions of these comparisons:

```
> ls | where size > 10kb
> ls | where $it.size > 10kb
```

# Looking forward

With 0.13.0, we've landed some important features that fill in gaps for using Nu as your daily driver, and we're excited to hear from our users. Looking forward, there's a lot of polish we'd like to put on these new features, including updating the book, cleaning up the code, writing more test cases, and fixing some of our bug backlog. This will also give us time to "kick the tires" on these new features as well, using them in our day-to-day work. We're currently planning for the following release to be more focused on "polish". After this, of course, there are many more features to come!