The latest development version of this page may be more current than this released 3.7.0 version.

Contribution Guidelines

As an open-source project, we welcome and encourage the community to submit patches directly to the project. In our collaborative open source environment, standards and methods for submitting changes help reduce the chaos that can result from an active development community.

This document explains how to participate in project conversations, log bugs and enhancement requests, and submit patches to the project so your patch will be accepted quickly in the codebase.

Licensing

Licensing is very important to open source projects. It helps ensure the software continues to be available under the terms that the author desired.

Zephyr uses the Apache 2.0 license (as found in the LICENSE file in the project’s GitHub repo) to strike a balance between open contribution and allowing you to use the software however you would like to. The Apache 2.0 license is a permissive open source license that allows you to freely use, modify, distribute and sell your own products that include Apache 2.0 licensed software. (For more information about this, check out articles such as Why choose Apache 2.0 licensing and Top 10 Apache License Questions Answered).

A license tells you what rights you have as a developer, as provided by the copyright holder. It is important that the contributor fully understands the licensing rights and agrees to them. Sometimes the copyright holder isn’t the contributor, such as when the contributor is doing work on behalf of a company.

Components using other Licenses

There are some imported or reused components of the Zephyr project that use other licensing, as described in Licensing of Zephyr Project components.

Importing code into the Zephyr OS from other projects that use a license other than the Apache 2.0 license needs to be fully understood in context and approved by the Zephyr governing board.

By carefully reviewing potential contributions and also enforcing a Developer Certification of Origin (DCO) for contributed code, we can ensure that the Zephyr community can develop products with the Zephyr Project without concerns over patent or copyright issues.

See Contributing External Components for more information about this contributing and review process for imported components.

Copyrights Notices

Please follow this Community Best Practice for Copyright Notices from the Linux Foundation.

Developer Certification of Origin (DCO)

To make a good faith effort to ensure licensing criteria are met, the Zephyr project requires the Developer Certificate of Origin (DCO) process to be followed.

The DCO is an attestation attached to every contribution made by every developer. In the commit message of the contribution, (described more fully later in this document), the developer simply adds a Signed-off-by statement and thereby agrees to the DCO.

When a developer submits a patch, it is a commitment that the contributor has the right to submit the patch per the license. The DCO agreement is shown below and at http://developercertificate.org/.

Developer's Certificate of Origin 1.1

By making a contribution to this project, I certify that:

(a) The contribution was created in whole or in part by me and I
    have the right to submit it under the open source license
    indicated in the file; or

(b) The contribution is based upon previous work that, to the
    best of my knowledge, is covered under an appropriate open
    source license and I have the right under that license to
    submit that work with modifications, whether created in whole
    or in part by me, under the same open source license (unless
    I am permitted to submit under a different license), as
    Indicated in the file; or

(c) The contribution was provided directly to me by some other
    person who certified (a), (b) or (c) and I have not modified
    it.

(d) I understand and agree that this project and the contribution
    are public and that a record of the contribution (including
    all personal information I submit with it, including my
    sign-off) is maintained indefinitely and may be redistributed
    consistent with this project or the open source license(s)
    involved.

DCO Sign-Off

The “sign-off” in the DCO is a “Signed-off-by:” line in each commit’s log message. The Signed-off-by: line must be in the following format:

Signed-off-by: Your Name <your.email@example.com>

For your commits, replace:

  • Your Name with your legal name (pseudonyms, hacker handles, and the names of groups are not allowed)

  • your.email@example.com with the same email address you are using to author the commit (CI will fail if there is no match)

You can automatically add the Signed-off-by: line to your commit body using git commit -s. Use other commits in the zephyr git history as examples. See Git Setup for instructions on configuring user and email settings in Git.

Additional requirements:

  • If you are altering an existing commit created by someone else, you must add your Signed-off-by: line without removing the existing one.

  • If you forget to add the Signed-off-by: line, you can add it to your previous commit by running git commit --amend -s.

  • If you’ve pushed your changes to GitHub already you’ll need to force push your branch after this with git push -f.

