# Check buffers

Flycheck provides two Emacs minor modes for automatic syntax checking: `Flycheck Mode` to enable syntax checking in the current buffer, and `Global Flycheck Mode` to enable syntax checking in all buffers whenever possible.

Minor Mode `Flycheck Mode`

  Enable automatic syntax checking in the current buffer.

Minor Mode `Global Flycheck Mode`

  Enable `Flycheck Mode` in all buffers where syntax checking is possible.

  Note

  This mode does not enable `Flycheck Mode` in remote files (via TRAMP) and encrypted files. Checking remote files may be very slow depending on the network connections, and checking encrypted files would leak confidential data to temporary files and subprocesses.

  You can manually enable `Flycheck Mode` in these buffers nonetheless, but we do not recommend this for said reasons.

  Add the following to your init file to enable syntax checking permanently:

      (add-hook 'after-init-hook #'global-flycheck-mode)

  You can exclude specific major modes from syntax checking with `flycheck-global-modes`:

  defcustom `flycheck-global-modes`

    Major modes for which `Global Flycheck Mode` turns on `Flycheck Mode`:

    `t` (the default)

      Turn `Flycheck Mode` on for all major modes.

    `(foo-mode …)`

      Turn `Flycheck Mode` on for all major modes in this list, i.e. whenever the value of `major-mode` is contained in this list.

    `(not foo-mode …)`

      Turn `Flycheck Mode` on for all major nodes not in this list, i.e. whenever the value of `major-mode` is not contained in this list.

    Note

    `Global Flycheck Mode` never turns on `Flycheck Mode` in major modes whose `mode-class` property is `special`, regardless of the value of this option. Syntax checking simply makes no sense in special buffers which are typically intended for non-interactive display rather than editing.

    See also

    :infonode:`(elisp)Major Mode Conventions`

      Information about major modes, and modes marked as special.

## Check automatically

By default `Flycheck Mode` automatically checks a buffer whenever

- it is enabled,

- the buffer is saved,

- a new line is inserted,

- or a short time after the last change was made in a buffer.

You can customise this behaviour with `flycheck-check-syntax-automatically`:

defcustom `flycheck-check-syntax-automatically`

  A list of events which trigger a syntax check in the current buffer:

  `save`

    Check the buffer immediately after it was saved.

  `new-line`

    Check the buffer immediately after a new line was inserted.

  `idle-change`

    Check the buffer a short time after the last change. The delay is customisable with `flycheck-idle-change-delay`:

    defcustom `flycheck-idle-change-delay`

      Seconds to wait after the last change to the buffer before starting a syntax check.

  `idle-buffer-switch`

    Check the buffer a short time after switching to it from another buffer. The delay is customisable with `flycheck-idle-buffer-switch-delay`:

    defcustom `flycheck-idle-buffer-switch-delay`

      > Seconds to wait after switching to a buffer before starting a syntax check.

      If you switch to several buffers in rapid succession, the behavior depends on `flycheck-buffer-switch-check-intermediate-buffers`:

      defcustom `flycheck-buffer-switch-check-intermediate-buffers`

        If non-nil, then a buffer you switch to will have a syntax check run even if you switch to another buffer before it starts. If nil, then only the current buffer can have a syntax check run. Note that syntax checks can still be run in other buffers due to changes to their contents.

  `mode-enabled`

    Check the buffer immediately after `Flycheck Mode` was enabled.

  For instance with the following setting `Flycheck Mode` will only check the buffer when it was saved:

      (setq flycheck-check-syntax-automatically '(mode-enabled save))

## Check manually

You can also start a syntax check explicitly with `C-c ! c`:

`C-c ! c`
`M-x flycheck-buffer`

  Check syntax in the current buffer.