What Are The Supported Language Highlighters In Jekyll

Last modified:


To highlight code snippets in Jekyll post’s, there are many highlighters that can be used. Jekyll comes with Rouge by default.

Rouge is a pure-ruby syntax highlighter. It can highlight 100 different languages, and output HTML or ANSI 256-color text. Its HTML output is compatible with stylesheets designed for pygments.

This article explores how to see the languages that Jekyll support in your current environment and the list of languages for which Jekyll can generate syntax highlighting in posts.


To know which languages can have code syntax highlighted, we can user the command rougify that is part of the rouge gem already installed by Jekyll.

$ rougify --help
usage: rougify [command] [args...]

where  is one of:
        highlight       highlight code
        help            print help info
        style           print CSS styles
        list            list available lexers
        version         print the rouge version number

See `rougify help ` for more info.


As of rouge version 1.11.1, this is the complete list of languages that it supports.

$ rougify version
$ rougify list
== Available Lexers ==                                                                                                       [168/287]
actionscript: ActionScript [aliases: as,as3]

apache: configuration files for Apache web server

apiblueprint: Markdown based API description language. [aliases: apiblueprint,apib]

applescript: The AppleScript scripting language by Apple Inc. (http://developer.apple.com/applescript/) [aliases: applescript]

biml: BIML, Business Intelligence Markup Language

c: The C programming language

ceylon: Say more, more clearly.

cfscript: CFScript, the CFML scripting language [aliases: cfc]

clojure: The Clojure programming language (clojure.org) [aliases: clj,cljs]

cmake: The cross-platform, open-source build system

coffeescript: The Coffeescript programming language (coffeescript.org) [aliases: coffee,coffee-script]

common_lisp: The Common Lisp variant of Lisp (common-lisp.net) [aliases: cl,common-lisp,elisp,emacs-lisp]

conf: A generic lexer for configuration files [aliases: config,configuration]

coq: Coq (coq.inria.fr)

cpp: The C++ programming language [aliases: c++]

csharp: a multi-paradigm language targeting .NET [aliases: c#,cs]

css: Cascading Style Sheets, used to style web pages

d: The D programming language(dlang.org) [aliases: dlang]

dart: The Dart programming language (dartlang.com)                                                                           [131/287]

diff: Lexes unified diffs or patches [aliases: patch,udiff]

eiffel: Eiffel programming language

elixir: Elixir language (elixir-lang.org) [aliases: elixir,exs]

erb: Embedded ruby template files [aliases: eruby,rhtml]

erlang: The Erlang programming language (erlang.org) [aliases: erl]

factor: Factor, the practical stack language (factorcode.org)

fortran: Fortran 95 Programming Language

gherkin: A business-readable spec DSL ( github.com/cucumber/cucumber/wiki/Gherkin ) [aliases: cucumber,behat]

glsl: The GLSL shader language

go: The Go programming language (http://golang.org) [aliases: go,golang]

gradle: A powerful build system for the JVM

groovy: The Groovy programming language (http://www.groovy-lang.org/)

haml: The Haml templating system for Ruby (haml.info) [aliases: HAML]

handlebars: the Handlebars and Mustache templating languages [aliases: hbs,mustache]

haskell: The Haskell programming language (haskell.org) [aliases: hs]

html: HTML, the markup language of the web

http: http requests and responses

ini: the INI configuration format                                                                                             [95/287]

io: The IO programming language (http://iolanguage.com)

java: The Java programming language (java.com)

javascript: JavaScript, the browser scripting language [aliases: js]

jinja: Django/Jinja template engine (jinja.pocoo.org) [aliases: django]

json: JavaScript Object Notation (json.org)

json-doc: JavaScript Object Notation with extenstions for documentation

jsonnet: An elegant, formally-specified config language for JSON

julia: The Julia programming language [aliases: jl]

kotlin: Kotlin (http://kotlinlang.org)

liquid: Liquid is a templating engine for Ruby (liquidmarkup.org)

literate_coffeescript: Literate coffeescript [aliases: litcoffee]

literate_haskell: Literate haskell [aliases: lithaskell,lhaskell,lhs]

llvm: The LLVM Compiler Infrastructure (http://llvm.org/)

lua: Lua (http://www.lua.org)

make: Makefile syntax [aliases: makefile,mf,gnumake,bsdmake]

markdown: Markdown, a light-weight markup language for authors [aliases: md,mkd]

matlab: Matlab [aliases: m]

moonscript: Moonscript (http://www.moonscript.org) [aliases: moon]                                                            [59/287]

nasm: Netwide Assembler

nginx: configuration files for the nginx web server (nginx.org)

nim: The Nim programming language (http://nim-lang.org/) [aliases: nimrod]

objective_c: an extension of C commonly used to write Apple software [aliases: objc]

ocaml: Objective CAML (ocaml.org)

pascal: a procedural programming language commonly used as a teaching language.

perl: The Perl scripting language (perl.org) [aliases: pl]

php: The PHP scripting language (php.net) [aliases: php,php3,php4,php5]

plaintext: A boring lexer that doesn't highlight anything [aliases: text]

powershell: powershell [aliases: posh]

praat: The Praat scripting language (praat.org)

prolog: The Prolog programming language (http://en.wikipedia.org/wiki/Prolog) [aliases: prolog]

properties: .properties config files for Java

protobuf: Google's language-neutral, platform-neutral, extensible mechanism for serializing structured data [aliases: proto]

puppet: The Puppet configuration management language (puppetlabs.org) [aliases: pp]

python: The Python programming language (python.org) [aliases: py]

qml: QML, a UI markup language [aliases: qml]

r: The R statistics language (r-project.org) [aliases: r,R,s,S]                                                               [23/287]

racket: Racket is a Lisp descended from Scheme (racket-lang.org)

ruby: The Ruby programming language (ruby-lang.org) [aliases: rb]

rust: The Rust programming language (rust-lang.org) [aliases: rs]

sass: The Sass stylesheet language language (sass-lang.com)

scala: The Scala programming language (scala-lang.org) [aliases: scala]

scheme: The Scheme variant of Lisp

scss: SCSS stylesheets (sass-lang.com)

sed: sed, the ultimate stream editor

shell: Various shell languages, including sh and bash [aliases: bash,zsh,ksh,sh]

shell_session: A generic lexer for shell session and command line [aliases: terminal,console]

slim: The Slim template language

smalltalk: The Smalltalk programming language [aliases: st,squeak]

smarty: Smarty Template Engine [aliases: smarty]

sml: Standard ML [aliases: ml]

sql: Structured Query Language, for relational databases

swift: Multi paradigm, compiled programming language developed by Apple for iOS and OS X development. (developer.apple.com/swift)

tap: Test Anything Protocol [aliases: tap]

tcl: The Tool Command Language (tcl.tk)

tex: The TeX typesetting system [aliases: TeX,LaTeX,latex]

toml: the TOML configuration format (https://github.com/mojombo/toml)

tulip: The tulip programming language http://github.com/jneen/tulip [aliases: tlp]

twig: Twig template engine (twig.sensiolabs.org)

typescript: TypeScript, a superset of JavaScript [aliases: ts]

vb: Visual Basic [aliases: visualbasic]

verilog: The System Verilog hardware description language

viml: VimL, the scripting language for the Vim editor (vim.org) [aliases: vim,vimscript,ex]

xml: XML

yaml: Yaml Ain't Markup Language (yaml.org) [aliases: yml]

The list is also available as a wiki page online at Rouge wiki, this won’t be always up to date but will cover most of the languages you will ever need.


To use any of the above languages, you need to enclose the code snippets with three or more tilde characters ~~~ and specify the language or an alias appending it to the end of the starting line, for example, to highlight a python snippet the kramdown markdown parser we use fenced code blocks:

~~~ python
# a comment
import datetime

def get_or_create_user(session, model, **kwargs):
    instance = session.query(model).filter_by(twitter_user_id=kwargs["twitter_user_id"]).first()
	return instance

or using the alias py

~~~ py
# ...

Then when rendered it will look like:

# a comment
import datetime

def get_or_create_user(session, model, **kwargs):
    instance = session.query(model).filter_by(twitter_user_id=kwargs["twitter_user_id"]).first()
	return instance


Marcelo Canina
I'm Marcelo Canina, a developer from Uruguay. I build websites and web-based applications from the ground up and share what I learn here.
comments powered by Disqus

The list of languages that Jekyll understand to do syntax highlighting of code

Clutter-free software concepts.
Translations English Espa簽ol

Except as otherwise noted, the content of this page is licensed under CC BY-NC-ND 4.0 . Terms and Policy.

Powered by SimpleIT Hugo Theme