Blog | Volta

Announcing Volta 1.0.0

Mon, 21 Dec 2020 15:00:00 +0000

The Volta team is thrilled to announce that Volta 1.0.0 is now available! Volta is a fast, reliable utility for declaring your JavaScript Toolchains as Code. In much the same way that Infrastructure as Code frees teams from manually managing their server infrastructure, Volta takes the hassle out of installing and coordinating JavaScript tools—such as Node, package managers, and package binaries—so that you can focus on creating awesome software.

What does 1.0.0 mean for Volta?

The 1.0.0 release means that Volta is ready for general use in projects of all sizes. The new features included in version 1.0.0 are the last pieces in a string of work—begun with Volta 0.9.0—to make the most common tools work seamlessly with the benefits that Volta provides.

At the same time, 1.0.0 means more than, “we implemented some high-impact functionality and finally closed some long-standing issues.” From the beginning, Volta was built to empower engineers and engineering teams to build amazing JS applications without having to worry about their environment or tooling. For individual engineers, Volta unobtrusively makes sure your tooling is aligned with the needs of your project, allowing you to stay focused on your work. For engineering teams, Volta allows you to manage your infrastructure decision-making centrally without slowing down individual team members. When the team decides to change versions of Node, for example, that doesn’t require explicit effort on the part of each developer. With version 1.0.0, we believe Volta delivers on the promise of making tool management disappear.

Last, version 1.0.0 represents a commitment to stability. As we continue to add new features and support for more tools, we are committed to doing so in a backwards-compatible way. You can be confident that new releases won’t break your workflows or scripts.

What’s new?

Support for `npm link`

With the release of Volta 0.9.0, we added support for installing tools directly with your package manager while still taking advantage of the benefits that Volta provides. We have extended that support to include linking your local packages with npm link, even across different npm versions. Additionally, if you try to link two projects that are using different Node versions, Volta will alert you that there might be incompatibilities that cause unexpected behavior.

Support for upgrading global packages

You can now upgrade your installed global packages directly with your package manager, using npm update -g or yarn global upgrade. Volta will make sure that the package manager can locate all of the packages so that they can be upgraded to their latest versions.

The future of Volta

While we believe that Volta 1.0.0 achieves the goals for the project, that doesn’t mean that we are done! Active development will continue on Volta: adding new features, support for new tools, and fixing any bugs that crop up. A few items on our near-term roadmap include:

Native builds for Apple M1 devices
Support for using pnpm as your package manager
Improvements to volta list, making it easier to visualize the state of your tools

Try it out!

To try Volta for the first time or upgrade your existing installation, follow the instructions on our Getting Started page!

Finally, this release is the culmination of more than two years of work from a whole host of contributors. It wouldn’t have been possible without all of your ideas, feedback, bug reports, code, and encouragement. We would like to extend our heartfelt thanks to everyone in the community for your support.

Interested in getting involved? Join our Discord server!

Command Spotlight: volta run

Wed, 25 Nov 2020 15:00:00 +0000

Volta is designed to be invisible: You type a command like npm start, and Volta automatically detects and runs the right versions of npm and Node. While that works great most of the time, occasionally you need direct control over the tool versions that are used. Maybe you are trying to reproduce a reported bug or testing how your project works with a different npm version. Whatever the reason, volta run lets you take explicit control of tool selection right from the command line.

Let’s check out some examples of how you can use volta run:

volta run --node lts --npm 7 npm start

This will run the command npm start using the most recent LTS Node version and major version 7 of npm.

volta run --yarn 1.22.1 yarn add typescript

This will run yarn add typescript using Yarn 1.22.1 and whichever Node version Volta would normally find (probably from your package.json file).

volta run --node latest --bundled-npm --env NPM_CONFIG_LOGLEVEL=silly npm install

This will run npm install using the latest Node, the npm version bundled with that Node, and with the environment variable NPM_CONFIG_LOGLEVEL set to silly.

You can even use volta run inside your CI configuration to test against multiple tool versions. For example, the following GitHub Actions configuration for a job will run npm test using every combination of Node 10, 12, & 14 with npm 5, 6, and 7:

strategy:
  matrix:
    node: [10,12,14]
    npm: [5,6,7]
steps:
  - run: volta run --node ${{ matrix.node }} --npm ${{ matrix.npm }} npm test

