{"id":15017966,"url":"https://github.com/niklasei/bevy_asset_loader","last_synced_at":"2025-04-10T23:23:52.166Z","repository":{"id":37492202,"uuid":"367979587","full_name":"NiklasEi/bevy_asset_loader","owner":"NiklasEi","description":"Bevy plugin helping with asset loading and organization","archived":false,"fork":false,"pushed_at":"2025-04-05T11:56:41.000Z","size":2051,"stargazers_count":543,"open_issues_count":19,"forks_count":57,"subscribers_count":4,"default_branch":"main","last_synced_at":"2025-04-10T18:13:21.792Z","etag":null,"topics":["assets","assets-management","bevy","bevy-plugin","game-development","hacktoberfest","rust"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/NiklasEi.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE-APACHE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2021-05-16T20:32:22.000Z","updated_at":"2025-04-08T12:05:45.000Z","dependencies_parsed_at":"2024-01-03T19:23:56.910Z","dependency_job_id":"31857250-3ec5-4b07-b380-0f2ea01aa02a","html_url":"https://github.com/NiklasEi/bevy_asset_loader","commit_stats":{"total_commits":459,"total_committers":21,"mean_commits":"21.857142857142858","dds":"0.13507625272331159","last_synced_commit":"5a5481608820a434c5fc9b1cd48ba4f64e2571df"},"previous_names":[],"tags_count":21,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NiklasEi%2Fbevy_asset_loader","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NiklasEi%2Fbevy_asset_loader/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NiklasEi%2Fbevy_asset_loader/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NiklasEi%2Fbevy_asset_loader/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/NiklasEi","download_url":"https://codeload.github.com/NiklasEi/bevy_asset_loader/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248313368,"owners_count":21082849,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["assets","assets-management","bevy","bevy-plugin","game-development","hacktoberfest","rust"],"created_at":"2024-09-24T19:51:15.763Z","updated_at":"2025-04-10T23:23:52.143Z","avatar_url":"https://github.com/NiklasEi.png","language":"Rust","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Bevy asset loader\n\n[![crates.io](https://img.shields.io/crates/v/bevy_asset_loader.svg)](https://crates.io/crates/bevy_asset_loader)\n[![docs](https://docs.rs/bevy_asset_loader/badge.svg)](https://docs.rs/bevy_asset_loader)\n[![license](https://img.shields.io/crates/l/bevy_asset_loader)](https://github.com/NiklasEi/bevy_asset_loader#license)\n[![crates.io](https://img.shields.io/crates/d/bevy_asset_loader.svg)](https://crates.io/crates/bevy_asset_loader)\n\n_Loading states with minimal boilerplate_\n\nThis [Bevy][bevy] plugin reduces boilerplate for handling game assets. The crate offers the derivable `AssetCollection` trait and can automatically load structs that implement it. Asset collections contain handles to your game assets and are available to your systems as resources after loading.\n\nIn most cases you will want to load your asset collections during loading states (think loading screens). During such a state, all assets are loaded and their loading progress is observed. Only when asset collections can be built with fully loaded asset handles, the collections are inserted to Bevy's ECS as resources. If you do not want to use a loading state, asset collections can still result in cleaner code and improved maintainability (see the [\"usage without a loading state\"](#usage-without-a-loading-state) section).\n\n_The `main` branch and the latest release support Bevy version `0.15` (see [version table](#compatible-bevy-versions))_\n\n## Loading states\n\nA loading state is responsible for managing the loading process during a configurable Bevy state (see [the cheatbook on states][cheatbook-states]).\n\nIf your `LoadingState` is set up, you can start your game logic from the configured \"next state\" and use the asset collections as resources in your systems. The loading state guarantees that all handles in your collections are fully loaded by the time the next state starts.\n\n```rust no_run\nuse bevy::prelude::*;\nuse bevy_asset_loader::prelude::*;\n\nfn main() {\n    App::new()\n        .add_plugins(DefaultPlugins)\n        .init_state::\u003cMyStates\u003e()\n        .add_loading_state(\n            LoadingState::new(MyStates::AssetLoading)\n                .continue_to_state(MyStates::Next)\n                .load_collection::\u003cAudioAssets\u003e(),\n        )\n        .add_systems(OnEnter(MyStates::Next), start_background_audio)\n        .run();\n}\n\n#[derive(AssetCollection, Resource)]\nstruct AudioAssets {\n    #[asset(path = \"audio/background.ogg\")]\n    background: Handle\u003cAudioSource\u003e,\n}\n\n/// This system runs in MyStates::Next. Thus, AudioAssets is available as a resource\n/// and the contained handle is done loading.\nfn start_background_audio(mut commands: Commands, audio_assets: Res\u003cAudioAssets\u003e) {\n    commands.spawn((AudioPlayer(audio_assets.background.clone()), PlaybackSettings::LOOP));\n}\n\n#[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]\nenum MyStates {\n    #[default]\n    AssetLoading,\n    Next,\n}\n```\n\nIf we want to add additional asset collections to the just added loading state, we can do so using `configure_loading_state` at any point in our application. We could, for example, add a `PlayerPlugin` to the `App` after adding the loading state. The `PlayerPlugin` will contain all things \"player\" including its sprite.\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::prelude::*;\n\nstruct PlayerPlugin;\n\nimpl Plugin for PlayerPlugin {\n    fn build(\u0026self, app: \u0026mut App) {\n        app\n            .configure_loading_state(\n                LoadingStateConfig::new(MyStates::AssetLoading)\n                    .load_collection::\u003cPlayerAssets\u003e(),\n            );\n    }\n}\n\n#[derive(AssetCollection, Resource)]\nstruct PlayerAssets {\n    #[asset(path = \"images/player.png\")]\n    sprite: Handle\u003cImage\u003e,\n}\n\n#[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]\nenum MyStates {\n    #[default]\n    AssetLoading,\n    Next,\n}\n```\n\n## Compile time vs. Run time (dynamic) assets\n\nAsset configurations, like their file path or dimensions of sprite sheets, can be given at compile time (through derive macro attributes), or at run time ([\"Dynamic assets\"](#dynamic-assets)). The second, allows managing asset configurations as assets. That means you can keep a list of your asset files and their properties in asset files. The main benefit of using dynamic assets is a cleaner split of code and data leading to less recompiles while working on your assets. It also makes your game more approachable for people that want to contribute without touching code.\n\nThe derive macro for `AssetCollection` supports multiple attributes. They configure how the asset is loaded.\n\n### Compile time assets\n\nThe two earlier code examples show a loading state with collections that have all their configuration in derive macro attributes. The path of the player sprite is hardcoded to be \"images/player.png\". Changing it will require recompiling your application.\n\nThe [full_collection](/bevy_asset_loader/examples/full_collection.rs) example showcases all the different kinds of fields that an asset collection can contain using only derive macro attributes.\n\n### Dynamic assets\n\nDynamic assets are configured through the derive macro attribute `key` and are not allowed to have a `path` or `paths` attribute:\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct ImageAssets {\n  #[asset(key = \"player\")]\n  player: Handle\u003cImage\u003e,\n  #[asset(key = \"tree\")]\n  tree: Handle\u003cImage\u003e,\n}\n```\n\nThe keys `player` and `tree` in the example above should either be set manually in the `DynamicAssets` resource prior to the loading state\n(see the [manual_dynamic_asset](/bevy_asset_loader/examples/manual_dynamic_asset.rs) example), or be part of a dynamic assets file (see [dynamic_asset.rs](/bevy_asset_loader/examples/dynamic_asset.rs)).\nA dynamic assets file for the collection above might look like this:\n\n```ron\n({\n    \"player\": File (\n        path: \"images/player.png\",\n    ),\n    \"tree\": File (\n        path: \"images/tree.png\",\n    ),\n})\n```\n\nUsing dynamic assets like `File` and loading ron files requires the `standard_dynamic_assets` feature to be enabled.\n\nThe file ending is `.assets.ron` by default, but can be configured via `LoadingState::set_standard_dynamic_asset_collection_file_endings`.\n\nThe example [full_dynamic_collection](/bevy_asset_loader/examples/full_dynamic_collection.rs) shows all supported field types for dynamic assets. Note that adding a dynamic asset file to a loading state requires the `AssetServer` resource to be available. In most cases that means that you should add the `DefaultPlugins` before configuring your loading state.\n\n### Custom dynamic assets\n\nYou can define your own types to load as dynamic assets. Take a look at the [custom_dynamic_assets.rs](/bevy_asset_loader/examples/custom_dynamic_assets.rs) example for some code.\n\n## Supported asset fields\n\nThe simplest field is of the type `Handle\u003cT\u003e` and is loaded from a single file. One example might be audio sources, but any asset type that has an asset loader registered with Bevy can be used like this.\n\nThe field should only have the `path` attribute set.\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(path = \"my-background.ogg\")]\n    background: Handle\u003cAudioSource\u003e,\n}\n```\n\nThe dynamic version of the same collection looks like this:\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(key = \"background\")]\n    background: Handle\u003cAudioSource\u003e,\n}\n```\n\n```ron\n({\n    \"background\": File (\n        path: \"my-background.ogg\",\n    ),\n})\n```\n\nThe following sections describe more types of asset fields that you can load through asset collections.\n\n### Texture atlases\n\nYou can create texture atlas layouts as part of an `AssetCollection` if you enable the feature `2d`. For a complete example please take a look at [atlas_from_grid.rs](/bevy_asset_loader/examples/atlas_from_grid.rs).\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(texture_atlas_layout(tile_size_x = 64, tile_size_y = 64, columns = 8, rows = 1, padding_x = 12, padding_y = 12, offset_x = 6, offset_y = 6))]\n    layout: Handle\u003cTextureAtlasLayout\u003e,\n    #[asset(path = \"images/sprite_sheet.png\")]\n    sprite: Handle\u003cImage\u003e,\n}\n```\n\nAs a dynamic asset this example becomes:\n\n```rust ignore\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(key = \"player.layout\")]\n    layout: Handle\u003cTextureAtlasLayout\u003e,\n    #[asset(key = \"player.image\")]\n    sprite: Handle\u003cImage\u003e,\n}\n```\n\n```ron\n({\n    \"player.image\": File (\n        path: \"images/sprite_sheet.png\",\n    ),\n    \"player.layout\": TextureAtlasLayout (\n        tile_size_x: 100,\n        tile_size_y: 64,\n        columns: 8,\n        rows: 1,\n        padding_x: 12,\n        padding_y: 12,\n        offset_x: 6,\n        offset_y: 6,\n    ),\n})\n```\n\nThe four padding \u0026 offset fields/attributes are optional, and default to `0`.\n\n### Images with sampler configuration\n\nAsset collections support configuring the sampler of an image asset through a derive attribute:\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct ImageAssets {\n    #[asset(path = \"images/pixel_tree.png\")]\n    #[asset(image(sampler(filter = linear)))]\n    tree_linear: Handle\u003cImage\u003e,\n\n    #[asset(path = \"images/pixel_tree.png\")]\n    #[asset(image(sampler(filter = nearest)))]\n    tree_nearest: Handle\u003cImage\u003e,\n\n    #[asset(path = \"images/pixel_tree.png\")]\n    #[asset(image(sampler(filter = linear, wrap = repeat)))]\n    tree_linear_repeat: Handle\u003cImage\u003e,\n}\n```\n\nThe corresponding dynamic asset would be\n\n```ron\n({\n    \"tree_nearest\": Image (\n        path: \"images/tree.png\",\n        filter: Nearest,\n        wrap: Clamp\n    ),\n    \"tree_linear\": Image (\n        path: \"images/tree.png\",\n        filter: Linear,\n        wrap: Clamp\n    ),\n    \"tree_linear_repeat\": Image (\n        path: \"images/tree.png\",\n        filter: Linear,\n        wrap: Repeat\n    ),\n})\n```\n\n### Array images\n\nYou can let `bevy_asset_loader` configure the layers of a texture array.\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct ImageAssets {\n    #[asset(path = \"images/array_texture.png\")]\n    #[asset(image(array_texture_layers = 4))]\n    array_texture: Handle\u003cImage\u003e,\n}\n```\n\nThe corresponding dynamic asset would be\n\n```ron\n({\n    \"array_texture\": Image (\n        path: \"images/array_texture.png\",\n        array_texture_layers: 4\n    ),\n})\n```\n\n### Standard materials\n\nYou can directly load standard materials if you enable the feature `3d`. For a complete example please take a look at [standard_material.rs](/bevy_asset_loader/examples/standard_material.rs).\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(standard_material)]\n    #[asset(path = \"images/player.png\")]\n    player: Handle\u003cStandardMaterial\u003e,\n}\n```\n\nThis is also supported as a dynamic asset:\n\n```rust ignore\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(key = \"image.player\")]\n    player: Handle\u003cStandardMaterial\u003e,\n}\n```\n\n```ron\n({\n    \"image.player\": StandardMaterial (\n        path: \"images/player.png\",\n    ),\n})\n```\n\n### Collections\n\n#### Folders\n\n_This asset field type is not supported in web builds. See [Files](#list-of-paths) for a web compatible way of loading a collection of files._\n\nYou can load all files in a folder as a vector of untyped handles. This field requires the additional derive macro attribute `collection`:\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(path = \"images\", collection)]\n    folder: Vec\u003cUntypedHandle\u003e,\n}\n```\n\nJust like Bevy's `load_folder`, this will also recursively load sub folders.\n\nIf all assets in the folder have the same (known) type, you can load the folder as `Vec\u003cHandle\u003cT\u003e\u003e` by setting `typed` in the `collection` attribute. Don't forget to adapt the type of the struct field:\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(path = \"images\", collection(typed))]\n    folder: Vec\u003cHandle\u003cImage\u003e\u003e,\n}\n```\n\nFolders are also supported as a dynamic asset. The path attribute is replaced by the `key` attribute:\n\n```rust ignore\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(key = \"my.images\", collection(typed))]\n    images: Vec\u003cHandle\u003cImage\u003e\u003e,\n}\n```\n\n```ron\n({\n    \"my.images\": Folder (\n        path: \"images\",\n    ),\n})\n```\n\nLoading folders is not supported for web builds. If you want to be compatible with Wasm, load you handles from a list of paths instead (see next section).\n\n#### List of paths\n\nIf you want to load a list of asset files with the same type into a vector of `Handle\u003cT\u003e`, you can list their paths in an attribute:\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(paths(\"images/player.png\", \"images/tree.png\"), collection(typed))]\n    files_typed: Vec\u003cHandle\u003cImage\u003e\u003e,\n}\n```\n\nIn case you do not know their types, or they might have different types, the handles can also be untyped:\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(paths(\"images/player.png\", \"sound/background.ogg\"), collection)]\n    files_untyped: Vec\u003cUntypedHandle\u003e,\n}\n```\n\nAs dynamic assets, these two fields replace their `paths` attribute with `key`. This is the same as for folders.\n\n```rust\nuse bevy::prelude::*;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(key = \"files_untyped\", collection)]\n    files_untyped: Vec\u003cUntypedHandle\u003e,\n    #[asset(key = \"files_typed\", collection(typed))]\n    files_typed: Vec\u003cHandle\u003cImage\u003e\u003e,\n}\n```\n\nThe corresponding assets file differs from the folder example:\n\n```ron\n({\n    \"files_untyped\": Files (\n        paths: [\"images/tree.png\", \"images/player.png\"],\n    ),\n    \"files_typed\": Files (\n        paths: [\"images/tree.png\", \"images/player.png\"],\n    ),\n})\n```\n\n### Collections as maps\n\nCollections can be loaded as maps using any type that implements [`MapKey`](https://docs.rs/bevy_asset_loader/latest/bevy_asset_loader/mapped/trait.MapKey.html) as the keys (see documentation for more details).\nThis is only a change in derive attributes and asset field type. The examples from the sections above would look like this:\n\n```rust\nuse bevy::prelude::*;\nuse bevy::utils::HashMap;\nuse bevy_asset_loader::asset_collection::AssetCollection;\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(path = \"images\", collection(mapped))]\n    folder: HashMap\u003cString, UntypedHandle\u003e,\n    #[asset(paths(\"images/player.png\", \"images/tree.png\"), collection(typed, mapped))]\n    files_typed: HashMap\u003cString, Handle\u003cImage\u003e\u003e,\n    #[asset(key = \"files_untyped\", collection(mapped))]\n    dynamic_files_untyped: HashMap\u003cString, UntypedHandle\u003e,\n    #[asset(key = \"files_typed\", collection(typed, mapped))]\n    dynamic_files_typed: HashMap\u003cString, Handle\u003cImage\u003e\u003e,\n}\n```\n\n### Types implementing FromWorld\n\nAny field in an asset collection without any attribute is required to implement the `FromWorld` trait. When the asset collection is build, the `FromWorld` implementation is called to get the value for the field.\n\n## Initializing FromWorld resources\n\nIn situations where you would like to prepare other resources based on your loaded asset collections you can use `LoadingState::finally_init_resource` or `LoadingStateConfig::finally_init_resource` to initialize `FromWorld` resources. See [finally_init_resource.rs](/bevy_asset_loader/examples/finally_init_resource.rs) for an example that loads two images and then combines their pixel data into a third image.\n\nBoth `finally_init_resource` methods from `bevy_asset_loader` do the same as Bevy's `App::init_resource`, but at a different point in time. While Bevy inserts your resources at application startup, `bevy_asset_loader` will initialize them only after your asset collections are available. That means you can use your asset collections in the `FromWorld` implementation of the resource.\n\n## Progress tracking\n\nWith the feature `progress_tracking`, you can integrate with [`iyes_progress`][iyes_progress] to track asset loading during a loading state. This, for example, enables progress bars.\n\nSee [`progress_tracking`](/bevy_asset_loader/examples/progress_tracking.rs) for a complete example.\n\n### A note on system ordering\n\nThe loading state is organized in a private schedule that runs in a single system during the `Update` schedule. If you want to explicitly order against the system running the loading state, you can do so with the exported system set `LoadingStateSet`.\n\n## Failure state\n\nYou can configure a failure state in case some asset in a collection fails to load by calling `on_failure_continue_to` with a state (see the [`failure_state.rs`](/bevy_asset_loader/examples/failure_state.rs) example). If no failure state is configured and some asset fails to load, your application will be stuck in the loading state.\n\nIn most cases of failed loading states, an asset file is missing or a certain asset does not have an asset loader registered. In both of these cases, the application log should help since Bevy prints warnings about those issues.\n\n## Usage without a loading state\n\nAlthough the pattern of a loading state is quite nice (imo), you might have reasons not to use it. In this case, `bevy_asset_loader` can still be helpful. Deriving `AssetCollection` on a resource can significantly reduce the boilerplate for managing assets.\n\nAsset collections loaded without a loading state do not support folders, dynamic assets, or the `image` annotation. This is because these features require some form of waiting (see [potential future support for these features](https://github.com/NiklasEi/bevy_asset_loader/issues/230)).\n\nYou can directly initialise asset collections on the bevy `App` or `World`. See [no_loading_state.rs](/bevy_asset_loader/examples/no_loading_state.rs) for a complete example.\n\n```rust no_run\nuse bevy::prelude::*;\nuse bevy_asset_loader::prelude::*;\n\nfn main() {\n    App::new()\n        .add_plugins(DefaultPlugins)\n        .init_collection::\u003cMyAssets\u003e()\n        .run();\n}\n\n#[derive(AssetCollection, Resource)]\nstruct MyAssets {\n    #[asset(texture_atlas_layout(tile_size_x = 64, tile_size_y = 64, columns = 8, rows = 1, padding_x = 12, padding_y = 12, offset_x = 6, offset_y = 6))]\n    layout: Handle\u003cTextureAtlasLayout\u003e,\n    #[asset(path = \"images/sprite_sheet.png\")]\n    sprite: Handle\u003cImage\u003e,\n}\n```\n\n## Unloading assets\n\nBevy unloads an asset when there are no strong asset handles left pointing to the asset. An `AssetCollection` stores strong handles and ensures that assets contained in it are not removed from memory. If you want to unload assets, you need to remove any `AssetCollection` resource that holds handles pointing to those assets. You, for example, could do this when leaving the state that needed the collection.\n\n## Compatible Bevy versions\n\nThe main branch is compatible with the latest Bevy release, while the branch `bevy_main` tries to track the `main` branch of Bevy (PRs updating the tracked commit are welcome).\n\nCompatibility of `bevy_asset_loader` versions:\n\n| Bevy version | `bevy_asset_loader` version |\n|:-------------|:----------------------------|\n| `0.15`       | `0.22`                      |\n| `0.14`       | `0.21`                      |\n| `0.13`       | `0.20`                      |\n| `0.12`       | `0.18` - `0.19`             |\n| `0.11`       | `0.17`                      |\n| `0.10`       | `0.15` - `0.16`             |\n| `0.9`        | `0.14`                      |\n| `0.8`        | `0.12` - `0.13`             |\n| `0.7`        | `0.10` - `0.11`             |\n| `0.6`        | `0.8` - `0.9`               |\n| `0.5`        | `0.1` - `0.7`               |\n| `0.15`       | branch `main`               |\n| `main`       | branch `bevy_main`          |\n\n## License\n\nDual-licensed under either of\n\n- Apache License, Version 2.0, ([LICENSE-APACHE](/LICENSE-APACHE) or https://www.apache.org/licenses/LICENSE-2.0)\n- MIT license ([LICENSE-MIT](/LICENSE-MIT) or https://opensource.org/licenses/MIT)\n\nat your option.\n\nAssets in the examples might be distributed under different terms. See the [readme](/bevy_asset_loader/examples/README.md#credits) in the `bevy_asset_loader/examples` directory.\n\n## Contribution\n\nUnless you explicitly state otherwise, any contribution intentionally submitted\nfor inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any\nadditional terms or conditions.\n\n[bevy]: https://bevyengine.org/\n[cheatbook-states]: https://bevy-cheatbook.github.io/programming/states.html\n[iyes_progress]: https://github.com/IyesGames/iyes_progress\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fniklasei%2Fbevy_asset_loader","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fniklasei%2Fbevy_asset_loader","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fniklasei%2Fbevy_asset_loader/lists"}