Notes

Any contributions made as part of submitted pull requests are considered free for the Project to use. Developers are permitted to cherry-pick patches that are included in pull requests submitted by other contributors. It is expected that

  • the content of the patches will not be substantially modified,

  • the cherry-picked commits or portions of a commit shall preserve the original sign-off messages and the author identity.

Modifying Contributions made by other developers describes additional recommended policies around working with contributions submitted by other developers.

Prerequisites

As a contributor, you’ll want to be familiar with the Zephyr project, how to configure, install, and use it as explained in the Zephyr Project website and how to set up your development environment as introduced in the Zephyr Getting Started Guide.

You should be familiar with common developer tools such as Git and CMake, and platforms such as GitHub.

If you haven’t already done so, you’ll need to create a (free) GitHub account on https://github.com and have Git tools available on your development system.

Note

The Zephyr development workflow supports all 3 major operating systems (Linux, macOS, and Windows) but some of the tools used in the sections below are only available on Linux and macOS. On Windows, instead of running these tools yourself, you will need to rely on the Continuous Integration (CI) service using Github Actions, which runs automatically on GitHub when you submit your Pull Request (PR). You can see any failure results in the workflow details link near the end of the PR conversation list. See Continuous Integration for more information

Source Tree Structure

To clone the main Zephyr Project repository use the instructions in Get Zephyr and install Python dependencies.

This section describes the main repository’s source tree. In addition to the Zephyr kernel itself, you’ll also find the sources for technical documentation, sample code, supported board configurations, and a collection of subsystem tests. All of these are available for developers to contribute to and enhance.

Understanding the Zephyr source tree can help locate the code associated with a particular Zephyr feature.

At the top of the tree, several files are of importance:

CMakeLists.txt

The top-level file for the CMake build system, containing a lot of the logic required to build Zephyr.

Kconfig

The top-level Kconfig file, which refers to the file Kconfig.zephyr also found in the top-level directory.

See the Kconfig section of the manual for detailed Kconfig documentation.

west.yml

The West (Zephyr’s meta-tool) manifest, listing the external repositories managed by the west command-line tool.

The Zephyr source tree also contains the following top-level directories, each of which may have one or more additional levels of subdirectories not described here.

arch

Architecture-specific kernel and system-on-chip (SoC) code. Each supported architecture (for example, x86 and ARM) has its own subdirectory, which contains additional subdirectories for the following areas:

  • architecture-specific kernel source files

  • architecture-specific kernel include files for private APIs

soc

SoC related code and configuration files.

boards

Board related code and configuration files.

doc

Zephyr technical documentation source files and tools used to generate the https://docs.zephyrproject.org web content.

drivers

Device driver code.

dts

devicetree source files used to describe non-discoverable board-specific hardware details.

include

Include files for all public APIs, except those defined under lib.

kernel

Architecture-independent kernel code.

lib

Library code, including the minimal standard C library.

misc

Miscellaneous code that doesn’t belong to any of the other top-level directories.

samples

Sample applications that demonstrate the use of Zephyr features.

scripts

Various programs and other files used to build and test Zephyr applications.

cmake

Additional build scripts needed to build Zephyr.

subsys

Subsystems of Zephyr, including:

  • USB device stack code

  • Networking code, including the Bluetooth stack and networking stacks

  • File system code

  • Bluetooth host and controller

tests

Test code and benchmarks for Zephyr features.

share

Additional architecture independent data. It currently contains Zephyr’s CMake package.

Pull Requests and Issues

Before starting on a patch, first check in our issues Zephyr Project Issues system to see what’s been reported on the issue you’d like to address. Have a conversation on the Zephyr devel mailing list (or the Zephyr Discord Server) to see what others think of your issue (and proposed solution). You may find others that have encountered the issue you’re finding, or that have similar ideas for changes or additions. Send a message to the Zephyr devel mailing list to introduce and discuss your idea with the development community.