As with any Volta command, if one of the versions you set at the command line hasn’t been seen before, Volta will automatically download it and make it available. No need to install it separately, just tell Volta which version to use and it will make it happen! For more details about the available command-line flags, visit the documentation.

While most of the time Volta’s automatic version detection means you don’t have to worry about which version of Node or npm is needed, sometimes you need to take over and have full control. In those situations, volta run is a powerful tool that lets you tell Volta directly which versions to use for a one-off command.

Announcing Volta 0.9.0

Thu, 22 Oct 2020 15:00:00 +0000

The Volta team is happy to announce that Volta 0.9.0 is now available! This release includes a significant update to how global packages are handled that we’re excited to share!

What’s New?

Install Packages with Your Package Manager

Installing global packages with Volta has many benefits over traditional globals. Until now, to take advantage of those benefits, you needed to install the packages using volta install instead of your package manager. With Volta 0.9.0, you can now install packages directly using your package manager and still get the upside that Volta provides:

npm install --global typescript
yarn global add typescript

Volta will ensure that a shim is set up and pin the Node version so that the package continues to work, even if you change your default Node in the future. Similarly, you can use your package manager to uninstall a global package and Volta will make sure everything is cleaned up correctly:

npm uninstall --global yo
yarn global remove yo

Direct Control Over Pinned Node Version

When pinning the Node version for an installed package, Volta will now use your current default Node version, so there should be no surprises about which Node is used after installing a package. If you want to adjust that to install a package with a different version, you can use volta run to modify the command:

volta run --node 15 npm install --global ts-node

Better Interop Between Packages

Previously, a consequence of Volta’s isolation for packages was that packages weren’t able to call or interact with one another. With Volta 0.9.0, we have resolved those issues so that global binaries can now correctly call other global binaries or require global libraries.

Removal of Package Hooks

Now that the installation is handled by the package managers, Volta no longer supports "package" hooks in the hooks.json file. Instead, if you need to modify the download location for packages, use the standard configuration files for your package manager (i.e. .npmrc and/or .yarnrc).

Miscellaneous Improvements

In addition to the global package improvements, Volta 0.9.0 also includes:

Support for proxying network requests using the HTTP_PROXY, HTTPS_PROXY, and NO_PROXY environment variables.
Further reductions in unnecessary filesystem operations to improve startup time.

Try it out!

To try Volta for the first time or upgrade your existing installation, follow the instructions on our Getting Started page!

Finally, a huge amount of work went into making this release possible, and we would like to thank everyone who contributed ideas, feedback, bug reports, code, and moral support to the project.

Declare Your Tools, Don't Install Them

Thu, 23 Jul 2020 15:00:00 +0000

Declarative UI—powered by packages like React, Vue, or Ember—has completely taken over the world. These techniques let you focus on describing how an app should look and feel, without having to worry about how the page is updated. Despite that, installing the tools you need for development is often stuck in an imperative world. In the same way that modern frameworks take the worry out of updating your UI, Volta liberates you from worrying about the state of your tools!

Installing your development tools—Node, package managers, and others—is almost always done imperatively: You have to tell the computer to use specific versions and when to switch versions. This makes things complicated and error-prone, especially when you are working in multiple projects that have different tool requirements.

Every time you switch to a new project, you have to remember which tools and versions are needed for the new project and manually switch.
For teams, when a decision is made to upgrade to a new version of Node, the entire team needs to be notified.
Forgetting to switch can lead to confusing bugs that are difficult for other contributors to reproduce.

With this model, every time you run a tool, you need to be aware of the context in which you are working to make sure you are running the correct version. By contrast, Volta takes care of picking the correct version of your tools for every context, leaving you free to focus on your work.

Volta delegates to the correct local versions of global packages when you are working in a project (see Global Installs Done Right for more).
Node and package manager versions are specified directly in package.json and Volta will always use those versions.
The shims that power Volta re-evaluate the context on every execution, so whenever those values change, the new versions are immediately reflect in your terminal.
If a team decides to update the Node version, they only need to change the value in package.json and every member will immediately start using the new version.
Volta automatically downloads new versions of tools that it hasn’t seen before, so you don’t even need to track whether you have installed it or not.

Despite all this context detection, Volta is built as a native binary and committed to speed, so the overhead is nearly imperceptible.

Volta’s declarative model frees you from having to constantly track which context you are in, letting you focus on writing great software. You no longer need to think, “Did I remember to switch to the correct npm version?,” just run npm and you get the right version!

