Zephyr Project content is written using the reStructuredText[2] markup
language (.rst file extension) with Sphinx extensions, and processed
using Sphinx to create a formatted standalone website. Developers can
view this content either in its raw form as .rst markup files, or (with
Sphinx installed) they can build the documentation locally
to generate the documentation in HTML or PDF format. The HTML content can
then be viewed using a web browser. This same .rst content is served by the
Zephyr documentation[4] website.
This document provides a quick reference for commonly used reST and
Sphinx-defined directives and roles used to create the documentation
you’re reading.
Indenting is significant in reST file content, and using spaces is
preferred. Extra indenting can (unintentionally) change the way content
is rendered too. For lists and directives, indent the content text to
the first non-white space in the preceding line. For example:
* List item that spans multiple lines of text
showing where to indent the continuation line.
1. And for numbered list items, the continuation
line should align with the text of the line above.
..code-block::
The text within a directive block should align with the
first character of the directive name.
For bullet lists, place an asterisk (*) or hyphen (-) at
the start of a paragraph and indent continuation lines with two
spaces.
The first item in a list (or sublist) must have a blank line before it
and should be indented at the same level as the preceding paragraph
(and not indented itself).
For numbered lists
start with a 1. or a. for example, and continue with autonumbering by
using a # sign. Indent continuation lines with three spaces:
* This is a bulleted list.
* It has two items, the second
item and has more than one line of reST text. Additional lines
are indented to the first character of the
text of the bullet list.
1. This is a new numbered list. If the wasn't a blank line before it,
it would be a continuation of the previous list (or paragraph).
#. It has two items too.
a. This is a numbered list using alphabetic list headings
#. It has three items (and uses autonumbering for the rest of the list)
#. Here's the third item
#. This is an autonumbered list (default is to use numbers starting
with 1).
#. This is a second-level list under the first item (also
autonumbered). Notice the indenting.
#. And a second item in the nested list.
#. And a second item back in the containing list. No blank line
needed, but it wouldn't hurt for readability.
Definition lists (with a term and its definition) are a convenient way
to document a word or phrase with an explanation. For example this reST
content:
The Makefile has targets that include:
html
Build the HTML output for the project
clean
Remove all generated output, restoring the folders to a
clean state.
Would be rendered as:
The Makefile has targets that include:
html
Build the HTML output for the project
clean
Remove all generated output, restoring the folders to a
clean state.
If you have a long bullet list of items, where each item is short, you
can indicate the list items should be rendered in multiple columns with
a special ..rst-class::rst-columns directive. The directive will
apply to the next non-comment element (e.g., paragraph), or to content
indented under the directive. For example, this unordered list:
..rst-class:: rst-columns
* A list of
* short items
* that should be
* displayed
* horizontally
* so it doesn't
* use up so much
* space on
* the page
would be rendered as:
A list of
short items
that should be
displayed
horizontally
so it doesn’t
use up so much
space on
the page
A maximum of three columns will be displayed, and change based on the
available width of the display window, reducing to one column on narrow
(phone) screens if necessary. We’ve deprecated use of the hlist
directive because it misbehaves on smaller screens.
There are a few ways to create tables, each with their limitations or
quirks. Grid tables
offer the most capability for defining merged rows and columns, but are
hard to maintain:
+------------------------+------------+----------+----------+
| Header row, column 1 | Header 2 | Header 3 | Header 4 |
| (header rows optional) | | | |
+========================+============+==========+==========+
| body row 1, column 1 | column 2 | column 3 | column 4 |
+------------------------+------------+----------+----------+
| body row 2 | ... | ... | you can |
+------------------------+------------+----------+ easily +
| body row 3 with a two column span | ... | span |
+------------------------+------------+----------+ rows +
| body row 4 | ... | ... | too |
+------------------------+------------+----------+----------+
This example would render as:
Header row, column 1
(header rows optional)
Header 2
Header 3
Header 4
body row 1, column 1
column 2
column 3
column 4
body row 2
…
…
you can
easily
span
rows
too
body row 3 with a two column span
…
body row 4
…
…
List tables
are much easier to maintain, but don’t support row or column spans:
..list-table:: Table title
:widths: 15 20 40
:header-rows: 1
* - Heading 1
- Heading 2
- Heading 3
* - body row 1, column 1
- body row 1, column 2
- body row 1, column 3
* - body row 2, column 1
- body row 2, column 2
- body row 2, column 3
The :widths: parameter lets you define relative column widths. The
default is equal column widths. If you have a three-column table and you
want the first column to be half as wide as the other two equal-width
columns, you can specify :widths:122. If you’d like the browser
to set the column widths automatically based on the column contents, you
can use :widths:auto.
As introduced in the Getting Started Guide, you can provide alternative
content to the reader via a tabbed interface. When the reader clicks on
a tab, the content for that tab is displayed, for example:
..tabs:: ..tab:: Apples
Apples are green, or sometimes red.
..tab:: Pears
Pears are green.
..tab:: Oranges
Oranges are orange.
will display as:
Apples are green, or sometimes red.
Pears are green.
Oranges are orange.
Tabs can also be grouped, so that changing the current tab in one area
changes all tabs with the same name throughout the page. For example:
Linux Line 1
macOS Line 1
Windows Line 1
Linux Line 2
macOS Line 2
Windows Line 2
In this latter case, we’re using ..group-tab:: instead of simply
..tab::. Under the hood, we’re using the sphinx-tabs extension that’s included
in the Zephyr setup. Within a tab, you can have most any content other
than a heading (code-blocks, ordered and unordered lists, pictures,
paragraphs, and such). You can read more about sphinx-tabs from the
link above.
two asterisks: **text** for strong emphasis (boldface), and
two backquotes: ``text`` for inlinecode samples.
If asterisks or backquotes appear in running text and could be confused with
inline markup delimiters, you can eliminate the confusion by adding a
backslash (\) before it.
Sphinx extends reST by supporting additional inline markup elements (called
“roles”) used to tag text with special
meanings and allow style output formatting. (You can refer to the Sphinx Inline Markup[3]
documentation for the full list).
While double quotes can be used for rendering text as “code”, you are encouraged to use the
following roles for marking up file names, command names, and other “special” text.
file for file names, e.g., :file:`CMakeLists.txt` will render as
CMakeLists.txt
Note
In case you want to indicate a “variable” file path, you may use curly braces to enclose the
variable part of the path, e.g., :file:`{boardname}_defconfig` will render as
boardname_defconfig.
command for command names, e.g., :command:`make` will render as make
envvar for environment variables, e.g., :envvar:`ZEPHYR_BASE` will render as
ZEPHYR_BASE
When documenting user interactions, such as key combinations or GUI interactions, use the following
roles to highlight the commands in a meaningful way:
kbd for keyboard input, e.g., :kbd:`Ctrl-C` will render as Ctrl-C
menuselection for menu selections, e.g., :menuselection:`File-->Open` will render
as File ‣ Open
guilabel for GUI labels, e.g., :guilabel:`Cancel` will render as Cancel
You can include mathematical formulas using either the math role or math
directive. The directive provides more flexibility in case you have a more complex formula.
The input language for mathematics is LaTeX markup. Example:
The answer to life, the universe, and everything is :math:`30 + 2^2 + \sqrt{64} = 42`.
This would render as:
The answer to life, the universe, and everything is \(30 + 2^2 + \sqrt{64} = 42\).
Prefer plain ASCII unless a specific symbol is required for correctness or conventional typography
(for example units like µ, or well-known marks like ™).
Avoid adding non-ASCII characters purely for aesthetic purposes.
The file doc/substitutions.txt contains some basic HTML substitution definitions for
special formatting needs (e.g. to force line breaks), but Unicode characters can and should be used
directly in the documentation source files.
Use the reST code-block directive to create a highlighted block of
fixed-width text, typically used for showing formatted code or console
commands and output. Smart syntax highlighting is also supported (using the
Pygments package). You can also directly specify the highlighting language.
For example:
Note the blank line between the code-block directive and the first
line of the code-block body, and the body content is indented three
spaces (to the first non-white space of the directive name).
Other languages are of course supported (see languages supported by Pygments[8]), and in particular,
you are encouraged to make use of the following when appropriate:
c for C code
cpp for C++ code
python for Python code
console for console output, i.e. interactive shell sessions where commands are prefixed by a
prompt (ex. $ for Linux, or uart:~$ for Zephyr’s shell), and where the output is also
shown. The commands will be highlighted, and the output will not. What’s more, copying code block
using the “copy” button will automatically copy just the commands, excluding the prompt and the
outputs of the commands.
shell or bash for shell commands. Both languages get highlighted the same but you may use
bash for conveying that the commands are bash-specific, and shell for generic shell
commands.
Note
Do not use bash or shell if your code block includes a prompt, use console instead.
Reciprocally, do not use console if your code block does not include a prompt and is not
showcasing an interactive session with command(s) and their output.
An interactive Zephyr shell session, with commands and their outputs
..code-block::consoleuart:~$ version
Zephyr version 3.5.99uart:~$ kerneluptime
Uptime: 20970 ms
uart:~$ version
Zephyr version 3.5.99uart:~$ kerneluptime
Uptime: 20970 ms
bat for Windows batch files
cfg for config files with “KEY=value” entries (ex. Kconfig .conf files)
cmake for CMake
devicetree for Devicetree
kconfig for Kconfig
yaml for YAML
rst for reStructuredText
When no language is specified, the language is set to none and the code block is not
highlighted. You may also use none explicitly to achieve the same result; for example:
..code-block::none This would be a block of text styled with a background and box, but with no syntax highlighting.
Would display as:
This would be a block of text styled with a background
and box, but with no syntax highlighting.
There’s a shorthand for writing code blocks too: end the introductory paragraph with a double colon
(::) and indent the code block content that follows it by three spaces. On output, only one
colon will be shown. The code block will have no highlighting (i.e. none). You may however use
the highlight directive to customize the default language used in your document (see for
example how this is done at the beginning of this very document).
Note the use of a trailing
underscore to indicate an outbound link. In this example, the label was
added immediately before a heading, so the text that’s displayed is the
heading text itself. You can change the text that’s displayed as the
link writing this as:
Refer to the `show this text instead <internal-linking_>`_ page
With Sphinx’s help, we can create
link-references to any tagged text within the Zephyr Project documentation.
Target locations in a document are defined with a label directive:
.._my label name:Heading=======
Note the leading underscore indicating an inbound link.
The content immediately following
this label must be a heading, and is the target for a :ref:`mylabelname`
reference from anywhere within the Zephyr documentation.
The heading text is shown when referencing this label.
You can also change the text that’s displayed for this link, such as:
:ref:`some other text <my label name>`
To enable easy cross-page linking within the site, each file should have
a reference label before its title so it can
be referenced from another file. These reference labels must be unique
across the whole site, so generic names such as “samples” should be
avoided. For example the top of this document’s .rst file is:
.._doc_guidelines:Documentation Guidelines for the Zephyr Project###############################################
Other .rst documents can link to this document using the :ref:`doc_guidelines` tag and
it will show up as Documentation Guidelines. This type of internal cross reference works across
multiple files, and the link text is obtained from the document source so if the title changes,
the link text will update as well.
You can also define links to any URL and then reference it in your document.
For example, with this label definition in the document:
.._Zephyr Wikipedia Page:
https://en.wikipedia.org/wiki/Zephyr_(operating_system)
you can reference it with:
Read the `Zephyr Wikipedia Page`_ for more information about the
project.
Tip
When a document contains many external links, it can be useful to list them in a single
“References” section at the end of the document. This can be done using the
target-notes directive. Example:
Images are included in the documentation by using an image directive:
..image:: ../../../../images/doc-gen-flow.png
:align: center
:alt: alt text for the image
or if you’d like to add an image caption, use:
..figure:: ../../../../images/doc-gen-flow.png
:alt: image description
Caption for the figure
The file name specified is relative to the document source file,
and we recommend putting images into an images folder where the document
source is found.
The usual image formats handled by a web browser are supported: WebP, PNG, GIF,
JPEG, and SVG.
Keep the image size only as large as needed, generally at least 500 px wide but
no more than 1000 px, and no more than 100 KB unless a particularly large image
is needed for clarity.
Graphviz[9] is a tool for creating diagrams specified in a simple text language. As it’s important
to allow for diagrams used in the documentation to be easily maintained, we encourage the use of
Graphviz for creating diagrams. Graphviz is particularly well suited for creating state diagrams, flow
charts, and other types of diagrams that can be expressed as a graph.
To include a Graphviz diagram in a document, use the graphviz directive. For example:
..graphviz:::caption: An example graph using Graphviz
digraph G {
rankdir=LR;
A -> B;
B -> C;
C -> D;
}
The Zephyr documentation uses custom Sphinx roles and directives to provide additional functionality
and to make it easier to write and maintain consistent documentation.
If set, the application build directory will APPEND this relative, Unix-separated, path to
the standard build directory. This is mostly useful for distinguishing builds for one
application within a single page.
If set, this indicates the reader may have already created a build directory and changed
there, and will tweak the text to note that doing so again is not necessary.
The role automatically verifies that the referenced file exists in the Zephyr tree and will
generate a warning during documentation build if the file is not found.
Note
Use the line references sparingly as keeping them accurate over time can be challenging as the
content of the linked file is subject to change.
You may use the zephyr_raw role instead if you want to reference the “raw” content.
This directive is used to output a short description of a Doxygen group and a link to the
corresponding Doxygen-generated documentation.
All the code samples (declared using the zephyr:code-sample directive) indicating the
group as relevant will automatically be list and referenced in the rendered output.
This role is used to reference a Doxygen group in the Zephyr tree. In the HTML documentation,
they are rendered as links to the corresponding Doxygen-generated documentation for the group.
For example:
Check out :c:group:`gpio_interface` for more information.
If you want to reference a Kconfig option from a document, you can use the
kconfig:option role and provide the name of the option you want to reference. The role
will automatically generate a link to the documentation of the Kconfig option when building HTML
output.
Make sure to use the full name of the Kconfig option, including the CONFIG_ prefix.
This role is used to create links to regex searches for Kconfig options. It generates a link to
the Kconfig search page with the provided regex pattern automatically filled in as the search
query. It is useful for referencing multiple Kconfig options that share a common prefix, or
belong to a common category. For example:
Check out :kconfig:option-regex:`CONFIG_SECURE_STORAGE_ITS_(STORE|TRANSFORM)_.*_CUSTOM` for
the various customization possibilities.
If you want to reference a Devicetree binding from a document, you can use the
dtcompatible role and provide the compatible string of the binding you want to
reference. The role will automatically generate a link to the documentation of the binding when
building HTML output.
This role can be used inline to make a reference to the generated documentation for the
Devicetree compatible given as argument.
There may be more than one page for a single compatible. For example, that happens if a binding
behaves differently depending on the bus the node is on. If that occurs, the reference points at
a “disambiguation” page which links out to all the possibilities, similarly to how Wikipedia
disambiguation pages work. Example:
Check out :dtcompatible:`zephyr,input-longpress` for more information.
If set, a listing of code samples in the category will be shown. The listing is automatically
generated based on all code samples found in the subdirectories of the current document.
A glob pattern to match the files to include in the listing. The default is */* but it can
be overridden e.g. when samples may be found in directories not sitting directly under the
category directory.
A flag to include a search box right above the listing. The search box allows users to filter
the listing by code sample name/description, which can be useful for categories with a large
number of samples. This option is only available in the HTML builder.
This directive is used at the beginning of a document to indicate it is the main documentation
page for a board whose name is given as the directive argument.
For example:
..zephyr:board:: wio_terminal
The metadata for the board is read from various config files and used to automatically populate
some sections of the board documentation. A board documentation page that uses this directive
can be linked to using the zephyr:board role.
This directive is used to generate a catalog of Zephyr-supported boards that can be used to
quickly browse the list of all supported boards and filter them according to various criteria.
This directive is used to show supported hardware features for all the targets of the board
documented in the current page. The tables are automatically generated based on the board’s
Devicetree.
The directive must be used in a document that also contains a zephyr:board directive,
as it relies on the board information to generate the table.
Note
This directive requires that the documentation is built with hardware features generation enabled
(zephyr_generate_hw_features config option set to True). If disabled, a warning message
will be shown instead of the hardware features tables.
It is possible to limit the hardware features generation to boards from a specific list of vendors
to speed up documentation builds without completely disabling the hardware features table. Set the
config option zephyr_hw_features_vendor_filter to the list of vendors to generate features for.
If the option is empty, hardware features are generated for all boards from all vendors.
This directive is used to show the supported runners for the board documented in the current
page, including which runner is the default for flashing and debugging.
The directive must be used in a document that also contains a zephyr:board directive,
as it relies on the board information to generate the table.
Note
Similar to zephyr:board-supported-hw, this directive requires hardware features
generation to be enabled (zephyr_generate_hw_features config option set to True) to
produce a complete table. If disabled, a warning message will be shown instead of the runners
tables.
Accessibility is an important aspect of documentation, ensuring that all users, including those with
disabilities, can access and understand the content.
When writing and maintaining Zephyr Project documentation, please follow these guidelines to improve
accessibility for everyone.
All images and figures must include appropriate alternative text (alt text) to convey the meaning of
the visual content to users who rely on screen readers or cannot view images.
Use the :alt: attribute when including images using the image directive. Example:
..image:: ../../../../contribute/documentation/image/doc-gen-flow.png
:alt: Documentation generation process overview
If the image contains text, ensure that the alt text includes this text verbatim.
When using the figure directive, which allows for a caption, the :alt: text is
still important. The alt text should describe the image itself, while the caption provides
additional context or interpretation. Example:
..figure:: ../../../../images/arch-diagram.png
:alt: High-level overview of Zephyr OS architecture showing layers and components.
High-level overview of Zephyr OS architecture.
Avoid using images as the sole method of conveying information that can be explained
clearly with text.
Best Practices for writing alt text
Be Accurate and Equivalent: Present the same essential information as the image.
Be Succinct: Convey the core message of the image concisely.
Avoid Redundancy: Do not use phrases like “Image of…” or “Picture of…” as screen readers
typically announce the element as an image.
Describe, Don’t Interpret: Stick to describing what is visually present on the image.
Complex Images: For charts, diagrams, or other complex visuals, provide a summary in the alt
text. If a full understanding requires more detail, consider providing a more detailed
description in the surrounding text or as part of the figure caption. Using text-based diagram
tools like Graphviz can also improve accessibility.
Use headings to structure your document logically. This allows users of assistive
technologies to understand the document’s organization and navigate it efficiently.