It’s always a good practice to search for existing or related issues before submitting your own. When you submit an issue (bug or feature request), the triage team will review and comment on the submission, typically within a few business days.

You can find all open pull requests on GitHub and open Zephyr Project Issues in Github issues.

Git Setup

We need to know who you are, and how to contact you. To add this information to your Git installation, set the Git configuration variables user.name to your full name, and user.email to your email address.

For example, if your name is Zephyr Developer and your email address is z.developer@example.com:

git config --global user.name "Zephyr Developer"
git config --global user.email "z.developer@example.com"

Pull Request Guidelines

When opening a new Pull Request, adhere to the following guidelines to ensure compliance with Zephyr standards and facilitate the review process.

If in doubt, it’s advisible to explore existing Pull Requests within the Zephyr repository. Use the search filters and labels to locate PRs related to changes similar to the ones you are proposing.

Commit Message Guidelines

Changes are submitted as Git commits. Each commit has a commit message describing the change. Acceptable commit messages look like this:

[area]: [summary of change]

[Commit message body (must be non-empty)]

Signed-off-by: [Your Full Name] <[your.email@address]>

You need to change text in square brackets ([like this]) above to fit your commit.

Examples and more details follow.

Example

Here is an example of a good commit message.

drivers: sensor: abcd1234: fix bus I/O error handling

The abcd1234 sensor driver is failing to check the flags field in
the response packet from the device which signals that an error
occurred. This can lead to reading invalid data from the response
buffer. Fix it by checking the flag and adding an error path.

Signed-off-by: Zephyr Developer <z.developer@example.com>

[area]: [summary of change]

This line is called the commit’s title. Titles must be:

  • one line

  • less than 72 characters long

  • followed by a completely blank line

[area]

The [area] prefix usually identifies the area of code being changed. It can also identify the change’s wider context if multiple areas are affected.

Here are some examples:

  • doc: ... for documentation changes

  • drivers: foo: for foo driver changes

  • Bluetooth: Shell: for changes to the Bluetooth shell

  • net: ethernet: for Ethernet-related networking changes

  • dts: for treewide devicetree changes

  • style: for code style changes

If you’re not sure what to use, try running git log FILE, where FILE is a file you are changing, and using previous commits that changed the same file as inspiration.

[summary of change]

The [summary of change] part should be a quick description of what you’ve done. Here are some examples:

  • doc: update wiki references to new site

  • drivers: sensor: sensor_shell: fix channel name collision

Commit Message Body

Warning

An empty commit message body is not permitted. Even for trivial changes, please include a descriptive commit message body. Your pull request will fail CI checks if you do not.

This part of the commit should explain what your change does, and why it’s needed. Be specific. A body that says "Fixes stuff" will be rejected. Be sure to include the following as relevant:

  • what the change does,

  • why you chose that approach,

  • what assumptions were made, and

  • how you know it works – for example, which tests you ran.

Each line in your commit message should usually be 75 characters or less. Use newlines to wrap longer lines. Exceptions include lines with long URLs, email addresses, etc.

For examples of accepted commit messages, you can refer to the Zephyr GitHub changelog.

Signed-off-by: …

Tip

You should have set your Git Setup already. Create your commit with git commit -s to add the Signed-off-by: line automatically using this information.

For open source licensing reasons, your commit must include a Signed-off-by: line that looks like this:

Signed-off-by: [Your Full Name] <[your.email@address]>

For example, if your full name is Zephyr Developer and your email address is z.developer@example.com:

Signed-off-by: Zephyr Developer <z.developer@example.com>

This means that you have personally made sure your change complies with the Developer Certification of Origin (DCO). For this reason, you must use your legal name. Pseudonyms or “hacker aliases” are not permitted.

Your name and the email address you use must match the name and email in the Git commit’s Author: field.

See the Contributor Expectations for a more complete discussion of contributor and reviewer expectations.

Coding Style