Announcing Volta 0.8.0

Fri, 01 May 2020 15:00:00 +0000

The Volta team is happy to announce that Volta 0.8.0 is now available! This is a significant release, with several new features we’re excited to share with you: Custom npm versions, volta run, and more!

What’s New?

Support for Custom npm

With Volta 0.8.0, you can now use custom versions of npm and are not tied to the version bundled with Node. Using the same commands you use to manage yarn, you can now also manage npm to select a custom version:

volta pin npm@latest

If you’re using a custom npm version but want to switch back to using the version bundled with Node, no need to go searching for the specific version! You can use the bundled tag to switch back to the version that is bundled with your Node distribution:

volta pin npm@bundled

You can also manage your default version of npm using volta install in the same way.

New Command – `volta run`

volta run is a new command that lets you run a one-off command with custom versions of your tools – without needing to modify your pinned or default versions! Say you want to do a test run of your app with a new version of Node and Yarn, simply pass those versions to the volta run command:

volta run --node latest --yarn 1.19 yarn test

Volta will resolve the versions you selected, and automatically download any tools that aren’t already available, then run your command using those tools. Any versions you don’t set at the command-line will be filled using the pinned versions for your project or your defaults.

For full details on the options, see the documentation.

Human Formatter for `volta list`

We added volta list all the way back in Volta 0.6.2, to allow inspecting the tools and versions you have available. At the time, the only output format we supported was plain, which output the tools in a simple way, suitable for parsing in a script. In Volta 0.8.0, we added a new format – human – which is designed to be clearer and more user-friendly:

$ volta list
⚡️ Currently active tools:

    Node: v12.16.2 (default)
    npm: v6.14.4 (default)
    Yarn: v1.22.4 (default)
    Tool binaries available:
        ember (default)

The new format is the default when you run volta list, so you don’t need to do anything special to see the new output.

Bug Fixes and Experience Improvements

In addition to the big features, Volta 0.8.0 has a number of performance enhancements, UX improvements, and bug fixes. Including:

More accurate installation - The Volta installer will now do a better job of ensuring that it is correctly configured on your system.
Faster startup - We reduced some of the filesystem operations so that tools start up even faster than they did before.
Error details are now always written to the terminal in CI environments.
volta list correctly handles showing scoped packages.
Node resolution now handles switching between internal and external repos more smoothly.
Small typo fixes and improvements in the output formatting.

Try it out!

To try Volta for the first time or upgrade your existing installation, follow the instructions on our Getting Started page!

Finally, a huge amount of work went into making this release possible, and we would like to thank everyone who contributed ideas, feedback, bug reports, code, and moral support to the project.

Every Error is a Help Screen in Disguise

Mon, 30 Mar 2020 15:00:00 +0000

Nothing is quite so frustrating as a piece of technology giving you an error message that you don’t understand. We’ve all felt that surge of anger like we were a character in Office Space, “’PC Load Letter,’ what the $&@# does that mean?!” With Volta, we’re committed to having helpful errors. In fact, if you ever find yourself frustrated or confused by an error message from Volta, we consider that a bug, so please file an issue!

Early on in the development of Volta, we revamped our error-handling code so that every error in the program is associated with a custom error message. These error messages provide context of what Volta was trying to do when the error occurred and they all provide a call-to-action for what you can do to solve the problem. For example, if you try to run node before installing a version of Node, you don’t see a generic command not found message, you see this:

    $ node --version
Volta error: Node is not available.

To run any Node command, first set a default version using `volta install node`
Error details written to ~/.volta/log/volta-error-2020-03-30_08_00_00.log
  

First, we let the user know what happened and why the command didn’t work. Next, we give advice on how to fix the problem. Finally, we provide an error log with more information in case the user needs to dig in deeper. All of our error messages are structured similarly: Context of what the problem is, call-to-action, and additional information.

We believe in putting effort into the error experience because we recognize that unexpected errors are when users are at their most frustrated. Something went wrong, you didn’t expect it, and now you have to figure out what to do next. If we just show you a generic error message or a cryptic error code with no guidance, we only compound that frustration. Now you have to go figure out what went wrong, then figure out how to fix it, before you can finally get back to the task at hand. Our goal is to give you a helpful error message and guidance on how to move forward, so that you can quickly and easily get back to your work.

Errors are easy to overlook because they aren’t part of what software is supposed to do. We’ve dedicated the time to make our error experience as gentle as possible in order to make using Volta a delightful experience, even when things aren’t working correctly.

