Rocket is a web framework for Rust (nightly) with a focus on ease-of-use, expressibility, and speed. Here's an example of a complete Rocket application:
extern crate rocket;
localhost:8000/hello/John/58, for example, will trigger the
route resulting in the string
Hello, 58 year old named John! being sent to the
browser. If an
<age> string was passed in that can't be parsed as a
route won't get called, resulting in a 404 error.
Rocket is extensively documented:
- Overview: A brief look at what makes Rocket special.
- Quickstart: How to get started as quickly as possible.
- Getting Started: How to start your first Rocket project.
- Guide: A detailed guide and reference to Rocket.
- API Documentation: The "rustdocs".
The official community support channels are
#rocket:mozilla.org on Matrix
and the bridged
#rocket IRC channel on Freenode at
recommend joining us on Matrix via Riot. If your prefer IRC, you can join via
the Kiwi IRC client or a client of your own.
Rocket requires a nightly version of Rust as it makes heavy use of syntax extensions. This means that the first two unwieldly lines in the introductory example above are required.
Core, Codegen, and Contrib
All of the Rocket libraries are managed by Cargo. As a result, compiling them is simple.
cd lib && cargo build
cd codegen && cargo build
cd contrib && cargo build --all-features
Rocket ships with an extensive number of examples in the
which can be compiled and run with Cargo. For instance, the following sequence
of commands builds and runs the
Hello, world! example:
cd examples/hello_world cargo run
You should see
Hello, world! by visiting
To test Rocket, simply run
./scripts/test.sh from the root of the source tree.
This will build and test the
contrib libraries as well
as all of the examples. The
test.sh script accepts no flags or either the
--release flag to test in release mode or the
--contrib flag to test all
contrib modules individually. This script gets run by CI.
To test a crate individually, run
cargo test --all-features in the
corresponding crate directory.
Testing for the core library is done inline in the corresponding module. For
example, the tests for routing can be found at the bottom of the
Code generation tests can be found in
codegen/tests. We use the
compiletest library, which was
rustc, for testing. See the compiler test
for information on how to write compiler tests.
You can build the Rocket API documentation locally by running
./scripts/mk-docs.sh. The resulting documentation is what gets uploaded to
Contributions are absolutely, positively welcome and encouraged! Contributions come in many forms. You could:
- Submit a feature request or bug report as an issue.
- Ask for improved documentation as an issue.
- Comment on issues that require feedback.
- Contribute code via pull requests.
We aim to keep Rocket's code quality at the highest level. This means that any code you contribute must be:
- Commented: Public items must be commented.
- Documented: Exposed items must have rustdoc comments with examples, if applicable.
- Styled: Your code should be
rustfmt'd when possible.
- Simple: Your code should accomplish its task as simply and idiomatically as possible.
- Tested: You must add (and pass) convincing tests for any functionality you add.
- Focused: Your code should do what it's supposed to do and nothing more.
All pull requests are code reviewed and tested by the CI. Note that unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Rocket by you shall be dual licensed under the MIT License and Apache License, Version 2.0, without any additional terms or conditions.
Rocket is licensed under either of the following, at your option:
- Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
- MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)
The Rocket website source is licensed under separate terms.