In general, follow the Linux kernel coding style, with the following exceptions:

  • The line length is 100 columns or fewer. In the documentation, longer lines for URL references are an allowed exception.

  • Add braces to every if, else, do, while, for and switch body, even for single-line code blocks. Use the --ignore BRACES flag to make checkpatch stop complaining.

  • Use spaces instead of tabs to align comments after declarations, as needed.

  • Use C89-style single line comments, /*  */. The C99-style single line comment, //, is not allowed.

  • Use /**  */ for doxygen comments that need to appear in the documentation.

  • Avoid using binary literals (constants starting with 0b).

  • Avoid using non-ASCII symbols in code, unless it significantly improves clarity, avoid emojis in any case.

Use these coding guidelines to ensure that your development complies with the project’s style and naming conventions.

The Linux kernel GPL-licensed tool checkpatch is used to check coding style conformity.

Note

checkpatch does not currently run on Windows.

Checkpatch is available in the scripts directory. To invoke it when committing code, make the file $ZEPHYR_BASE/.git/hooks/pre-commit executable and edit it to contain:

#!/bin/sh
set -e exec
exec git diff --cached | ${ZEPHYR_BASE}/scripts/checkpatch.pl -

Instead of running checkpatch at each commit, you may prefer to run it only before pushing on zephyr repo. To do this, make the file $ZEPHYR_BASE/.git/hooks/pre-push executable and edit it to contain:

#!/bin/sh
remote="$1"
url="$2"

z40=0000000000000000000000000000000000000000

echo "Run push hook"

while read local_ref local_sha remote_ref remote_sha
do
    args="$remote $url $local_ref $local_sha $remote_ref $remote_sha"
    exec ${ZEPHYR_BASE}/scripts/series-push-hook.sh $args
done

exit 0

If you want to override checkpatch verdict and push you branch despite reported issues, you can add option –no-verify to the git push command.

A more complete alternative to this is using check_compliance.py script.

clang-format

The clang-format tool can be helpful to quickly reformat large amounts of new source code to our Coding Style standards together with the .clang-format configuration file provided in the repository. clang-format is well integrated into most editors, but you can also run it manually like this:

clang-format -i my_source_file.c

clang-format is part of LLVM, which can be downloaded from the project releases page. Note that if you are a Linux user, clang-format will likely be available as a package in your distribution repositories.

When there are differences between the Coding Style guidelines and the formatting generated by code formatting tools, the Coding Style guidelines take precedence. If there is ambiguity between formatting tools and the guidelines, maintainers may decide which style should be adopted.

Continuous Integration (CI)

The Zephyr Project operates a Continuous Integration (CI) system that runs on every Pull Request (PR) in order to verify several aspects of the PR:

  • Git commit formatting

  • Coding Style

  • Twister builds for multiple architectures and boards

  • Documentation build to verify any doc changes

CI is run on Github Actions and it uses the same tools described in the CI Tests section. The CI results must be green indicating “All checks have passed” before the Pull Request can be merged. CI is run when the PR is created, and again every time the PR is modified with a commit.

The current status of the CI run can always be found at the bottom of the GitHub PR page, below the review status. Depending on the success or failure of the run you will see:

  • “All checks have passed”

  • “All checks have failed”

In case of failure you can click on the “Details” link presented below the failure message in order to navigate to Github Actions and inspect the results. Once you click on the link you will be taken to the Github actions summary results page where a table with all the different builds will be shown. To see what build or test failed click on the row that contains the failed (i.e. non-green) build.

Running CI Tests Locally

check_compliance.py

The check_compliance.py script serves as a valuable tool for assessing code compliance with Zephyr’s established guidelines and best practices. The script acts as wrapper for a suite of tools that performs various checks, including linters and formatters.

Developers are encouraged to run the script locally to validate their changes before opening a new Pull Request:

./scripts/ci/check_compliance.py -c upstream/main..

twister

Note

twister is only fully supported on Linux; on Windows and MacOS the execution of tests is not supported, only building.