Global installs done right

Tue, 18 Jun 2019 15:00:00 +0000

We built Volta to make managing, sharing, and using JavaScript command-line tools convenient and reliable. To make this work, we had to tackle the problem of global installs: a simple way to distribute command-line binaries but with issues that cause some developers to shy away from using them. Volta makes global installs a first-class part of the JavaScript tooling experience, making them both convenient and safe to use.

So why do folks avoid global installs in the first place?

Relying on global tools can make your project depend on something that isn’t listed in its dependencies or devDependencies, making it harder for other developers to contribute.
Other developers could have different versions of the same global tools, leading to hard-to-identify bugs or inconsistencies in behavior.
Unrelated projects on your own machine might depend on different versions of a tool, meaning you now have to manage those versions and switch between them when switching projects.

Some experts advocate including any tools your project depends on in your dependencies and then using the scripts hash in package.json to facilitate running those tools. This way any developer using your code will be able to easily run the same versions of the same tools that you do. This solution, while powerful, is not without its own issues:

Requires the mental overhead of knowing what script to run to invoke a given tool (npm test vs mocha)
Can make it tricky to customize the command, for example to run a single test from a test suite.
Doesn’t work for tools that are used to bootstrap projects, like create-react-app.

Volta solves both of these sets of problems by providing smart proxies for any and all of your JS tools.

By running volta install mocha, you let Volta know that you want mocha to be available everywhere in your terminal. Volta will download the latest version (or if you want you can specify a specific version) to use as the default.
From that point forward, you’ll be able to run that default version of mocha directly in your terminal, just as if you had globally installed it with npm.
However, if you run mocha in a project that has the mocha package as a dependency, Volta will automatically delegate to the local version installed in node_modules, without you having to change the command at all.

This proxy behavior lets you get all the usefulness of having tools directly available in your terminal, without having to worry about switching versions when switching projects. As a bonus, Volta will also pin a version of Node when installing each tool, so you don’t have to worry about having to re-install the tools if you update your default version of Node—they will all continue to work!

To learn more and try Volta for yourself, check out our home page https://volta.sh. You can also reach us on Twitter @usevolta or join our Discord https://discord.gg/hgPTz9A

Hello Volta!

Mon, 13 May 2019 17:07:41 +0000

We’ve got a new version available… and a new name!

Volta 0.5.0 is out, with lots of new features and improvements, including:

Improved stability
Simpler and more helpful error messages
Safe, fast management of npm-distributed binaries!
Idiomatic version syntax (e.g. typescript@3.4)

Compatibility note for current users: The package.json key for pinned tools is now called "volta". You’ll need to rename the "toolchain" key to "volta" in any existing pinned projects.

About the name: This project started as a Node version manager (hence the “No—” alliteration in the old name Notion). Since then, two things happened: first, a number of people brought to our attention the Notion productivity tool, and we decided the polite thing to do would be to rename. Second, since the project has grown in scope to let you manage arbitrary JavaScript tools, we figured it was a good opportunity to rethink the name anyway!

For these reasons and after internal discussion, we decided on a new name. What we once called Notion is now Volta: The JavaScript Launcher ⚡! Our new website is up at https://volta.sh/.

Download Volta 0.5.0 and let us know what you think!

curl -sSLf https://get.volta.sh | bash

Last but not least, we owe our progress to a bunch of amazing collaborators and contributors. Special thanks to Ben Blank, Steve Calvert, Travis Hoover, Rob Jackson, Chris Krycho, Stef Penner, NullVoxPopuli, and Michael Stewart for their great feedback and contributions.

State of the Notion

Tue, 05 Feb 2019 17:07:41 +0000

NOTE: This post predates this project’s rename to Volta.

Notion is a JavaScript toolchain manager, making sure you always get the right version of Node, package managers like npm and Yarn, and JS command-line tools. Best of all, Notion makes tool requirements declarative and reproducible by using package.json to remember and launch the right versions of a project’s required tools, so developers and users always see their projects build and run in a consistent environment.

What’s new?

Lots of good stuff is happening—I can feel the momentum picking up!

Michael Stewart is making great progress on notion install <package>
Chuck Pierce is getting us started on hooks and error message quality
Chris Krycho and I have been working on the web site

What’s next?

Some of the big things I think we need to tackle next are:

Get the work I mentioned done, of course!
Take another pass at the Unix installation scripts and make them more robust for all shells.
Get the Windows installer working.
Make the shims more robust (signal handling, shim name detection logic).
Easier self-update workflow.
Get lots of user input and address whatever issues come up!

State of the Notion

Mon, 20 Aug 2018 17:32:05 +0000

NOTE: This post predates this project’s rename to Volta.

Minimum viable status update

If you’re reading this, it’s probably because one of our contributors reached out to you for early feedback. (Thank you!) Either that, or word spread faster than we expected… 😝

To get started using Notion, you can install the current snapshot with:

$ curl -sSLf https://get.notionjs.com | bash

Then when you open a new terminal, you should be able to run Notion—you can explore its usage by typing notion help.

So here’s where we are so far: we’ve reached a first milestone that hits enough significant use cases to be able to start dogfooding. It’s currently working on Linux and Mac (bash only), but we’ve got the structure in place to start adding support for other shells as well as Windows.

We’re still a ways off from a full release, but this first release demonstrates a few of the things we think are going to make Notion powerful: in particular, a new approach to collaborating on Node projects.

Projects

The goal of Notion is to enable collaborators on a project to always work with the same version of Node. You can select the Node version for a project with notion pin:

$ cd ~/projects/my-app
$ notion pin node 10.7

This command resolves the Node version, fetches the installer, and pins your project to that version by adding a "toolchain" key to your package.json:

"toolchain": {
    "node": "10.7.0"
}

You can think of this as a declarative way of documenting the version of the Node platform that the project is intended to build and run on.

Now here’s the cool part: whenever you’re in a directory inside your project, Notion’s shims to Node executables (like node and npm) automatically switch to the right versions. For example, if app1 is pinned to Node 10.7.0, you’d see this when entering the project directory:

$ cd ~/projects/app1
$ node --version
v10.7.0

And then if app2 is pinned to, say, Node 8.9.4, you’d see this instead:

$ cd ~/projects/app2
$ node --version
v8.9.4

In other words, you never have to think about switching Node setups as you navigate between projects. And all your project’s collaborators can use Notion to be sure they’re always working with the right toolchain for the project. Once you check in the changes to package.json, your team will automatically get the right versions of all the relevant tools.

User toolchains

(First, a caveat: this part of Notion’s implementation is still pretty basic, and some of the workflows are going to change and improve before Notion 1.0 ships.)

The command for installing user tools is notion install. For example, you can choose your version of Node for personal use, which is what you get when you run node anywhere other than in a pinned project:

$ notion install node 10
$ cd ~/Desktop # or anywhere that isn't a pinned project
$ node --version
v10.7.0

There will eventually be a similar workflow for installing package binaries, and automatic creation of shims in your PATH for using them.

Where can we go from here?

Here’s a few of the topics we plan to tackle eventually, in no particular order:

Windows support, and other shells: We will ensure that Notion 1.0 ships on Windows as a fully supported platform! We also intend to support popular Unix shells like zsh, fish, and any others that contributors might want to implement.
Plugins: We plan to make Notion extensible, so e.g. your company’s IT department can configure Notion to provision tools from a private intranet. We’re also working on enabling companies to collect metrics about usage patterns, outages, etc. (These are all disabled by default for privacy.)
CI and offline support: Continuous integration environments bring some extra requirements, like the ability to choose from a matrix of toolchain options, and the ability to split apart the fetching of remote assets and using those assets (often in a network-disabled sandbox) into separate phases.

Blog | Volta

Announcing Volta 1.0.0

What does 1.0.0 mean for Volta?

What’s new?

Support for npm link

Support for upgrading global packages

The future of Volta

Try it out!

Command Spotlight: volta run

Announcing Volta 0.9.0

What’s New?

Install Packages with Your Package Manager

Direct Control Over Pinned Node Version

Better Interop Between Packages

Removal of Package Hooks

Miscellaneous Improvements

Try it out!

Declare Your Tools, Don't Install Them

Announcing Volta 0.8.0

What’s New?

Support for Custom npm

New Command – volta run

Human Formatter for volta list

Bug Fixes and Experience Improvements

Try it out!

Every Error is a Help Screen in Disguise

Global installs done right

Hello Volta!

State of the Notion

What’s new?

What’s next?

State of the Notion

Minimum viable status update

Projects

User toolchains

Where can we go from here?

Support for `npm link`

New Command – `volta run`

Human Formatter for `volta list`