cc69fdd0c6
# Objective - Fixes #15460 (will open new issues for further `no_std` efforts) - Supersedes #17715 ## Solution - Threaded in new features as required - Made certain crates optional but default enabled - Removed `compile-check-no-std` from internal `ci` tool since GitHub CI can now simply check `bevy` itself now - Added CI task to check `bevy` on `thumbv6m-none-eabi` to ensure `portable-atomic` support is still valid [^1] [^1]: This may be controversial, since it could be interpreted as implying Bevy will maintain support for `thumbv6m-none-eabi` going forward. In reality, just like `x86_64-unknown-none`, this is a [canary](https://en.wiktionary.org/wiki/canary_in_a_coal_mine) target to make it clear when `portable-atomic` no longer works as intended (fixing atomic support on atomically challenged platforms). If a PR comes through and makes supporting this class of platforms impossible, then this CI task can be removed. I however wager this won't be a problem. ## Testing - CI --- ## Release Notes Bevy now has support for `no_std` directly from the `bevy` crate. Users can disable default features and enable a new `default_no_std` feature instead, allowing `bevy` to be used in `no_std` applications and libraries. ```toml # Bevy for `no_std` platforms bevy = { version = "0.16", default-features = false, features = ["default_no_std"] } ``` `default_no_std` enables certain required features, such as `libm` and `critical-section`, and as many optional crates as possible (currently just `bevy_state`). For atomically-challenged platforms such as the Raspberry Pi Pico, `portable-atomic` will be used automatically. For library authors, we recommend depending on `bevy` with `default-features = false` to allow `std` and `no_std` users to both depend on your crate. Here are some recommended features a library crate may want to expose: ```toml [features] # Most users will be on a platform which has `std` and can use the more-powerful `async_executor`. default = ["std", "async_executor"] # Features for typical platforms. std = ["bevy/std"] async_executor = ["bevy/async_executor"] # Features for `no_std` platforms. libm = ["bevy/libm"] critical-section = ["bevy/critical-section"] [dependencies] # We disable default features to ensure we don't accidentally enable `std` on `no_std` targets, for example. bevy = { version = "0.16", default-features = false } ``` While this is verbose, it gives the maximum control to end-users to decide how they wish to use Bevy on their platform. We encourage library authors to experiment with `no_std` support. For libraries relying exclusively on `bevy` and no other dependencies, it may be as simple as adding `#![no_std]` to your `lib.rs` and exposing features as above! Bevy can also provide many `std` types, such as `HashMap`, `Mutex`, and `Instant` on all platforms. See `bevy::platform_support` for details on what's available out of the box! ## Migration Guide - If you were previously relying on `bevy` with default features disabled, you may need to enable the `std` and `async_executor` features. - `bevy_reflect` has had its `bevy` feature removed. If you were relying on this feature, simply enable `smallvec` and `smol_str` instead. --------- Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
59 lines
2.2 KiB
Rust
59 lines
2.2 KiB
Rust
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
|
|
|
|
//! [](https://bevyengine.org)
|
|
//!
|
|
//! Bevy is an open-source modular game engine built in Rust, with a focus on developer productivity
|
|
//! and performance.
|
|
//!
|
|
//! Check out the [Bevy website](https://bevyengine.org) for more information, read the
|
|
//! [Quick Start Guide](https://bevyengine.org/learn/quick-start/introduction) for a step-by-step introduction, and [engage with our
|
|
//! community](https://bevyengine.org/community/) if you have any questions or ideas!
|
|
//!
|
|
//! ## Example
|
|
//!
|
|
//! Here is a simple "Hello World" Bevy app:
|
|
//! ```
|
|
//! use bevy::prelude::*;
|
|
//!
|
|
//! fn main() {
|
|
//! App::new()
|
|
//! .add_systems(Update, hello_world_system)
|
|
//! .run();
|
|
//! }
|
|
//!
|
|
//! fn hello_world_system() {
|
|
//! println!("hello world");
|
|
//! }
|
|
//! ```
|
|
//!
|
|
//! Don't let the simplicity of the example above fool you. Bevy is a [fully featured game engine](https://bevyengine.org)
|
|
//! and it gets more powerful every day!
|
|
//!
|
|
//! ## This Crate
|
|
//!
|
|
//! The `bevy` crate is just a container crate that makes it easier to consume Bevy subcrates.
|
|
//! The defaults provide a "full" engine experience, but you can easily enable / disable features
|
|
//! in your project's `Cargo.toml` to meet your specific needs. See Bevy's `Cargo.toml` for a full
|
|
//! list of features available.
|
|
//!
|
|
//! If you prefer, you can also consume the individual bevy crates directly.
|
|
//! Each module in the root of this crate, except for the prelude, can be found on crates.io
|
|
//! with `bevy_` appended to the front, e.g. `app` -> [`bevy_app`](https://docs.rs/bevy_app/*/bevy_app/).
|
|
#![doc = include_str!("../docs/cargo_features.md")]
|
|
#![doc(
|
|
html_logo_url = "https://bevyengine.org/assets/icon.png",
|
|
html_favicon_url = "https://bevyengine.org/assets/icon.png"
|
|
)]
|
|
#![no_std]
|
|
|
|
pub use bevy_internal::*;
|
|
|
|
// Wasm does not support dynamic linking.
|
|
#[cfg(all(feature = "dynamic_linking", not(target_family = "wasm")))]
|
|
#[expect(
|
|
unused_imports,
|
|
clippy::single_component_path_imports,
|
|
reason = "This causes bevy to be compiled as a dylib when using dynamic linking, and as such cannot be removed or changed without affecting dynamic linking."
|
|
)]
|
|
use bevy_dylib;
|