If you think your change may break some test, you can submit your PR as a draft and let the project CI automatically run the Test Runner (Twister) for you.

If a test fails, you can check from the CI run logs how to rerun it locally, for example:

west twister -p native_sim -s tests/drivers/build_all/sensor/sensors.generic_test

Static Code Analysis

Coverity Scan is a free service for static code analysis of Open Source projects. It is based on Coverity’s commercial product and is able to analyze C, C++ and Java code.

Coverity’s static code analysis doesn’t run the code. Instead of that it uses abstract interpretation to gain information about the code’s control flow and data flow. It’s able to follow all possible code paths that a program may take. For example the analyzer understands that malloc() returns a memory that must be freed with free() later. It follows all branches and function calls to see if all possible combinations free the memory. The analyzer is able to detect all sorts of issues like resource leaks (memory, file descriptors), NULL dereferencing, use after free, unchecked return values, dead code, buffer overflows, integer overflows, uninitialized variables, and many more.

The results are available on the Coverity Scan website. In order to access the results you have to create an account yourself. From the Zephyr project page, you may select “Add me to project” to be added to the project. New members must be approved by an admin.

Static analysis of the Zephyr codebase is conducted on a bi-weekly basis. GitHub issues are automatically created for any issues detected by static analysis tools. These issues will have the same (or equivalent) priority initially defined by the tool.

To ensure accountability and efficient issue resolution, they are assigned to the respective maintainer who is responsible for the affected code.

A dedicated team comprising members with expertise in static analysis, code quality, and software security ensures the effectiveness of the static analysis process and verifies that identified issues are properly triaged and resolved in a timely manner.

Workflow

If after analyzing the Coverity report it is concluded that it is a false positive please set the classification to either “False positive” or “Intentional”, the action to “Ignore”, owner to your own account and add a comment why the issue is considered false positive or intentional.

Update the related Github issue in the zephyr project with the details, and only close it after completing the steps above on scan service website. Any issues closed without a fix or without ignoring the entry in the scan service will be automatically reopened if the issue continues to be present in the code.

Contribution Workflow

One general practice we encourage, is to make small, controlled changes. This practice simplifies review, makes merging and rebasing easier, and keeps the change history clear and clean.

When contributing to the Zephyr Project, it is also important you provide as much information as you can about your change, update appropriate documentation, and test your changes thoroughly before submitting.

The general GitHub workflow used by Zephyr developers uses a combination of command line Git commands and browser interaction with GitHub. As it is with Git, there are multiple ways of getting a task done. We’ll describe a typical workflow here:

  1. Create a Fork of Zephyr to your personal account on GitHub. (Click on the fork button in the top right corner of the Zephyr project repo page in GitHub.)

  2. On your development computer, change into the zephyr folder that was created when you obtained the code:

    cd zephyrproject/zephyr

    Rename the default remote pointing to the upstream repository from origin to upstream:

    git remote rename origin upstream

    Let Git know about the fork you just created, naming it origin:

    git remote add origin https://github.com/<your github id>/zephyr

    and verify the remote repos:

    git remote -v

    The output should look similar to:

    origin   https://github.com/<your github id>/zephyr (fetch)
origin   https://github.com/<your github id>/zephyr (push)
upstream https://github.com/zephyrproject-rtos/zephyr (fetch)
upstream https://github.com/zephyrproject-rtos/zephyr (push)

  3. Create a topic branch (off of main) for your work (if you’re addressing an issue, we suggest including the issue number in the branch name):

    git checkout main
