Babel is a JavaScript compiler

Babel is a toolchain that is mainly used to convert ECMAScript 2015+ code into a backwards compatible version of JavaScript in current and older browsers or environments. Here are the main things Babel can do for you:

  • Transform syntax
  • Polyfill features that are missing in your target environment (through @babel/polyfill)
  • Source code transformations (codemods)
  • And more! (check out these videos for inspiration)
  1. // Babel Input: ES2015 arrow function
  2. [1, 2, 3].map((n) => n + 1);
  4. // Babel Output: ES5 equivalent
  5. [1, 2, 3].map(function(n) {
  6.   return n + 1;
  7. });

For an awesome tutorial on compilers, check out the-super-tiny-compiler, which also explains how Babel itself works on a high level.

ES2015 and beyond

Babel has support for the latest version of JavaScript through syntax transformers.

These plugins allow you to use new syntax, right now without waiting for browser support. Check out our usage guide to get started.

JSX and React

Babel can convert JSX syntax! Check out our React preset to get started. Use it together with the babel-sublime package to bring syntax highlighting to a whole new level.

You can install this preset with

  1. npm install --save-dev @babel/preset-react

and add @babel/preset-react to your Babel configuration.

  1. export default React.createClass({
  2.   getInitialState() {
  3.     return { num: this.getRandomNumber() };
  4.   },
  6.   getRandomNumber() {
  7.     return Math.ceil(Math.random() * 6);
  8.   },
  10.   render() {
  11.     return <div>
  12.       Your dice roll:
  13.       {this.state.num}
  14.     </div>;
  15.   }
  16. });

Learn more about JSX

Type Annotations (Flow and TypeScript)

Babel can strip out type annotations! Check out either our Flow preset or TypeScript preset to get started. Keep in mind that Babel doesn't do type checking; you'll still have to install and use Flow or TypeScript to check types.

You can install the flow preset with

  1. npm install --save-dev @babel/preset-flow
  1. // @flow
  2. function square(n: number): number {
  3.   return n * n;
  4. }

or the typescript preset with

  1. npm install --save-dev @babel/preset-typescript
  1. function Greeter(greeting: string) {
  2.     this.greeting = greeting;
  3. }

Learn more about Flow and TypeScript

Pluggable

Babel is built out of plugins. Compose your own transformation pipeline using existing plugins or write your own. Easily use a set of plugins by using or creating a preset. Learn more →

Create a plugin on the fly with astexplorer.net or use generator-babel-plugin to generate a plugin template.

  1. // A plugin is just a function
  2. export default function ({types: t}) {
  3.   return {
  4.     visitor: {
  5.       Identifier(path) {
  6.         let name = path.node.name; // reverse the name: JavaScript -> tpircSavaJ
  7.         path.node.name = name.split('').reverse().join('');
  8.       }
  9.     }
  10.   };
  11. }

Debuggable

Source map support so you can debug your compiled code with ease.

Spec Compliant

Babel tries to stay true to the ECMAScript standard, as much as reasonably possible. It may also have specific options to be more spec compliant as a tradeoff to performance.

Compact

Babel tries using the least amount of code possible with no dependence on a bulky runtime.

This may be difficult to do in cases, and there are "loose" options for specific transforms that may tradeoff spec compliancy for readability, file size, and speed.