Flow is a static typechecker for JavaScript. To find out more about Flow, check out flow.org.

For a background on the project, please read this overview.

Flow works with:

• Mac OS X
• Linux (64-bit)
• Windows (64-bit)

There are binary distributions for each of these platforms and you can also build it from source on any of them as well.

Flow is simple to install: all you need is the flow binary on your PATH and you're good to go.

The recommended way to install Flow is via the flow-bin npm package. Adding flow-bin to your project's package.json:

• provides a smoother upgrade experience, since the correct version of Flow is automatically used based on the revision you check out
• installs Flow as part of your existing npm install workflow
• lets you use different versions of Flow on different projects

npm install --save-dev flow-bin
node_modules/.bin/flow

Although not recommended, you can also install Flow globally (for example, perhaps you don't use npm or package.json).

The best way to install globally is via flow-bin:

npm install -g flow-bin
flow # make sure `npm bin -g` is on your path

On Mac OS X, you can install Flow via the Homebrew package manager:

brew update
brew install flow

You can also build and install Flow via the OCaml OPAM package manager. Since Flow has some non-OCaml dependencies, you need to use the depext package like so:

opam install depext
opam depext --install flowtype

If you don't have a new enough version of OCaml to compile Flow, you can also use OPAM to bootstrap a modern version. Install OPAM via the binary packages for your operating system and run:

opam init --comp=4.03.0
opam install flowtype
eval `opam config env`
flow --help

Getting started with flow is super easy.

• Initialize Flow by running the following command in the root of your project

flow init

• Add the following to the top of all the files you want to typecheck

/* @flow */

• Run and see the magic happen

flow check

More thorough documentation and many examples can be found at https://flow.org.

Flow is written in OCaml (OCaml 4.03.0 or higher is required). You can install OCaml on Mac OS X and Linux by following the instructions at ocaml.org.

For example, on Ubuntu 16.04 and similar systems:

sudo apt-get install opam
opam init --comp 4.03.0

On OS X, using the brew package manager:

brew install opam
opam init --comp 4.03.0

Then, restart your shell and install these additional libraries:

opam update
opam install -y ocamlfind sedlex

Once you have these dependencies, building Flow just requires running

make

This produces a bin folder containing the flow binary.

In order to make the flow.js file, you first need to install js_of_ocaml:

opam install -y js_of_ocaml

After that, making flow.js is easy:

make js

The new flow.js file will also live in the bin folder.

Note: at this time, the OCaml dependency prevents us from adding Flow to npm. Try flow-bin if you need a npm binary wrapper.

Flow can also compile its parser to JavaScript. Read how here.

This is a little more complicated. Here is a process that works, though it probably can be simplified.

The general idea is that we build in Cygwin, targeting mingw. This gives us a binary that works even outside of Cygwin.

1. Install Cygwin 64bit from https://cygwin.com/install.html
2. In powershell, run iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/ocaml/ocaml-ci-scripts/master/appveyor-install.ps1")) which will likely run a cygwin setup installer with a bunch of cygwin packages and stuff. This helps make sure that every package that opam needs is available.

1. Open the cygwin64 terminal
2. Download opam with curl -fsSL -o opam64.tar.xz https://github.com/fdopen/opam-repository-mingw/releases/download/0.0.0.1/opam64.tar.xz
3. tar -xf opam64.tar.xz
4. cd opam64.tar.xz
5. Install opam ./install.sh
6. Initialize opam to point to a mingw fork: opam init -a default "https://github.com/fdopen/opam-repository-mingw.git" --comp "4.03.0+mingw64c" --switch "4.03.0+mingw64c"
7. Make sure opam stuff is in your path: eval `opam config env`

1. Clone flow: git clone https://github.com/facebook/flow.git
2. cd flow
3. Tell opam to use this directory as the flowtype project: opam pin add flowtype . -n
4. Install system dependencies opam depext -u flowtype
5. Install Flow's dependencies opam install flowtype --deps-only
6. We need these too: opam install camlp4 ocp-build
7. Finally, build Flow: make all-ocp

While Flow is written in OCaml, its parser is available as a compiled-to-JavaScript module published to npm, named flow-parser. Most end users of Flow will not need to use this parser directly (and should install flow-bin from npm above), but JavaScript packages which make use of parsing Flow-typed JavaScript can use this to generate Flow's syntax tree with annotated types attached.

To run the tests, first compile flow using make. Then run bash ./runtests.sh bin/flow

There is a make test target that compiles and runs tests.

To run a subset of the tests you can pass a second argument to the runtests.sh file.

For example: bash runtests.sh bin/flow class | grep -v 'SKIP'

• Website: https://flow.org/
• irc: #flowtype on Freenode
• Twitter: follow @flowtype and #flowtype to keep up with the latest Flow news.
• Stack Overflow: Ask a question with the flowtype tag

Flow is MIT-licensed (LICENSE). The website and documentation are licensed under the Creative Commons Attribution 4.0 license (website/LICENSE-DOCUMENTATION).