git checkout -b fix_comment_typo

    Some Zephyr subsystems do development work on a separate branch from main so you may need to indicate this in your checkout:

    git checkout -b fix_out_of_date_patch origin/net

  4. Make changes, test locally, change, test, test again, … (Check out the prior chapter on twister as well).

  5. When things look good, start the pull request process by adding your changed files:

    git add [file(s) that changed, add -p if you want to be more specific]

    You can see files that are not yet staged using:

    git status

  6. Verify changes to be committed look as you expected:

    git diff --cached

  7. Commit your changes to your local repo:

    git commit -s

    The -s option automatically adds your Signed-off-by: to your commit message. Your commit will be rejected without this line that indicates your agreement with the Developer Certification of Origin (DCO). See the Commit Message Guidelines section for specific guidelines for writing your commit messages.

  8. Push your topic branch with your changes to your fork in your personal GitHub account:

    git push origin fix_comment_typo

  9. In your web browser, go to your forked repo and click on the Compare & pull request button for the branch you just worked on and you want to open a pull request with.

  10. Review the pull request changes, and verify that you are opening a pull request for the main branch. The title and message from your commit message should appear as well.

  11. A bot will assign one or more suggested reviewers (based on the MAINTAINERS file in the repo). If you are a project member, you can select additional reviewers now too.

  12. Click on the submit button and your pull request is sent and awaits review. Email will be sent as review comments are made, or you can check on your pull request at https://github.com/zephyrproject-rtos/zephyr/pulls.

    Note

    As more commits are merged upstream, the GitHub PR page will show a This branch is out-of-date with the base branch message and a Update branch button on the PR page. That message should be ignored, as the commits will be rebased as part of merging anyway, and triggering a branch update from the GitHub UI will cause the PR approvals to be dropped.

  13. While you’re waiting for your pull request to be accepted and merged, you can create another branch to work on another issue. (Be sure to make your new branch off of main and not the previous branch.):

    git checkout main
git checkout -b fix_another_issue

    and use the same process described above to work on this new topic branch.

  14. If reviewers do request changes to your patch, you can interactively rebase commit(s) to fix review issues. In your development repo:

    git rebase -i <offending-commit-id>^

    In the interactive rebase editor, replace pick with edit to select a specific commit (if there’s more than one in your pull request), or remove the line to delete a commit entirely. Then edit files to fix the issues in the review.

    As before, inspect and test your changes. When ready, continue the patch submission:

    git add [file(s)]
git rebase --continue

    Update commit comment if needed, and continue:

    git push --force origin fix_comment_typo

    By force pushing your update, your original pull request will be updated with your changes so you won’t need to resubmit the pull request.

  15. After pushing the requested change, check on the PR page if there is a merge conflict. If so, rebase your local branch:

    git fetch --all
git rebase --ignore-whitespace upstream/main

    The --ignore-whitespace option stops git apply (called by rebase) from changing any whitespace. Resolve the conflicts and push again:

    git push --force origin fix_comment_typo

    Note

    While amending commits and force pushing is a common review model outside GitHub, and the one recommended by Zephyr, it’s not the main model supported by GitHub. Forced pushes can cause unexpected behavior, such as not being able to use “View Changes” buttons except for the last one - GitHub complains it can’t find older commits. You’re also not always able to compare the latest reviewed version with the latest submitted version. When rewriting history GitHub only guarantees access to the latest version.

  16. If the CI run fails, you will need to make changes to your code in order to fix the issues and amend your commits by rebasing as described above. Additional information about the CI system can be found in Continuous Integration.

Contribution Tips

The following is a list of tips to improve and accelerate the review process of Pull Requests. If you follow them, chances are your pull request will get the attention needed and it will be ready for merge sooner than later:

  1. When pushing follow-up changes, use the --keep-base option of git-rebase

  2. On the PR page, check if the change can still be merged with no merge conflicts

  3. Make sure title of PR explains what is being fixed or added

  4. Make sure your PR has a body with more details about the content of your submission

  5. Make sure you reference the issue you are fixing in the body of the PR

  6. Watch early CI results immediately after submissions and fix issues as they are discovered

  7. Revisit PR after 1-2 hours to see the status of all CI checks, make sure all is green

  8. If you get request for changes and submit a change to address them, make sure you click the “Re-request review” button on the GitHub UI to notify those who asked for the changes

Submitting Proposals

You can request a new feature or submit a proposal by submitting an issue to our GitHub Repository. If you would like to implement a new feature, please submit an issue with a proposal (RFC) for your work first, to be sure that we can use it. Please consider what kind of change it is:

  • For a Major Feature, first open an issue and outline your proposal so that it can be discussed. This will also allow us to better coordinate our efforts, prevent duplication of work, and help you to craft the change so that it is successfully accepted into the project. Providing the following information will increase the chances of your issue being dealt with quickly:

    • Overview of the Proposal

    • Motivation for or Use Case

    • Design Details

    • Alternatives

    • Test Strategy

  • Small Features can be crafted and directly submitted as a Pull Request.

Identifying Contribution Origin

When adding a new file to the tree, it is important to detail the source of origin on the file, provide attributions, and detail the intended usage. In cases where the file is an original to Zephyr, the commit message should include the following (“Original” is the assumption if no Origin tag is present):

Origin: Original

In cases where the file is imported from an external project, the commit message shall contain details regarding the original project, the location of the project, the SHA-id of the origin commit for the file and the intended purpose.

For example, a copy of a locally maintained import:

Origin: Contiki OS
License: BSD 3-Clause
URL: http://www.contiki-os.org/
commit: 853207acfdc6549b10eb3e44504b1a75ae1ad63a
Purpose: Introduction of networking stack.

For example, a copy of an externally maintained import in a module repository:

Origin: Tiny Crypt
License: BSD 3-Clause
URL: https://github.com/01org/tinycrypt
commit: 08ded7f21529c39e5133688ffb93a9d0c94e5c6e
Purpose: Introduction of TinyCrypt

Contributions to External Modules

Follow the guidelines in the Modules (External projects) section for contributing new modules and submitting changes to existing modules.

Treewide Changes

This section describes contributions that are treewide changes and some additional associated requirements that apply to them. These requirements exist to try to give such changes increased review and user visibility due to their large impact.

Definition and Decision Making

A treewide change is defined as any change to Zephyr APIs, coding practices, or other development requirements that either implies required changes throughout the zephyr source code repository or can reasonably be expected to do so for a wide class of external Zephyr-based source code.

This definition is informal by necessity. This is because the decision on whether any particular change is treewide can be subjective and may depend on additional context.

Project maintainers should use good judgement and prioritize the Zephyr developer experience when deciding when a proposed change is treewide. Protracted disagreements can be resolved by the Zephyr Project’s Technical Steering Committee (TSC), but please avoid premature escalation to the TSC.

Requirements for Treewide Changes

  • The zephyr repository must apply the ‘treewide’ GitHub label to any issues or pull requests that are treewide changes

  • The person proposing a treewide change must create an RFC issue describing the change, its rationale and impact, etc. before any pull requests related to the change can be merged

  • The project’s Architecture Working Group (WG) must include the issue on the agenda and discuss whether the project will accept or reject the change before any pull requests related to the change can be merged (with escalation to the TSC if consensus is not reached at the WG)

  • The Architecture WG must specify the procedure for merging any PRs associated with each individual treewide change, including any required approvals for pull requests affecting specific subsystems or extra review time requirements

  • The person proposing a treewide change must email devel@lists.zephyrproject.org about the RFC if it is accepted by the Architecture WG before any pull requests related to the change can be merged

Examples

Some example past treewide changes are:

Note that adding a new version of a widely used API while maintaining support for the old one is not a treewide change. Deprecation and removal of such APIs, however, are treewide changes.

Specialized driver requirements

Drivers for standalone devices should use the Zephyr bus APIs (SPI, I2C…) whenever possible so that the device can be used with any SoC from any vendor implementing a compatible bus.

If it is not technically possible to achieve full performance using the Zephyr APIs due to specialized accelerators in a particular SoC family, one could extend the support for an external device by providing a specialized path for that SoC family. However, the driver must still provide a regular path (via Zephyr APIs) for all other SoCs. Every exception must be approved by the Architecture WG in order to be validated and potentially to be learned/improved from.