diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
deleted file mode 100644
index cc90457bb9..0000000000
--- a/.github/workflows/ci.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@master
-
-      - name: "Build Bevy Assets"
-        run: cd generate-assets && ./generate_assets.sh
-
-      - name: "Build website"
-        uses: shalzz/zola-deploy-action@master
-        env:
-          PAGES_BRANCH: gh-pages
-          BUILD_DIR: .
-          BUILD_ONLY: true
-          TOKEN: fake-secret
\ No newline at end of file
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
deleted file mode 100644
index b330b9929b..0000000000
--- a/.github/workflows/deploy.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-name: Deploy
-
-on:
-  push:
-    branches: [master]
-  schedule:
-    - cron:  '0 0 * * *'
-  workflow_dispatch:
-
-jobs:
-  build_and_deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@master
-
-      - name: "Build Bevy Assets"
-        run: cd generate-assets && ./generate_assets.sh
-
-      - name: "Build and deploy website"
-        if: github.repository_owner == 'bevyengine'
-        uses: shalzz/zola-deploy-action@master
-        env:
-          PAGES_BRANCH: gh-pages
-          BUILD_DIR: .
-          TOKEN: ${{ secrets.CART_PAT }}
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
new file mode 100644
index 0000000000..78b8144f2d
--- /dev/null
+++ b/.github/workflows/main.yml
@@ -0,0 +1,39 @@
+# This is a basic workflow to help you get started with Actions
+
+name: CI
+
+# Controls when the action will run. Triggers the workflow on pushes to master
+#  or any pull request or pull request
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    if: github.ref != 'refs/heads/master' # Only on PRs, see also build_and_deploy below
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: "Build website"
+        uses: shalzz/zola-deploy-action@master
+        env:
+          PAGES_BRANCH: gh-pages
+          BUILD_DIR: .
+          BUILD_ONLY: true
+          TOKEN: fake-secret
+
+  build_and_deploy:
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/master' # Only on a push to the master branch (like when PR's are merged)
+    steps:
+      - uses: actions/checkout@master
+
+      - name: "Build and deploy website"
+        uses: shalzz/zola-deploy-action@master
+        env:
+          PAGES_BRANCH: gh-pages
+          BUILD_DIR: .
+          TOKEN: ${{ secrets.CART_PAT }}
diff --git a/.gitignore b/.gitignore
index 71da54c70d..7b24706ebb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,6 @@
 public
 **/.DS_Store
 .idea/
-content/assets
+
+generate-assets/target/
+generate-errors/target/
diff --git a/README.md b/README.md
index db052ccc12..5b12a19c90 100644
--- a/README.md
+++ b/README.md
@@ -4,13 +4,14 @@ The source files for https://bevyengine.org. This includes official Bevy news an
 
 ## Zola
 
-The Bevy website is built using the Zola static site engine. In our experience, it is fast, flexible, and straightforward to use.
+The Bevy website is built using the Zola static site engine. In our experience, it is fast, flexible, and straightforward to use. [Check it out here](https://www.getzola.org/)!
 
 To check out any local changes you've made:
-1. [Download Zola](https://www.getzola.org/).
-2. Clone the Bevy Website git repo and enter that directory:
-    1. `git clone https://github.com/bevyengine/bevy-website.git`
-    2. `cd bevy-website`
+1. Download Zola.
+2. Clone the Bevy Website git repo and move to that directory:
+  1. `git clone https://github.com/bevyengine/bevy-website.git`
+  2. `cd bevy-website`
 3. Start the Zola server with `zola serve`.
 
 A local server should start and you should be able to access a local version of the website from there.
+
diff --git a/config.toml b/config.toml
index 38e9358b76..5a7faf47e1 100644
--- a/config.toml
+++ b/config.toml
@@ -22,7 +22,8 @@ taxonomies = [
 # Whether to do syntax highlighting
 # Theme can be customised by setting the `highlight_theme` variable to a theme supported by Zola
 highlight_code = true
-highlight_theme = "css"
+highlight_theme = "base16-ocean-dark"
+
 
 [extra]
 # Put all your custom variables here
diff --git a/content/learn/book/ecs/_index.md b/content/learn/book/ecs/_index.md
index d1f1081755..a15ff3d39a 100644
--- a/content/learn/book/ecs/_index.md
+++ b/content/learn/book/ecs/_index.md
@@ -4,6 +4,345 @@ weight = 2
 sort_by = "weight"
 template = "book-section.html"
 page_template = "book-section.html"
+insert_anchor_links = "right"
 +++
 
-TODO: high-level overview of how the ECS works
+Bevy is fundamentally powered by its ECS (a central [paradigm](https://ajmmertens.medium.com/ecs-from-tool-to-paradigm-350587cdf216) for organizing and operating on data which stands Entity-Component-System): almost all data is stored as components which belong to entities, and all logic is executed by its systems.
+
+We can think of our **entity-component data storage** as a giant in-memory database:
+
+* each row is an **entity**, representing an object (perhaps a player, tile, or UI button) in our game
+* each column is a type of **component**, storing data of a particular type (perhaps the sprite, team or life of a player entity) in an [efficient way](https://github.com/bevyengine/bevy/pull/1525) that keeps data of the same type tightly packed together
+* each cell is a component of a particular entity, which has a concrete value we can look up and change
+* we access data from this database using **queries**, which fetch component data from entities with the specified components
+* the primary key of this database is the {{rust_type(type="struct" crate="bevy_ecs" name="Entity")}} identifier, which can be used to look up specific entities using {{rust_type(type="struct" crate="bevy_ecs" name="Query" method = "get")}}
+
+Of course, this database is [very ragged](https://www.transdatasolutions.com/what-is-ragged-data/): not all entities will have every component!
+We can use this fact to specialize behavior between entities: systems only perform work on entities with the correct combination of components.
+You don't want to apply gravity to entities without a position in your world, and you're only interested in using the UI layout algorithm to control the layout of UI entities!
+
+When we want to go beyond this tabular data storage, we can use **resources**: global singletons which store data, each in their own monolithic blob.
+You might use resources to interface with other libraries, store unique bits of state like the game's score, or store secondary data structures like indexes to augment your use of entity-component data.
+
+In order to manipulate and act on this data, we must use systems.
+**Systems** are Rust functions that request specific data, such as resources and entities, from the {{rust_type(type="struct" crate="bevy_ecs" name="World")}}. They define a query in their parameters (arguments) that selects data with a particular combination of components.
+All of the rules and behaviours of our game are governed by systems.
+
+Once the systems are added to our app, the **runner** takes this information and automatically runs our systems, typically once during each pass of the **game loop** according to the rules defined in their **schedule**.
+
+Bevy's default execution strategy runs systems in parallel by default, without the need for any manual setup.
+Because the **function signature** of each of our systems fully define the data it can access, we can ensure that only one system can change a piece of data at once (although any number can read from a piece of data at the same time).
+
+Systems within the same **stage** are allowed to run in parallel with each other (as long as their data access does not conflict), and are assigned to a thread to perform work as soon as one is free.
+
+When we need to access data in complex, cross-cutting ways that are not cleanly modelled by our systems' function signatures, we can defer the work until we have exclusive access to the entire world's data: executing **commands** generated in earlier systems at the end of each stage or performing complex logic (like saving the entire game) in our own **exclusive systems**.
+You will first encounter this when spawning and despawning entities: we have no way of knowing precisely which other components our entities might have, and so we are forced to wait until we can ensure that we can safely write to *all* component data at once.
+
+## ECS by example
+
+Before we dive into the details of each of these features, let's take a quick look at a simple but fun whack-a-mole game that you can run and play.
+Unsurprisingly, the different parts of the ECS tend to be closely linked: components are not very useful without a way to spawn entities and systems that run our logic are very dull if we can't discuss the data they can access.
+The details of each part are more easily grasped if you have a basic sense of the whole.
+
+```rust
+use bevy::prelude::*;
+
+// This is a fast but insecure HashMap (dictionary, for those coming from Python)
+// implementation that Bevy re-exports for internal and external use
+use bevy::utils::HashMap;
+
+// We want to randomize our moles,
+// so we're also using the `rand` crate.
+// Be sure to add `rand = "0.8"` to your Cargo.toml
+use rand::distributions::{Distribution, Uniform};
+use rand::seq::IteratorRandom;
+
+// The main function defines all the code that our program will run
+// in an imperative fashion
+fn main() {
+    // The App stores entities, their components and all resources in the World
+    // and systems in its Schedule
+    App::new()
+        // Sets up the graphics and input that we need for this example
+        .add_plugins(DefaultPlugins)
+        // We only want to run this once, at the start of the app, so it's a startup system
+        .add_startup_system(spawn_camera_system)
+        // This resource is explicitly initialized with a new value
+        .insert_resource(Score(0))
+        // These systems all run once per frame,
+        // in parallel if possible
+        .add_system(report_score_system)
+        // This resource is initialized using its FromWorld trait impl
+        .init_resource::<MoleColors>()
+        // This resource is initialized using its Default trait impl
+        .init_resource::<SpawnTimer>()
+        .add_system(spawn_mole_system)
+        .add_system(despawn_on_timer_system)
+        .add_system(whack_system)
+        .run();
+}
+
+/// Resource that stores the current score
+struct Score(isize);
+
+/// Creates a standard 2D camera
+fn spawn_camera_system(mut commands: Commands) {
+    // This spawns a new entity for our camera
+    // with the set of components defined by the OrthographicCameraBundle
+    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
+}
+
+/// Reports the value of the Score resource for the player
+fn report_score_system(score: Res<Score>) {
+    // We only want to report the new score when it has changed
+    if score.is_changed() {
+        println!("Score: {}", score.0);
+    }
+}
+
+const MOLE_SIZE: f32 = 50.0;
+
+/// Marker component for our moles
+#[derive(Component)]
+struct Mole;
+
+/// Component that stores how long this entity has left to live
+#[derive(Component)]
+struct DespawnTimer(Timer);
+
+impl Default for DespawnTimer {
+    fn default() -> Self {
+        const MOLE_LIFESPAN: f32 = 5.0;
+        DespawnTimer(Timer::from_seconds(MOLE_LIFESPAN, false))
+    }
+}
+
+/// Component that determines how many points each mole is worth
+// Enums can be added as components!
+// We need the additional traits to allow us to use this type as a key in our MoleColors hashmap
+#[derive(Component, PartialEq, Eq, Hash, Clone, Copy)]
+enum MoleType {
+    Avoid,
+    Click,
+    Prioritize,
+}
+
+impl MoleType {
+    /// The number of points each type of mole is worth when clicked
+    fn points(&self) -> isize {
+        match *self {
+            MoleType::Avoid => -10,
+            MoleType::Click => 1,
+            MoleType::Prioritize => 5,
+        }
+    }
+
+    /// The color each type of mole will have when spawned
+    fn color(&self) -> Color {
+        match *self {
+            MoleType::Avoid => Color::RED,
+            MoleType::Click => Color::BLUE,
+            MoleType::Prioritize => Color::VIOLET,
+        }
+    }
+
+    /// Lists the types of moles for easy iteration
+    fn types() -> impl Iterator<Item = MoleType> {
+        [MoleType::Avoid, MoleType::Click, MoleType::Prioritize]
+            .iter()
+            // This allows us to return MoleType as our item,
+            // rather than just a reference to the objects in this array (&MoleType)
+            .copied()
+    }
+}
+
+/// A resource to store the colors for our moles in an efficient way
+struct MoleColors {
+    map: HashMap<MoleType, Handle<ColorMaterial>>,
+}
+
+// This trait allows us to initialize a resource in more complex ways
+impl FromWorld for MoleColors {
+    fn from_world(world: &mut World) -> Self {
+        // Here, we're grabbing the Assets<ColorMaterial> resource directly from the world
+        // so we can record the materials that we create in it
+        let mut material_assets = world.get_resource_mut::<Assets<ColorMaterial>>().unwrap();
+        let mut mole_colors = MoleColors {
+            map: HashMap::default(),
+        };
+
+        // The types() method on MoleTypes we made above returns an iterator,
+        // so we can loop over it directly
+        for mole_type in MoleType::types() {
+            // Each mole type has its own color.
+            // We need to create a ColorMaterial from our simple RGBA color
+            let color_material: ColorMaterial = mole_type.color().into();
+            // Then, we add that new color material to our assets collection,
+            // storing the original handle created for it
+            let material_handle = material_assets.add(color_material);
+            // Assets are expensive and batching is critical for performance,
+            // so we're storing reference-counted pointers to a single common asset
+            // called "handles", then cloning references as needed
+            mole_colors.map.insert(mole_type, material_handle);
+        }
+
+        // The last expression evaluated is implicitly (and idiomatically) returned in Rust
+        mole_colors
+    }
+}
+
+impl MoleColors {
+    fn get_handle(&self, mole_type: MoleType) -> Handle<ColorMaterial> {
+        // We need to clone a new handle for each new mole we create.
+        // We can skip reference-counting using `clone_weak` rather than `clone`,
+        // since we know that the colors stored in our resource will never be unloaded
+        self.map
+            .get(&mole_type)
+            .expect("Missing color handle")
+            .clone_weak()
+    }
+}
+
+/// Resource that tracks when the next mole should be spawned
+struct SpawnTimer(Timer);
+
+impl Default for SpawnTimer {
+    fn default() -> Self {
+        const SPAWN_PERIOD: f32 = 0.5;
+
+        // The second value `true` sets the `repeating` field of the timer,
+        // causing the timer to reset when it ticks down to 0
+        SpawnTimer(Timer::from_seconds(SPAWN_PERIOD, true))
+    }
+}
+
+/// Spawns a new random mole whenever the SpawnTimer has elapsed
+fn spawn_mole_system(
+    mut commands: Commands,
+    mut spawn_timer: ResMut<SpawnTimer>,
+    windows: Res<Windows>,
+    time: Res<Time>,
+    mole_colors: Res<MoleColors>,
+) {
+    // Advance the timer by the amount of time that elapsed during the last game loop
+    spawn_timer.0.tick(time.delta());
+
+    // .0 refers to the first (and in this case only) field,
+    // of our SpawnTimer tuple struct: the Timer-type field
+    if spawn_timer.0.just_finished() {
+        // Initialize our pseudo-random number generator
+        let mut rng = rand::thread_rng();
+
+        // Grab the window so we can use its size to determine where the moles can spawn
+        let window = windows.get_primary().expect("No window found!");
+
+        // By default, the camera is centered on (0, 0)
+        // and we don't want the boxes to go outside of the screen
+        let x_limit = (window.width() - MOLE_SIZE) / 2.0;
+        let y_limit = (window.height() - MOLE_SIZE) / 2.0;
+
+        // Randomly determine properties of our new mole
+        let mole_pos_x = Uniform::from(-x_limit..x_limit).sample(&mut rng);
+        let mole_pos_y = Uniform::from(-y_limit..y_limit).sample(&mut rng);
+        let mole_type = MoleType::types()
+            .choose(&mut rng)
+            .expect("No mole type could be selected.");
+
+        // Spawn our new mole
+        commands
+            // This creates an empty entity
+            .spawn()
+            // First, we add a marker component to it
+            // (in case we want to filter for only moles later)
+            .insert(Mole)
+            // Then, we add a collection of components called a bundle
+            // to give our moles an associated graphical sprite
+            .insert_bundle(SpriteBundle {
+                sprite: Sprite::new(Vec2::new(MOLE_SIZE, MOLE_SIZE)),
+                // Get the appropriate material handle for the type of mole
+                // to ensure consistent color-score correspondence
+                material: mole_colors.get_handle(mole_type),
+                transform: Transform::from_xyz(mole_pos_x, mole_pos_y, 0.0),
+                // This is "struct update syntax", and sets all other values of the SpriteBundle struct
+                // to their default values
+                ..Default::default()
+            })
+            //Then, we add a timer to our mole so it will despawn automatically if not clicked
+            .insert(DespawnTimer::default())
+            // Finally, we add our MoleType component to the new entity,
+            // with the appropriate randomly selected value
+            .insert(mole_type);
+    }
+}
+
+/// Automatically despawn anything with a DespawnTimer component when that timer elapses
+fn despawn_on_timer_system(
+    mut mole_query: Query<(Entity, &mut DespawnTimer)>,
+    time: Res<Time>,
+    mut commands: Commands,
+) {
+    for (entity, mut despawn_timer) in mole_query.iter_mut() {
+        // Each mole has its own timer, allowing them to despawn independently
+        despawn_timer.0.tick(time.delta());
+        if despawn_timer.0.finished() {
+            commands.entity(entity).despawn()
+        }
+    }
+}
+
+/// Handles mouse clicks and checks if you hit a mole
+fn whack_system(
+    mut commands: Commands,
+    windows: Res<Windows>,
+    mut score: ResMut<Score>,
+    mouse_input: Res<Input<MouseButton>>,
+    mole_query: Query<(Entity, &Transform, &MoleType), With<Mole>>,
+) {
+    // Get the mouse position in screen coordinates
+    let window = windows.get_primary().unwrap();
+    let win_size = Vec2::new(window.width(), window.height());
+    // The cursor may not be within the window
+    let maybe_screen_pos = window.cursor_position();
+
+    // Now, we need to convert the position from screen coordinates to world coordinates
+    // We declare this value outside of our branch to satisfy the compiler
+    let world_pos = match maybe_screen_pos {
+        Some(screen_pos) => screen_pos - win_size / 2.0,
+        None => Vec2::default(),
+    };
+
+    // Check for moles if the mouse button is pressed
+    if mouse_input.just_pressed(MouseButton::Left) {
+        for (mole_entity, mole_transform, mole_type) in mole_query.iter() {
+            //dbg!(mole_entity);
+            //let did_hit = mole_hit(world_pos, mole_transform);
+            //dbg!(did_hit);
+            if mole_hit(world_pos, mole_transform) {
+                // Each type of mole has its own point total
+                score.0 += mole_type.points();
+                // Despawn the mole once they've been clicked once
+                commands.entity(mole_entity).despawn();
+            }
+        }
+    }
+}
+
+// This helper function encapsulates our checking logic,
+// making the system above easier to follow
+fn mole_hit(cursor_pos: Vec2, mole_transform: &Transform) -> bool {
+    // Bevy transforms are relative to the center of the sprite
+    let mole_min_x = mole_transform.translation.x - 0.5 * MOLE_SIZE;
+    let mole_max_x = mole_transform.translation.x + 0.5 * MOLE_SIZE;
+
+    let mole_min_y = mole_transform.translation.y - 0.5 * MOLE_SIZE;
+    let mole_max_y = mole_transform.translation.y + 0.5 * MOLE_SIZE;
+
+    // If the cursor is within both the x and y range, it is within the box
+    mole_min_x <= cursor_pos.x
+        && cursor_pos.x <= mole_max_x
+        && mole_min_y <= cursor_pos.y
+        && cursor_pos.y <= mole_max_y
+}
+```
+
+If you'd like to see more tiny but cohesive examples like this, check out our [game examples](https://github.com/bevyengine/bevy/tree/latest/examples/game) on the Bevy GitHub repository.
diff --git a/content/learn/book/ecs/commands/_index.md b/content/learn/book/ecs/commands/_index.md
index 7d23555b14..98537234a8 100644
--- a/content/learn/book/ecs/commands/_index.md
+++ b/content/learn/book/ecs/commands/_index.md
@@ -1,12 +1,156 @@
 +++
-title = "Manipulating entities with commands"
-weight = 4
+title = "Commands queue up work"
+weight = 5
 template = "book-section.html"
 page_template = "book-section.html"
+insert_anchor_links = "right"
 +++
 
-TODO: explain what commands are used for
+**Commands** are powerful, unrestricted tools for deferring complex or heavily-blocking work.
+They are commonly used to:
 
-TODO: explain that they only run at the end of the stage, mention that they have exclusive world access
+- Spawn and despawn entities
+- Add and remove components to entities
+- Work across entity boundaries in hierarchal ways
+- Add and remove resources dynamically
 
-TODO: show how to spawn, despawn and modify entities with commands
+Commands are fundamentally designed to perform work that cannot be safely done in parallel, and are used to change the world in ways that touch large amounts of data at once (requiring exclusive access to the [archetypes](../../game-logic/system-ordering/_index.md) and other metadata of the [`World`].
+The [`Command`] trait used by each method on [`Commands`] takes in `&mut World` as the only argument to its [`write`] method, allowing commands to modify the entire world in arbitrary, sequential ways.
+
+As a result, **commands do not take effect immediately.**
+Instead, they must wait until the next **hard sync point** (where each step executed has  [exclusive access](../exclusive-world-access/_index.md) to the entire world in a sequential fashion) in order to be resolved as they require exclusive mutable access to the world.
+In other word: commands are processed at the end of each stage.
+
+You should avoid using commands unnecessarily.
+For example, you *could* use the overwriting behavior of component insertion to mutate components in place.
+However, this is unclear, relatively expensive and takes delayed effect: it is strictly worse than just requesting the appropriate data and mutating it.
+If you wish to defer work but do not need to spawn entities, add/remove components or add/remove resources, you likely can (and should) just use [events](../../game-logic/events/_index.md) instead.
+
+[`Command`]: https://docs.rs/bevy/0.6.0/bevy/ecs/system/trait.Command.html
+[`Commands`]: https://docs.rs/bevy/0.6.0/bevy/ecs/system/struct.Commands.html
+[`World`]: https://docs.rs/bevy/0.6.0/bevy/ecs/world/struct.World.html
+
+## Usage
+
+As discussed in [entities have components](../entities-components/_index.md), commands are used by adding a [`Commands`]-type system parameter, then appending various tasks to its end through the provided methods.
+For a basic overview of how they're used, please refer to that page.
+
+For more detailed information on the available methods, check [`Commands`] and [`EntityCommands`], which operate on a single entity.
+
+[`EntityCommands`]: https://docs.rs/bevy/0.6.0/bevy/ecs/system/struct.EntityCommands.html
+
+### Custom commands
+
+You can extend the [`Command`] trait to create your own commands, performing tasks with far-reaching consequences without requiring access to that data in your originating systems.
+
+Let's walk through the steps needed to create a new custom command:
+
+```rust
+// Usually, this setup will be handled automatically
+// by your Bevy app, but you can perform it manually
+let world = World::new();
+let command_queue = CommandQueue::default()
+let commands = Commands::new(command_queue, world);
+
+// First, we need to create a struct that stores any data needed by the command
+struct StoreMessage {
+    // This functionality is not very useful,
+    // and is included for teaching purposes
+    message: String,
+}
+
+// Next, we need to implement the `Command` trait for that struct
+// which describes how the command changes the world
+impl Command for StoreMessage {
+    // This method allows us to read from and modify
+    // *any* part of the world that we want
+    fn write(self, _world: &mut World) {
+        // Here though, we're simply passing on the message stored
+        info!(self.message);
+    }
+}
+
+// We can add our new command directly to our Commands struct
+// by inserting an instance of this new type
+commands.add(StoreMessage{message: "Added directly!"});
+
+// For better ergnonomics, we can instead choose to create an extension trait,
+// which allows us to add new methods to commands
+trait EntityCounting {
+    fn store_message(&mut self, message: String);
+}
+
+// We implement our new extension trait for the `Commands` type,
+// giving us access to a new method
+impl<'a> EntityCounting for Commands<'a> {
+    fn store_message(&mut self, message: String) {
+        self.add(StoreMessage { String })
+    }
+}
+
+// Now it's just another method!
+commands.store_message("Now with trait extensions!");
+
+// Finally, let's apply all of our commands to verify that this worked as we hoped
+command_queue.apply(world);
+```
+
+Due to the delayed effect of commands, their excessive power, and their relatively poor performance (they can only be executed one at a time in sequence), you should only use custom commands for tasks that truly need their world-altering powers.
+In many cases, an event-emitting system combined with an event-handling system will be faster, more ergonomic and easier to debug.
+
+For more details on how to work with `&mut World` to perform logic in custom commands, see the page on [exclusive world access](../exclusive-world-access/_index.md).
+
+### Manually flushing commands
+
+Ordinarily, commands are only applied at the end of each stage.
+This is because they require exclusive mutable access to the [`World`].
+
+However, if you already have exclusive access to the [`World`], you can use [`SystemState::<Commands>::apply()`] to immediately run and clear any {{rust_type(type="struct" crate="bevy" mod = "ecs/system" name="Commands" no_mod = "true")}} that may have accumulated.
+
+```rust
+use bevy::prelude::*;
+use bevy::ecs::system::SystemState;
+
+let world = World::new();
+
+let mut system_state = SystemState::<Commands>::new(&mut world);
+
+// Manually adding a command to the list to verify that this works
+let mut commands = system_state.get_mut();
+commands.spawn();
+
+// Applies all accumulated commands to the world, causing them to take immediate effect
+system_state.apply(&mut world);
+```
+
+Generally speaking, this isn't useful for the average game: you can't get exclusive world access any faster than commands naturally apply.
+However, this technique can be incredibly useful for advanced control flows that are willing to sacrifice some parallelism in order to immediately (or repeatedly) process commands.
+
+[`SystemState::<Commands>::apply()`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.SystemState#method.apply
+
+## Internal mechanics
+
+Due to some internal special-casing to reduce blocking, it can be challenging to grasp how commands are actually implemented.
+This section discusses a few of the details that can matter as an advanced end user.
+
+### System parallelism and commands
+
+Ordinarily, mutable access to data in Bevy requires exclusive access: preventing more than one system that use this data from running at the same time.
+
+However, [`Commands`] are special-cased, due to their prevalence in a way that takes advantage of their append-only nature.
+
+A fresh [`Commands`] struct is dispatched to each system and then each instance processed later according to the execution order of the originating systems.
+
+### Application order
+
+When combining the effects of multiple commands, it can be important to be aware of the exact order in which your commands are executed can be vitally important.
+If one system is spawning an entity and then passing off its [`Entity`] identifier to another system, the entity must be spawned before the second system attempts to add components to it!
+
+Thankfully, while their effect is delayed, their application order follows a few simple rules:
+
+1. Commands are always applied one at a time.
+2. All commands created by a given system are applied sequentially, in the order in which the methods were called on the [`Commands`] object in that system.
+3. If a system is explicitly specified (using [`.before`] or [`.after`]) to occur before another system, its commands will always be applied first.
+4. If two systems do not have an [explicit ordering](../../game-logic/system-ordering/_index.md) between them (including any transitive ordering from e.g. A before B before C), the order in which their commands are applied is unspecified, and may vary between runs of the app.
+
+[`Entity`]: https://docs.rs/bevy/0.6.0/bevy/ecs/entity/struct.Entity.html
diff --git a/content/learn/book/ecs/detecting-changes/_index.md b/content/learn/book/ecs/detecting-changes/_index.md
new file mode 100644
index 0000000000..ebf42e7e8f
--- /dev/null
+++ b/content/learn/book/ecs/detecting-changes/_index.md
@@ -0,0 +1,147 @@
++++
+title = "Detecting changes"
+weight = 6
+template = "book-section.html"
+page_template = "book-section.html"
+insert_anchor_links = "right"
++++
+
+Bevy allows you to respond to the addition of or changes to specific component types using the [`Added`] and [`Changed`] query filters.
+These are incredibly useful, allowing you to:
+
+- automatically complete initialization of components
+- keep data in sync
+- save on work by only operating on entities where the relevant data has been updated
+- automatically respond to changes in the data of UI elements
+
+A component will be marked as "added" on a per-system basis if it has been added to that entity (via component insertion or being spawned on an entity) since the last time that system ran.
+Similarly, a component will be marked as "changed" on a per-system basis if it has been added or mutably dereferenced since the last time that system ran.
+As you ([almost always](https://doc.rust-lang.org/book/ch15-05-interior-mutability.html)) need to mutably dereference data out of its wrapper in order to mutate it, this gives an accurate (and fast!) indication that the data may have changed.
+
+Change detection works for resources too, using the exact same internal mechanisms!
+Use the [`is_changed()`] and [`is_added()`] methods on resources (or individual components) to check if they've been added or changed since the last time this system ran.
+
+The [`Added`] and [`Changed`] types are query filters, restricting the list of entities returned.
+They are used in the second type parameter of our [`Query`] data types.
+
+Let's get familiar with them by examining a few snippets of gameplay code.
+You might use an addition-tracking system to automatically change the difficulty of your game's enemies:
+
+```rust
+// Enums can be used directly as both resources and components
+enum Difficulty {
+    Easy,
+    Medium,
+    Hard
+}
+
+impl Difficulty {
+    fn modifier(&self) -> f32 {
+        const EASY_DIFFICULTY_MODIFIER: f32 = 0.5;
+        const HARD_DIFFICULTY_MODIFIER: f32 = 2.0;
+
+        match *self {
+            Difficulty::Easy => EASY_DIFFICULTY_MODIFIER,
+            Difficulty::Normal => 1.0,
+            Difficulty::Hard => HARD_DIFFICULTY_MODIFIER,
+        }
+    }
+}
+
+#[derive(Component)]
+struct Life(f32);
+
+// This will detect all new entities that spawned with the `Life` component, or entities who just had that component added
+fn difficulty_adjusting_system(difficulty: Res<Difficulty>, query: Query<&mut Life, Added<Life>>){
+    let modifier = difficulty.modifier();
+
+    // Each relevant entity will always be affected exactly once by this system
+    for life in query.iter_mut(){
+        // We can't just change the values that our entities spawn with,
+        // because the modifier can change at run-time
+        // and we don't want to duplicate this code everywhere
+        life.0 *= modifier;
+    } 
+}
+```
+
+Of course, if our difficulty changes in the middle of the game, existing entities won't be modified correctly!
+Let's fix that, with a demonstration of resource change detection.
+
+```rust
+// We need to keep track of the old difficulty, so we can reverse the changes easily
+struct OldDifficulty(Difficulty);
+
+// We have to be sure that this system runs *after* difficulty_changed_system
+// so then we have the correct cached value of Difficulty when we update enemy stats
+fn old_difficulty_system(difficulty: Res<Difficulty>, mut old_difficulty: ResMut<OldDifficulty>){
+    // Here, we're checking whether the `Difficulty` resource's value has changed
+    // By checking if difficulty has changed, we can avoid constantly rewriting this value
+    if difficulty.is_changed(){
+        old_difficulty.0 = difficulty;
+    }
+}
+
+fn difficulty_changed_system(difficulty: Res<Difficulty>, old_difficulty: Res<OldDifficulty> query: Query<&mut Life>){
+    if difficulty.is_changed(){
+        // Reverse the previous difficulty adjustment
+        let old_modifier = old_difficulty.0.modifier();
+        // Apply the new multiplier
+        let new_modifer = difficulty.modifier();
+        let net_modifier = new_modifier / old_modifier;
+
+        // Apply the final change to every entity with `Life`!
+        for life in query.iter_mut(){
+            life.0 *= net_modifier;
+        } 
+    }
+}
+```
+
+[`Changed`] can be used with precisely the same syntax, and is incredibly useful for avoiding repeated work.
+For example, you might use it to efficiently check whether units are in a particular area each frame:
+
+```rust
+/// Detects enemies that have reached the entrance in a tower defense game
+fn enemy_escape_system(query: Query<&Transform, (With<Enemy>, Changed<Transform>>>, exit: Res<Exit>, lives: ResMut<Lives>){
+    for enemy_transform in query.iter(){
+        if exit.in_range(transform) {
+            lives.0 -= 1;
+        }
+    }
+}
+```
+
+[`Added`]: https://docs.rs/bevy/latest/bevy/ecs/query/struct.Added.html
+[`Changed`]: https://docs.rs/bevy/latest/bevy/ecs/query/struct.Changed.html
+[`is_added`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Res.html#method.is_added
+[`is_changed`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Res.html#method.is_changed
+[`Query`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Query.html
+
+### The details of change detection
+
+Change detection in Bevy works via a custom implementation of the [`DerefMut`] trait of our mutable [smart pointer](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html) wrappers (such as [`Mut`] and [`ResMut`]).
+As a result:
+
+1. Changes won't be flagged when you use [interior mutability](https://doc.rust-lang.org/book/ch15-05-interior-mutability.html). You should probably manually flag the data as having changed using the [`set_changed()`] method when you do this to prevent tricky bugs in other consumers of your component.
+2. Changes will be flagged whenever you mutably access a component or resource, even if you don't change its value. Only mutably dereference the data if you know you're going to change it to avoid false positives caused in this way.
+
+[`DerefMut`]: https://doc.rust-lang.org/std/ops/trait.DerefMut.html
+[`Mut`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.Mut.html
+[`ResMut`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.ResMut.html
+[`set_changed()`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.Mut.html#method.set_changed
+
+## Removal detection
+
+We can watch for the removal of components too, although the mechanisms are quite different.
+[`RemovedComponents`] is a system parameter, returning an iterator of all entity identifiers from whom components of that type were removed during the last frame.
+This includes entities with that component who were despawned.
+There are three important caveats here:
+
+1. While [`Added`] and [`Changed`] operate on the basis of "since the last time this system ran", removal detection only works for the last frame. This distinction is very important if your system does not run every frame due to states or run criteria.
+2. [`RemovedComponents`] does not return the *value* of the component that was removed, due to performance concerns. If you need this, you will need to include your own change-detecting system to cache the values before they are removed.
+3. The [`RemovedComponents`] system parameter is not a query filter. As a result, you will have to manually compare it to the results of a query if you only need to handle some subset of component removal events.
+
+Despite [these caveats](https://github.com/bevyengine/bevy/issues/2148), removal detection can be quite useful for handling complex cleanup and toggling behavior through the addition and removal of components.
+
+[`RemovedComponents`]: https://docs.rs/bevy/latest/bevy/prelude/struct.RemovedComponents.html
diff --git a/content/learn/book/ecs/ecs-magic/_index.md b/content/learn/book/ecs/ecs-magic/_index.md
new file mode 100644
index 0000000000..6e9580458c
--- /dev/null
+++ b/content/learn/book/ecs/ecs-magic/_index.md
@@ -0,0 +1,122 @@
++++
+title = "Understanding the magic"
+weight = 8
+template = "book-section.html"
+page_template = "book-section.html"
+insert_anchor_links = "right"
++++
+
+By this point, it's common for new Bevy users to have a few questions about how the high-level tools you've been introduced to actually perform their feats of cunning ergonomics.
+You may have wondered:
+
+1. How does Bevy convert a function to a system when we call {{rust_type(type = "struct" crate = "bevy" mod = "app" name = "App" method = "add_system")}}?
+2. How does the app know which data a given system needs access to?
+3. How are systems called by the main game loop?
+4. How does each system actually *get* its data?
+
+**This page is *completely* optional; if you just want to make cool things, embrace the magic and skip this page!**
+
+Now, let's pull back the curtain, and take a look at the inner mechanisms and low-level APIs of {{rust_mod(crate = "bevy_ecs")}} to answer these questions, one at a time.
+
+### Adding functions as systems
+
+Conceptually, this is straightforward: we pass in our functions as [first-class objects](https://en.wikipedia.org/wiki/First-class_function), examine their properties, store them in our [`Schedule`] and then call them repeatedly when our [`App`]'s [`runner`] requests them.
+
+But of course, that's hand-waving: how does it *really* work?
+We can pick up the trail by examining [`App::add_system`]: we find that it's generic over any type that implements the [`IntoSystemDescriptor`] trait.
+
+This trait defines a conversion between the underlying function, and the [`SystemDescriptor`] representation, which stores scheduler-relevant information, as well as the system itself in [`BoxedSystem`] form, which is a [boxed](https://doc.rust-lang.org/std/boxed/index.html) [`System`] trait object.
+
+Once our system is neatly boxed up, we can examine the methods of [`System`], which provide an interface to access all of the interesting information about the function that we've transformed into a system.
+The most important method here is [`System::run`], which allows callers (like a [`Schedule`]) to correctly run the system.
+
+Functions are converted into systems using a [blanket implementation](https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods) of the [`IntoSystem`] trait, allowing us to [extend](http://xion.io/post/code/rust-extension-traits.html) existing functions whose signature meets our criteria.
+By calling the [`IntoSystem::system()`] method when we attempt to run our systems, our function starts its path to becoming a well-behaved, fully-initialized system.
+
+The [blanket implementation in question](https://github.com/bevyengine/bevy/blob/6615b7bf6439c9bcaf59982b2713e1c1564bf0f5/crates/bevy_ecs/src/system/function_system.rs#L422) covers `impl<In, Out, Param, Marker, F> IntoSystem<In, Out, (IsFunctionSystem, Param, Marker)> for F` where `F` implements [`IntoSystem`].
+Here, at the bottom of our stack of abstractions, we find the heart of the magic: a collection of implementations (generated by macro due to the lack of [variadic generics](https://github.com/rust-lang/rfcs/issues/376)) that describe how to convert functions with arguments that implement [`SystemParam`], along with a [`System::run_unsafe`] method!
+
+[`Schedule`]: https://docs.rs/bevy/latest/bevy/ecs/schedule/struct.Schedule.html
+[`App`]: https://docs.rs/bevy/latest/bevy/app/struct.App.html
+[`runner`]: https://docs.rs/bevy/latest/bevy/app/struct.App.html#structfield.runner
+[`App::add_system`]: https://docs.rs/bevy/latest/bevy/app/struct.App.html#method.add_system
+[`IntoSystemDescriptor`]: https://docs.rs/bevy/latest/bevy/ecs/schedule/trait.IntoSystemDescriptor.html
+[`SystemDescriptor`]: https://docs.rs/bevy/latest/bevy/ecs/schedule/enum.SystemDescriptor.html
+[`BoxedSystem`]: https://docs.rs/bevy/latest/bevy/ecs/system/type.BoxedSystem.html
+[`System`]: https://docs.rs/bevy/latest/bevy/ecs/system/trait.System.html
+[`System::run`]: https://docs.rs/bevy/latest/bevy/ecs/system/trait.System.html#method.run
+[`IntoSystem`]: https://docs.rs/bevy/latest/bevy/ecs/system/trait.IntoSystem.html
+[`IntoSystem::system()`]: https://docs.rs/bevy/latest/bevy/ecs/system/trait.IntoSystem.html#tymethod.system
+[`SystemParam`]: https://docs.rs/bevy/latest/bevy/ecs/system/trait.SystemParam.html
+[`System::run_unsafe`]: https://docs.rs/bevy/latest/bevy/ecs/system/trait.System.html#tymethod.run_unsafe
+
+### Smart data access
+
+So, how do systems know which data they need access to in order to enable multiple systems to safely and automatically run in parallel?
+In the [`System`] trait, we can see two relevant methods: [`component_access`] and [`archetype_component_acesss`].
+
+The [`Access`] struct returned by those methods keeps track of the read and write accesses of a system: either on a [`ComponentId`] or [`ArchetypeComponentId`].
+These store the types of each resource and component as a cheap, safe identifier ultimately created out of a [`TypeId`] during type registration, which automatically occurs the first time a component or resource type is used.
+This, fundamentally, is why we're limited to one of each type of component per entity: we use this type information to dispatch data.
+
+Through the use of [`Access::is_compatible`], we can determine if two systems have compatible data access patterns, and block them from running in parallel if they do not.
+This can be done in a smart, cached fashion and is combined with explicit system ordering constraints to create a list of systems and their constraints.
+Systems are run in a greedy fashion, scheduling the next available unconstrained system as soon as a thread is free to accept work.
+
+But of course, every answer leads to more questions! How does Bevy know which access a system will need based on the arguments of the underlying function?
+To get the answer to this question, we must turn to the [`SystemParam`] trait once more.
+
+You'll recall that every parameter in our system functions must implement [`SystemParam`], and this information is somehow transformed into a fully-fledged [`System`]-implementing object, which has the access information we're curious about.
+
+The key is in the associated type [`Fetch`] on [`SystemParam`].
+This type must implement the [`SystemParamFetch`] trait,
+and stores the information we need inside its [`SystemMeta`] field.
+Inside *that* is a private field: `archetype_component_access: Access<ArchetypeComponentId>`, allowing the implementer to define the component data (at an [archetype level of granularity](https://github.com/bevyengine/bevy/pull/1525)) that are accessed by this system parameter!
+
+The accesses of a system are defined as the [union](https://en.wikipedia.org/wiki/Union_(set_theory)) of the accesses of all of its system parameters, allowing us to convert from the access needed for each parameter into the final form needed by the scheduler, concluding our detective work for the day.
+
+[`component_access`]: https://docs.rs/bevy/latest/bevy/ecs/prelude/trait.System.html#tymethod.component_access
+[`archetype_component_access`]: https://docs.rs/bevy/latest/bevy/ecs/prelude/trait.System.html#tymethod.archetype_component_access
+[`Access`]: https://docs.rs/bevy/latest/bevy/ecs/query/struct.Access.html
+[`ComponentId`]: https://docs.rs/bevy/latest/bevy/ecs/component/struct.ComponentId.html
+[`ArchetypeComponentId`]: https://docs.rs/bevy/latest/bevy/ecs/archetype/struct.ArchetypeComponentId.html
+[`TypeId`]: https://doc.rust-lang.org/std/any/struct.TypeId.html
+[`Access::is_compatible`]: https://docs.rs/bevy/latest/bevy/ecs/query/struct.Access.html#method.is_compatible
+[`Fetch`]: https://docs.rs/bevy/latest/bevy/ecs/system/trait.SystemParam.html#associatedtype.Fetch
+[`SystemMeta`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.SystemMeta.html
+
+### Running systems
+
+What happens when we call [`App::run`]?
+Well, on the surface it's quite simple: our [`runner`] field of [`App`], which stores a function in the form of `Box<dyn Fn(App)>` is called, taking the configured app as its argument.
+
+By default, this begins as a `Box::new(run_once)`, which is a trivial function that calls [`App::update`] a single time.
+When this method is called, the [`World`]'s [`Schedule`] is initialized, then run as a [`Stage`].
+
+[`Stage`] takes a mutable reference to the world, and its typical implementer [`SystemStage`] contains all of Bevy's scheduling and dispatch logic, allowing us to carefully dole out access to our data in safely parallelized fashion.
+
+This simple "update the app once" runner logic can be easily customized and changed: both [by the end user](https://github.com/bevyengine/bevy/blob/main/examples/app/custom_loop.rs) and by our [`DefaultPlugins`] whose [`WinitPlugin`] changes the runner to [`winit_runner`], which  repeatedly updates the app and interfaces with the [`winit`] crate Bevy depends on to establish windowing and input handling before the system schedule is run.
+
+[`App::run`]: https://docs.rs/bevy/latest/bevy/app/struct.App.html#method.run
+[`App::update`]: https://docs.rs/bevy/latest/bevy/app/struct.App.html#method.update
+[`Stage`]: https://docs.rs/bevy/latest/bevy/ecs/schedule/trait.Stage.html
+[`SystemStage`]: https://docs.rs/bevy/latest/bevy/ecs/schedule/struct.SystemStage.html
+[`DefaultPlugins`]: https://docs.rs/bevy/latest/bevy/struct.DefaultPlugins.html
+[`WinitPlugin`]: https://docs.rs/bevy/latest/bevy/winit/struct.WinitPlugin.html
+[`winit`]: https://docs.rs/winit/latest/winit/
+
+### Data dispatch
+
+There's one last piece of the puzzle: how do we actually pass references to that data from the [`World`] into our systems when the schedule is run?
+
+For parallel systems, this logic is contained within [`FunctionSystem::run_unsafe`], which is a method of the [`System`] trait.
+Ultimately, the data is fetched using the unsafe method [`SystemParamFetch::get_param`], which extracts the information specified in [`SystemMeta`] from the world directly.
+
+The safety of this is fundamentally upheld by our **executor**, which runs our schedule according to a particular strategy.
+Executors must update the list of archetypes that exist in the world each frame to ensure that system data access is safe and avoid false-positives by splitting our column-like component data storage into non-overlapping sets based on the collection of components that entities in our world actually have.
+The default executor used in Bevy is [`ParallelExecutor`], which executes systems in parallel in a simple and non-deterministic first-come-first-serve fashion that respects system ordering.
+Check out the source code (and the [section on system ordering](../../game-logic/system-ordering/_index.md)) for more details on how this is done.
+
+[`FunctionSystem::run_unsafe`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.FunctionSystem.html#method.run_unsafe
+[`SystemParamFetch::get_param`]: https://docs.rs/bevy/latest/bevy/ecs/system/trait.SystemParamFetch.html#tymethod.get_param
+[`ParallelExecutor`]: https://docs.rs/bevy/latest/bevy/ecs/schedule/struct.ParallelExecutor.html
diff --git a/content/learn/book/ecs/entities-components/_index.md b/content/learn/book/ecs/entities-components/_index.md
index eebec79298..6dd4127f84 100644
--- a/content/learn/book/ecs/entities-components/_index.md
+++ b/content/learn/book/ecs/entities-components/_index.md
@@ -3,8 +3,293 @@ title = "Entities have components"
 weight = 1
 template = "book-section.html"
 page_template = "book-section.html"
+insert_anchor_links = "right"
 +++
 
-TODO: explain the basic data model
+As we discussed in the introduction to this chapter, **entities** represent objects in your game world, whose data is stored in the form of components.
 
-TODO: show how to create an entity, add components to it, and query for it in pure `bevy_ecs`
+## Spawning and despawning entities
+
+Before you can do much of anything in Bevy, you'll need to **spawn** your first entity, adding it to the app's [`World`].
+Once entities exist, they can likewise be despawned, deleting all of the data stored in their components and removing it from the world.
+
+There are two APIs to do so. The first is more direct, allowing you to add and remove entities directly on the world.
+
+```rust
+use bevy::prelude::*;
+
+// Creates a new world
+let mut world = World::new();
+// Spawns an entity with no components
+world.spawn();
+// Spawns a second entity, keeping track of its unique identifier
+let my_entity = world.spawn().id();
+// Uses the second entity's unique identifier to despawn it
+world.despawn(my_entity);
+```
+
+If you're using Bevy as a whole (rather than just [`bevy_ecs`]), you'll tend to find that working with the world directly is rare:
+often reserved for [writing tests](https://github.com/bevyengine/bevy/blob/main/tests/how_to_test_systems.rs).
+Instead, almost all of your logic will be contained within systems,
+which don't have the permissions to immediately spawn or despawn new entities (what if someone else was using that?!).
+To work around this, we use **commands**, which have a delayed effect.
+For now, let's take a look at how we can use them to work with entities in simple ways (you can read about all the details [later in this chapter](../commands/_index.md)).
+
+```rust
+// This system needs to have a mutable argument with the `Commands` type
+// allowing it to queue up commands to be processed at the end of the stage
+fn spawning_system(mut commands: Commands){
+    // These commands perform the exact same operations
+    // as the previous code snippet,
+    // but at the end of the stage, rather than immediately
+    commands.spawn();
+    let my_entity = commands.spawn().id();
+    commands.despawn(my_entity);
+}
+```
+
+[`World`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html
+[`bevy_ecs`]: https://crates.io/crates/bevy_ecs
+
+## Working with components
+
+Entities are entirely bare when they're spawned: they contain no data other than their unique [`Entity`] identifier.
+This of course is not very useful, so let's discuss how we can add and remove components to them which store data and enable behavior through systems.
+
+[`Entity`]: https://docs.rs/bevy/latest/bevy/ecs/entity/struct.Entity.html
+
+### Defining components
+
+To define a component type, we simply implement the [`Component`] trait for a Rust type of our choice.
+You will almost always want to use the `#[derive(Component)]` macro to do this for you; which quickly and reliably generates the correct trait implementation.
+Any underlying component data must be `Send + Sync + 'static` (enforced by the [trait bounds](https://doc.rust-lang.org/book/ch10-02-traits.html#trait-bound-syntax) on [`Component`]).
+This ensures that the data can be sent across the threads safely and allows our [type reflection tools](https://github.com/bevyengine/bevy/tree/main/crates/bevy_reflect) to work correctly.
+
+With the theory out of the way, let's define some components!
+
+```rust
+// This is a dataless "unit struct", which holds no data of its own.
+// In Bevy, these are useful for distinguishing similar entities or toggling behavior
+// and are called "marker components"
+#[derive(Component)]
+struct Combatant;
+
+// This simple components wrap a u8 in a tuple struct
+#[derive(Component)]
+struct Life(u8);
+
+// We can store arbitrary data in our components, as long as it has a 'static lifetime
+// Types without lifetimes are always 'static,
+// allowing us to safely hold a String, but not a &str
+#[derive(Component)]
+struct Name(String);
+
+// Naming your components' fields,
+// makes them easier and safer to refer to
+#[derive(Component)]
+struct Stats {
+    strength: u8,
+    dexterity: u8,
+    intelligence: u8,
+}
+
+// Enum components are great for storing mutually exclusive states
+#[derive(Component)]
+enum Allegiance {
+    Friendly,
+    Neutral,
+    Hostile
+}
+```
+
+[`Component`]: https://docs.rs/bevy/latest/bevy/ecs/component/trait.Component.html
+
+### Spawning entities with components
+
+Now that we have some components defined, let's try adding them to our entities using [`Commands`].
+
+```rust
+fn spawn_combatants_system(mut commands: Commands) {
+    commands
+        .spawn()
+        // This inserts a data-less `Combatant` component into the entity we're spawning
+        .insert(Combatant)
+        // We configure starting component values by passing in concrete instances of our types
+        .insert(Life(10))
+        // By chaining .insert method calls like this, we continue to add more components to our entity
+        .insert(Name("Gallant".to_string()))
+        // Instances of named structs are constructed with {field_name: value}
+        .insert(Stats {
+            strength: 15,
+            dexterity: 10,
+            intelligence: 8,
+        })
+        // Instances of enums are created by picking one of their variants
+        .insert(Allegiance::Friendly);
+
+    // We've ended our Commands method chain using a ;,
+    // and so now we can create a second entity
+    // by calling .spawn() again
+    commands
+        .spawn()
+        .insert(Combatant)
+        .insert(Life(10))
+        .insert(Name("Goofus".to_string()))
+        .insert(Stats {
+            strength: 17,
+            dexterity: 8,
+            intelligence: 6,
+        })
+        .insert(Allegiance::Hostile);
+}
+```
+
+[`Commands`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Commands.html
+
+### Adding and removing components
+
+Once an entity is spawned, you can use [`Commands`] to add and remove components from them dynamically.
+
+```rust
+
+#[derive(Component)]
+struct InCombat;
+
+// This query returns the `Entity` identifier of all entities
+// that have the `Combatant` component but do not yet have the `InCombat` component
+fn start_combat_system(query: Query<Entity, (With<Combatant>, Without<InCombat>>, mut commands: Commands){
+    for entity in query.iter(){
+        // The component will be inserted at the end of the current stage
+        commands.entity(entity).insert(InCombat);
+    }
+}
+
+// Now to undo our hard work
+fn end_combat_system(query: Query<Entity, (With<Combatant>, With<InCombat>>, mut commands: Commands){
+    for entity in query.iter(){
+        // The component will be removed at the end of the current stage
+        commands.entity(entity).remove(InCombat);
+    }
+}
+```
+
+## Bundles
+
+As you might guess, the one-at-a-time component insertion syntax can be both tedious and error-prone as your project grows.
+To get around this, Bevy abstracts these patterns using **component bundles**.
+These are implemented by implementing the [`Bundle`] trait for a struct; turning each of its fields into a distinct component on your entity when they are inserted.
+
+Let's try rewriting that code from above.
+
+```rust
+#[derive(Bundle)]
+struct CombatantBundle {
+    combatant: Combatant
+    life: Life,
+    stats: Stats,
+    allegiance: Allegiance,
+}
+
+// We can add new methods to our bundle type that return Self
+// to create principled APIs for entity creation.
+// The Default trait is the standard tool for creating
+// new struct instances without configuration 
+impl Default for CombatantBundle {
+    fn default() -> Self {
+        CombatantBundle {
+            combatant: Combatant,
+            life: Life(10),
+            stats: Stats {
+                strength: 10,
+                dexterity: 10,
+                intelligence: 10,
+            }
+            allegiance: Allegiance::Neutral,
+        }
+    }
+}
+
+fn spawn_combatants_system(mut commands: Commands) {
+    commands
+        .spawn()
+        // We're using struct-update syntax to modify 
+        // the instance of `CombatantBundle` returned by its default() method
+        // See the page on Rust Tips and Tricks at the end of this chapter for more info!
+        .insert_bundle(CombatantBundle{
+            stats: Stats {
+                strength: 15,
+                dexterity: 10,
+                intelligence: 8,
+            }
+            allegiance: Allegiance::Friendly,
+            ..Default::default()
+        })
+        // We can continue to chain more .insert or .insert_bundle methods
+        // to add more components and extend behavior
+        .insert(Name("Gallant".to_string()));
+    
+    commands
+        // .spawn_bundle is just syntactic sugar for .spawn().insert_bundle
+        .spawn_bundle(CombatantBundle{
+            stats: Stats {
+                strength: 17,
+                dexterity: 8,
+                intelligence: 6,
+            }
+            allegiance: Allegiance::Hostile,
+            ..Default::default()
+        })
+        .insert(Name("Goofus".to_string()));}
+```
+
+[`Bundle`]: https://docs.rs/bevy/latest/bevy/ecs/bundle/trait.Bundle.html
+
+### Nested bundles
+
+As your game grows further in complexity, you may find that you want to reuse various bundles across entities that share some but not all behavior.
+One of the tools you can use to do so is **nested bundles**; embedding one bundle of components within another.
+Be mindful; this can lead to overwrought, deeply nested code if overused and bundles are [not currently checked](https://github.com/bevyengine/bevy/issues/2387) for duplicate component types.
+Later instances of the same type will overwrite earlier ones.
+
+With those caveats out of the way, let's take a look at the syntax by converting the bundle above to a nested one by creating a bundle of components that deal with related functionality.
+
+```rust
+#[derive(Bundle)]
+struct AttackableBundle{
+    life: Life,
+    attack: Attack,
+    defense: Defense,
+}
+
+#[derive(Bundle)]
+struct CombatantBundle {
+    combatant: Combatant
+    // This attribute macro marks our attackable_bundle field as a bundle,
+    // allowing Bevy to properly flatten it out when building the final entity
+    #[bundle]
+    attackable_bundle: AttackableBundle,
+    position: Position,
+    stats: Stats,
+    allegiance: Allegiance,
+}
+
+impl Default for CombatantBundle {
+    fn default() -> Self {
+        CombatantBundle {
+            combatant: Combatant,
+            attackable_bundle: AttackableBundle {
+                life: Life(10),
+                attack: Attack(5),
+                defense: Defense(1),
+            }
+            position: Position(0, 0),
+            stats: Stats {
+                strength: 10,
+                dexterity: 10,
+                intelligence: 10,
+            }
+            allegiance: Allegiance::Neutral,
+        }
+    }
+}
+```
diff --git a/content/learn/book/ecs/exclusive-world-access/_index.md b/content/learn/book/ecs/exclusive-world-access/_index.md
index b44ee28d54..d9745832ea 100644
--- a/content/learn/book/ecs/exclusive-world-access/_index.md
+++ b/content/learn/book/ecs/exclusive-world-access/_index.md
@@ -1,14 +1,168 @@
 +++
-title = "Exclusive `World` access"
-weight = 8
+title = "Exclusive world access"
+weight = 7
 template = "book-section.html"
 page_template = "book-section.html"
+insert_anchor_links = "right"
 +++
 
-TODO: show how to work with a raw world
+In various places, Bevy code works directly with the [`World`]'s data, gaining exclusive, blocking access to it and allowing for arbitrary mutations.
+This is very flexible, and can be essential for advanced use cases, but prevents any other systems from running simultaneously and can often be harder to reason about and maintain.
+As a result, you should use only exclusive [`World`] access when you have to.
+You might be working with the [`World`] if:
 
-TODO: discuss and demonstrate custom commands
+- you're running an exclusive system to access data in unusually broad ways (such as for saving the game or handling networking)
+- you're writing a custom [`Command`], to execute logic at the end of the system
+- you're initializing a resource using the [`FromWorld`] trait
+- you're setting up integration tests
+- you're using [`bevy_ecs`] as a standalone crate
 
-TODO: discuss and demonstrate exclusive systems
+[`Command`]: https://docs.rs/bevy/latest/bevy/ecs/system/trait.Command.html
+[`World`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html
+[`FromWorld`]: https://docs.rs/bevy/latest/bevy/ecs/world/trait.FromWorld.html
+[`bevy_ecs`]: https://crates.io/crates/bevy_ecs
 
-TOD: discuss and demonstrate `NonSend` resources
+## Basic usage
+
+Generally speaking, the API of working directly with the [`World`] mirrors those used by [`Commands`] that you might be familiar with.
+
+Like with [`Commands`], you can call [`World::spawn`], and [`World::despawn`] to add and remove entities, adding components to them with [`World::insert`].
+Resources are simply accessed with [`World::get_resouce`] and the mutable equivalent [`World::get_resouce_mut`], for when you need to modify a resource's value.
+
+Like with queries, you can call [`World::get`] and [`World::get_mut`] to access component data of a particular sort on a given entity.
+If you want access to *all* of the data on an entity, use [`World::get_entity`] and [`World::get_entity_mut`], along with various [`EntityRef`] and [`EntityMut`] methods to operate on the returned object.
+
+You can create new queries using {{rust_type(type="struct" crate="bevy_ecs" name="World" method = "query")}} and {{rust_type(type="struct" crate="bevy_ecs" name="World" method = "query_filtered")}}.
+Use the former when you only have one type parameter and the latter when you want to use the second filtering type parameter of standard queries as well.
+
+[`Commands`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Commands.html
+[`World::spawn`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.spawn
+[`World::despawn`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.despawn
+[`World::insert`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.insert
+[`World::get_resource`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.get_resource
+[`World::get_resource_mut`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.get_resource_mut
+[`World::get`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.get
+[`World::get_mut`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.get_mut
+[`World::get_entity`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.get
+[`World::get_entity_mut`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.get_mut
+[`EntityRef`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.EntityRef.html
+[`EntityMut`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.EntityMut.html
+
+## Exclusive systems
+
+Exclusive systems can operate on any data at once: no pesky carefully scoped data access needed.
+This comes at a great cost: no other work can be done at the same time.
+
+You *must* use `world: &mut World` as the only parameter in exclusive systems: all other data can be accessed using the methods on [`World`].
+Let the schedule know that they're exclusive by using [.exclusive_system()`] on the system function, then use [`App::add_system`] or any of its relatives like usual.
+
+Unlike ordinary systems, which can be executed in parallel in arbitrary orders, exclusive systems can run either:
+
+1. Immediately before the start of a stage, using `my_exclusive_system().exclusive_system().at_start()`.
+2. Immediately after the end of a stage, before commands are applied, using `my_exclusive_system().exclusive_system().before_commands()`.
+3. Immediately after the end of a stage, after commands are applied, using `my_exclusive_system().exclusive_system().at_end()`.
+
+`at_start` is the default behavior of exclusive systems and can be omitted.
+Like other systems, exclusive systems obey standard ordering constraints, but only with respect to other exclusive systems running at the same time in the same stage.
+
+Here's an example of where you might want the far-reaching power of exclusive systems:
+
+```rust
+// In this example, we're using a custom ActionStack to queue up
+// free-form actions to enable complex, flexible logic in a turn-based game
+
+/// Allows components that implement this trait to store arbitrary world-altering logic
+pub trait Action: Send + Sync {
+    fn perform(&mut self, world: &mut World);
+}
+
+/// Stores a vec of actions to be executed in first-in-last-out order
+pub struct ActionStack(Vec<Box<dyn Action>>);
+
+/// Takes the top action from the stack and runs it,
+/// repeating until the action queue is empty
+pub fn perform_next_action(world: &mut World) {
+    loop {
+        // This must be within the loop to satisfy the borrow checker
+        // as our action could modify this resource
+        let mut action_stack = world.get_resource_mut::<ActionStack>().unwrap();
+        match action_stack.0.pop() {
+            Some(mut action) => {
+                action.perform(world);
+            }
+            None => break,
+        }
+    }
+}
+```
+
+[.exclusive_system()`]: https://docs.rs/bevy/latest/bevy/ecs/prelude/trait.IntoExclusiveSystem.html#tymethod.exclusive_system
+[`App::add_system`]: https://docs.rs/bevy/latest/bevy/app/struct.App.html#method.add_system
+
+## Accessing multiple parts of the world simultaneously
+
+When working with non-trivial exclusive world logic, you're likely to run into cases where you need mutable access to more than one part of the {{rust_type(type="struct" crate="bevy_ecs" name="World")}} at once.
+This tends to make the compiler quite unhappy, but by carefully partitioning our data access we can ensure that our code doesn't violate Rust's memory safety rules.
+No [`unsafe`](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html) needed!
+
+Right now, there are two main tools to do so:
+
+1. [`World::cell`]: Like the [concept of the same name from the Rust standard library](https://doc.rust-lang.org/std/cell/), this enables interior mutability by disabling Rust's compile-time checks for aliased mutability and replacing them run-time checks.
+2. [`World::resource_scope`]: temporarily removes the requested resource from the world, returning it at the end of your function (or when the created scope is manually dropped). This allows you to freely have multiple mutable references to distinct resources active at once.
+
+[`World::cell`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.cell
+[`World::resource_scope`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html#method.resource_scope
+
+## Accessing system parameters
+
+Occasionally, you may find yourself reaching for convenient system parameters (like [`EventReader`] and [`EventWriter`]) while you have exclusive world access.
+We can call these directly, using the same syntax as we use in systems, using the [`SystemState`] type.
+
+```rust
+use bevy::prelude::*;
+use bevy::ecs::SystemState;
+use bevy::app::AppExit;
+
+let mut world = World::new();
+
+// Extract all of the relevant parameters from the world, as if it were a system
+let mut system_state: SystemState<(Query<&Transform, With<Camera>>, Commands, EventWriter<AppExit>>)> =
+            SystemState::new(&mut world);
+
+// Use .get() if you only need read-access for less restrictive ownership constraints
+let (camera_transform_query, mut commands, mut app_exit_event_writer) = system_state.get_mut(&world);
+
+// You can then work with the extracted system parameters however you wish
+app_exit_event_writer.send(AppExit);
+```
+
+[`EventReader`]: https://docs.rs/bevy/latest/bevy/app/struct.EventReader.html
+[`EventWriter`]: https://docs.rs/bevy/latest/bevy/app/struct.EventWriter.html
+[`SystemState`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.SystemState.html
+
+## Manually running systems
+
+If you'd like to use the familiar and expressive system syntax when working with [`World`], you can manually run systems to immediately execute them one at a time.
+
+```rust
+struct Name(String);
+let world = World::new();
+world.insert_resource(Name{"Bevian".to_string()})
+
+fn hello_system(name: Res<Name>){
+    println!("Hello {}!", name);
+}
+
+// Setting up the system correctly
+// This only needs to be done once per system per world
+hello_system.system().initialize(world);
+// Actually running the system
+hello_system.system().run(world);
+// Optionally, immediately apply any buffers (like Commands) created by the system to the World
+hello_system.system().apply_buffers(world);
+```
+
+This will generally be less performant than using a standard parallel system stage,
+but can offer greater simplicity and control, particularly when prototyping or for non-standard control flows.
+
+It can also be useful for re-using or organizing logic used in other areas where you need exclusive world access, by wrapping it in a safe and well-contained function that is run in a single line.
diff --git a/content/learn/book/ecs/filtering-queries/_index.md b/content/learn/book/ecs/filtering-queries/_index.md
deleted file mode 100644
index c31ac43fb6..0000000000
--- a/content/learn/book/ecs/filtering-queries/_index.md
+++ /dev/null
@@ -1,16 +0,0 @@
-+++
-title = "Filtering queries"
-weight = 5
-template = "book-section.html"
-page_template = "book-section.html"
-+++
-
-TODO: explain that queries fetch data of all the components at once
-
-TODO: demonstrate With filters
-
-TODO: demonstrate Without filters
-
-TODO: explain marker component pattern
-
-TODO: explain how to use `Or` and `Option` to create very complex queries
diff --git a/content/learn/book/ecs/generic-systems/_index.md b/content/learn/book/ecs/generic-systems/_index.md
deleted file mode 100644
index 17f7824c53..0000000000
--- a/content/learn/book/ecs/generic-systems/_index.md
+++ /dev/null
@@ -1,12 +0,0 @@
-+++
-title = "Generic systems"
-weight = 7
-template = "book-section.html"
-page_template = "book-section.html"
-+++
-
-TODO: refresh on generics in Rust
-
-TODO: motivate use (many similar systems)
-
-TODO: demonstrate
diff --git a/content/learn/book/ecs/queries/_index.md b/content/learn/book/ecs/queries/_index.md
new file mode 100644
index 0000000000..ec9f5c8ef8
--- /dev/null
+++ b/content/learn/book/ecs/queries/_index.md
@@ -0,0 +1,285 @@
++++
+title = "Fetching data with queries"
+weight = 2
+template = "book-section.html"
+page_template = "book-section.html"
+insert_anchor_links = "right"
++++
+
+Once we have data stored on our entities in the form of components, we need to be able to get the data back out in a principled way.
+**Queries** are precisely that tool; allowing us to carefully request sets of entities from the world that meet the criteria we care about and then retrieve the data we need to operate on.
+
+The [`Query`] type is your primary access into the data in your Bevy game: allowing you to carefully access exactly the data you need from the entity-component data storage.
+The [`Query`] type has two type parameters: the first describes which data should be requested, and the second optional type parameter describes how it should be filtered.
+
+We can request access to a single component (`Life`, in this case), by adding `Query<&Life>` to our system parameters.
+This will request (a reference to) the `Life` component on every entity that has that component.
+This reference is read-only: we cannot mutate the values contained within.
+
+If we want to be able to change these values, we need to use `Query<&mut Life>` instead, and remember to set our `query` function parameter to be mutable as well.
+
+```rust
+// A system that has read-access to the Life component of each entity
+fn read_life(query: Query<&Life>){}
+
+// A system that has write-access to the Life component of each entity
+fn write_life(mut query: Query<&mut Life>){}
+```
+
+In order to access multiple components at once, we need to replace our single `&Life` component with a tuple type that bundles many types into one.
+Concretely, `Query<(&Life, &Attack)>` gives us read access to the `Life` and `Attack` components to all entities that have *both* of those components.
+Be mindful of this fact when designing queries: queries operate using "AND" logic (unless you use an `Option<&C>` query parameter): adding more components will always strictly reduce the number of entities returned by your query.
+We can get mutable access to `Life` and `Attack` separately by changing our `&` (reference) to `&mut` (mutable references) on the components that we want mutable access to.
+
+[`Query`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Query.html
+
+## Iterating over queries
+
+Once we have a query, the most common thing we're likely to want to do with it is perform some logic on every entity returned.
+To do so, we can use straightforward for-loops:
+
+```rust
+#[derive(Component, Debug)]
+struct Life{
+	val: u8
+}
+
+#[derive(Component)]
+struct IncomingDamge{
+	val: u8
+}
+
+
+/// Prints the current life total of every entity with the Life component
+fn report_life(query: Query<&Life>){
+	for life in query.iter(){
+		dbg!(life);
+	}
+}
+
+#[derive(Component)]
+struct Age(u64);
+
+fn increment_age(query: Query<&mut Age>){
+	// We need to use mut age and .iter_mut() here because we need mutable access
+	for mut age in query.iter_mut(){
+		// age.0 refers to the first (only) field on our tuple type
+		// We could make this more ergonomic by implementing the Add<Age, u64> trait
+		// or the AddAssign<Age> trait on our Age component type
+		age.0 =  age.0 + 1;
+	}
+}
+
+fn take_damage(query: Query<(&mut Life, &mut IncomingDamage)>){
+	// Typically you want to unpack this iterator into several variables 
+	// that you can use in your loop
+	for (mut life, mut incoming_damage) in query.iter_mut(){
+		life.val -= incoming_damage.val;
+		incoming_damage.val = 0;
+	}
+}
+```
+
+For those more experienced with Rust, you will be unsurprised to discover that you can also use iterator constructs like `.for_each`, `.map`, and `.filter` to work with your queries.
+
+If you find yourself needing to iterate over all pairs (or triples or...) of a query (perhaps for collision detection), turn to the `iter_combinations` function demonstrated in the [corresponding example](https://github.com/bevyengine/bevy/blob/latest/examples/ecs/iter_combinations.rs) to avoid borrow-checker headaches.
+
+## Queries that return one entity
+
+When we have a query that we *know* will always return a single entity, iterating over the query tends to result in unclear code.
+To get around this, we can use [`Query::single()`] and [`Query::single_mut()`], depending on whether or not we need to mutate the returned data.
+
+Note that these functions return a [`Result`]: if you expect this could fail in real scenarios (in case the query does not contain exactly one entity), handle the result properly.
+Otherwise, just call `let (component_a, component_b) = query.single().unwrap()` to make use of the data quickly.
+
+[`Query::single()`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Query.html#method.single
+[`Query::single_mut()`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Query.html#method.single_mut
+[`Result`]: https://doc.rust-lang.org/std/result/enum.Result.html
+
+## Looking up specific entities
+
+Each entity in our ECS data storages has a unique, arbitrarily assigned identifier: its [`Entity`], made up of two [`u32`]s.
+We can fetch the [`Entity`] of each entity returned by our queries by including it as part of the first type parameter of [`Query`] as if it were a component (although no `&` is used):
+
+```rust
+// This system reports the Entity of every entity in your World
+fn all_entities(query: Query<Entity>){
+	for entity in query.iter(){
+		dbg!(entity);
+	}
+}
+
+#[derive(Component)]
+struct Marker;
+struct MyEntities{
+	entities: Vec<Entity>,
+}
+// Typically you'll combine this pattern with query filters 
+// to extract the entities of a relevant subset, 
+// and then store it somewhere where you can access it later
+fn identify_yourself(query: Query<Entity, With<Marker>>, my_entities: ResMut<MyEntities>){
+	for entity in query.iter(){
+		my_entities.push(entity);
+	}
+}
+
+```
+
+Once we have a particular entity in mind, we can grab its data using [`Query::get()`] and the related methods on [`Query`].
+This is fallible, and so it returns a [`Result`] that you must unwrap or handle.
+
+[`Entity`]: https://docs.rs/bevy/latest/bevy/ecs/entity/struct.Entity.html
+[`u32`]: https://doc.rust-lang.org/std/primitive.u32.html
+[`Query::get()`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Query.html#method.get
+
+## Optional components in queries
+
+If we want a query to include a component's data if it exists, we can use an `Option<&MyComponent>` query parameter in the first type parameter of [`Query`].
+This can be a powerful tool for branching logic (use [`match`] on the [`Option`] returned), especially when combined with marker components.
+
+[`match`]: https://doc.rust-lang.org/std/keyword.match.html
+[`Option`]: https://doc.rust-lang.org/std/option/enum.Option.html
+
+## Query filtering
+
+When components are fetched in queries, the data of *every* component in the first type argument passed will be fetched and made available to the system.
+However, this isn't always what you want!
+In many cases, you just want to filter the query based on the presence (or absence) of a component, and don't want to deal with unpacking data you're never going to use.
+This is particularly true when working with **marker components**: data-less structs designed to convey the identity or current state of an entity.
+
+Fortunately, [`Query`] has two type parameters: the first describes what data to fetch, while the second describes how the entities that would be returned by the first type parameter are then filtered down.
+The two most important query filter types are [`With<C>`] and [`Without<C>`], which filter based on whether or not an entity has a component of the type `C`.
+
+Let's demonstrate how these filters are used by filtering some fruit.
+
+```rust
+#[derive(Component)]
+enum Fruit{
+	Apple,
+	Orange,
+	Durian,
+	Kiwi
+}
+
+#[derive(Component)]
+struct Delicious;
+
+#[derive(Component)]
+struct Rotten;
+
+#[derive(Default)]
+struct FruitInventory{
+	map: HashMap<Fruit, u8>
+}
+
+// The second filtering type parameter of Query can be ommitted when no filter is used
+fn take_inventory_system(fruit_query: Query<&Fruit>, fruit_inventory: FruitInventory){
+	// Restart the count each time inventory is taken
+	fruit_inventory = FruitInventory::default();
+	for &fruit in fruit_inventory.iter(){
+		let fruit_type_count = fruit_inventory.map.get_mut(fruit);
+		fruit_type_count = match fruit_type_count {
+			None => 1,
+			Some(n) => n + 1,
+		}
+	}
+}
+
+// With restricts your query to only those entities who have all of the data present
+// *and* all of the With filters
+fn clean_inventory_system(rotten_food_query: Query<Entity, With<Rotten>>, mut commands: Commands){
+	for entity in rotten_food_query.iter(){
+		commands.despawn(entity);
+	}
+}
+
+// We can combine query filters by passing them in as tuple
+// Returning entities that meet *all* of the query filters criteria
+fn eat_fruit_system(query: Query<&Fruit, (Without<Rotten>, With<Delicious>)>){
+	// Perform complicated fruit-eating logic here!
+}
+```
+
+[`With<C>`]: https://docs.rs/bevy/latest/bevy/ecs/query/struct.With.html
+[`Without<C>`]: https://docs.rs/bevy/latest/bevy/ecs/query/struct.Without.html
+
+### `Or` Queries
+
+By default, query filters (just like query data requests) operate on a "and" basis: if you have a filter for `With<A>` and another filter for `With<B>`, only entities with both the `A` and `B` components will be fetched.
+We can change this behavior by using the [`Or`] type, nesting primitive query filters like [`With`], [`Without`] and [`Changed`] inside of it to return entities that meet any of the criteria inside.
+If we wanted to purchase fruits that were either `Delicious` or `Cheap`, we would use `Query<&mut Owner, (Or<With<Deliciou>, With<Cheap>>)>` as the type of our query, allowing us to change the owner of any delicious and cheap fruit that we found.
+
+Note that the `Or` type (and other query tuples) can be nested indefinitely, allowing you to construct very complex logic if needed.
+
+[`Or`]: https://docs.rs/bevy/latest/bevy/ecs/query/struct.Or.html
+[`With<C>`]: https://docs.rs/bevy/latest/bevy/ecs/query/struct.With.html
+[`Without<C>`]: https://docs.rs/bevy/latest/bevy/ecs/query/struct.Without.html
+[`Changed`]: https://docs.rs/bevy/latest/bevy/ecs/query/struct.Changed.html
+
+### Running multiple queries at once
+
+As the logic in your systems become more complex, you may find that you want to access data from two different queries at once.
+In most cases, simply adding a second query as another system parameter works perfectly fine:
+
+```rust
+fn defense_aura_system(aura_query: Query<&Transform, With<Aura>>, target_query: Query<(&mut Defense, &Transform), With<Creature>>){
+	// Give all allies near an aura-generator a bonus to their defense
+}
+```
+
+But as you use this pattern more, you may encounter an error that looks something like:
+
+```
+   Query<&mut Transform, With<Camera>> in system move_player accesses component(s) &mut Transform in a way that conflicts with a previous system parameter. Allowing this would break Rust's mutability rules. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `QuerySet`.
+```
+
+What went wrong? It worked just fine before!
+
+Well, it turns out that Rust, in its infinite wisdom,
+does not like it when you access the same data in multiple places at once,
+if at least one of those accesses is mutable.
+That's a result of its [ownership rules](https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html): we could mutate data in the first query while the second query is trying to read the data, resulting in undefined behavior.
+Which is bad.
+
+Of course, you already knew that, and have carefully thought about the architecture of your system, designing something like:
+
+```rust
+fn camera_follow_system(player_query: Query<&Transform, With<Player>>, camera_query: Query<&mut Transform, With<Camera>>){
+	let player_transform = player_query.single().unwrap();
+	let camera_query = camera_query.single_mut.unwrap();
+	// Insert logic here
+}
+```
+
+You know that there's never going to be an entity that has both `Player` and `Camera` on it, so there's no way that you're ever accessing the same [`Transform`] component twice.
+Unfortunately, Rust *doesn't* know that.
+We can fix this by making *sure* our queries our disjoint, no matter what bizarre entities might exist, through the judicious application of `Without` queries.
+
+```rust
+fn camera_follow_system(player_query: Query<&Transform, With<Player>>, camera_query: Query<&mut Transform, (With<Camera>, Without<Player>)>){
+	let player_transform = player_query.single().unwrap();
+	let camera_query = camera_query.single_mut.unwrap();
+	// Insert logic here
+}
+```
+
+The other way to get around this issue is to use a [`QuerySet`], which permits multiple conflicting queries to exist in a single system.
+The catch is that you can only access one query at a time.
+Query sets can be useful when you need to access genuinely conflicting data, such as if we truly had an entity with both `Player` and `Camera` that we wanted to operate on in both loops of our system.
+Let's rewrite our broken system again, using a [`QuerySet`] instead.
+
+```rust
+fn camera_follow_system(queries: QuerySet<Query<&Transform, With<Player>>, Query<&mut Transform, With<Camera>>){
+	let player_transform = queries.0.single().unwrap();
+	let camera_query = queries.1.single_mut.unwrap();
+	// Insert logic here
+}
+```
+
+Bevy's systems automatically run in parallel by default, so long as the scheduler can guarantee that the same data is never accessed in another place while it is being mutated.
+
+As a result, we can use the same query filtering techniques described  to allow our *systems* to safely run in parallel.
+In addition to improving parallelism, this also reduces the false positives when checking for [system execution order ambiguities](https://docs.rs/bevy/latest/bevy/ecs/schedule/struct.ReportExecutionOrderAmbiguities.html), as we can guarantee that the relative order of two systems that do not share data never changes the final outcome.
+
+[`Transform`]: https://docs.rs/bevy/latest/bevy/transform/components/struct.Transform.html
+[`QuerySet`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.QuerySet.html
diff --git a/content/learn/book/ecs/reliable-change-detection/_index.md b/content/learn/book/ecs/reliable-change-detection/_index.md
deleted file mode 100644
index 5a55e2d6c2..0000000000
--- a/content/learn/book/ecs/reliable-change-detection/_index.md
+++ /dev/null
@@ -1,16 +0,0 @@
-+++
-title = "Reliable change detection"
-weight = 6
-template = "book-section.html"
-page_template = "book-section.html"
-+++
-
-TODO: discuss the need to only respond on changed data
-
-TODO: demonstrate Changed filters
-
-TODO: discuss the need to only respond to added data
-
-TODO: demonstrate Added filters
-
-TODO: link to Leafwings blog post (possibly cross-post to Bevy blog) for technical details
diff --git a/content/learn/book/ecs/resources/_index.md b/content/learn/book/ecs/resources/_index.md
index fe2d291f18..a64f781c5c 100644
--- a/content/learn/book/ecs/resources/_index.md
+++ b/content/learn/book/ecs/resources/_index.md
@@ -3,14 +3,297 @@ title = "Resources are global singletons"
 weight = 3
 template = "book-section.html"
 page_template = "book-section.html"
+insert_anchor_links = "right"
 +++
 
-TODO: Explain what a resource is
+Not all data is stored in the entity-component data storage.
+**Resources** are the blanket term for data that lives outside of entities and their components, but is still accessible by Bevy apps.
+Each resource has a unique type (you can only have one resource of each type), and can be accessed in systems by adding either [`Res`] (for immutable read-only access) or [`ResMut`] (for mutable read-write access) as a system parameter.
 
-TODO: Explain why you might want a resource
+In effect, resources serve as well-behaved **global singletons**.
+They are accessible by any system in the app, and because you can only have one resource of each type, are unique.
+You might want to use resources for:
 
-TODO: Show how to create and access Resources
+- storing events
+- holding configuration data
+- storing simple global game state that you only need a single copy of (like a game's store)
+- interoperating with other libraries
+- providing faster or supplementary look-up data structures for entities (such as indexes or graphs)
+- storing reference-counted handles to assets (so then they're not unloaded when the last entity using it is despawned)
 
-TODO: Show how to modify resources
+[`Res`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Res.html
+[`ResMut`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.ResMut.html
 
-TODO: Compare and contrast with `query.single()`
+## Creating resources
+
+Unlike components, resources do not need their own trait implementation: you can use any new or existing [`'static`] Rust type as a resource (if it is not [`Send + Sync`], you'll need a [`NonSend`] resource instead).
+
+Like entities and their component data, resources are stored in your [`App`]'s [`World`] struct.
+Resources are typically added statically, via [`insert_resouce`] or [`init_resource`].
+
+[`insert_resource`] is used when you want to set the value of a resource manually, while [`init_resource`] is used when you want to automatically initialize the resources value using the [`Default`] or [`FromWorld`] trait.
+
+```rust
+use bevy::prelude::*;
+
+// Resources can be tuple structs
+// Default can be derived for many simple resources,
+// with the default value of most numeric types being 0
+#[derive(Default)]
+struct Score(u64);
+
+// Resources can be ordinary namedstructs
+struct PlayerSupplies {
+	gold: u64,
+	wood: u64,
+}
+
+// The Default trait can be manually implemented to control initial values
+impl Default for PlayerSupplies {
+	fn default() -> Self {
+		PlayerSupplies {
+			gold: 400,
+			wood: 200,
+		}
+	}
+}
+
+// Resources can be enums
+enum Turn {
+	Allied,
+	Enemy
+}
+
+fn main(){
+	// Resources are typically inserted using AppBuilder methods
+	App::build()
+	// Uses the default() value provided by the derived Default trait
+	.init_resource::<Score>()
+	// Uses the default() value provided by the manual impl of the Default trait
+	.init_resource::<PlayerSupplies>()
+	// Uses the specific manual value of Turn::Allied to insert a resource of type Turn
+	.insert_resource(Turn::Allied)
+	// Sets the value of the standard Bevy resource `WindowDescriptor`,
+	// leaving the unspecified fields as their default value
+	.insert_resource(WindowDescriptor {
+		title: "I am a window!".to_string(),
+		width: 500.,
+		height: 300.,
+		vsync: true,
+		..Default::default()
+	})
+	.add_plugins(DefaultPlugins)
+	.run()
+}
+```
+
+In rare cases, you may need to add a resource later, once other parts of the world exist to ensure proper initialization.
+For that, we can use the equivalent methods on [`Commands`].
+You can add, overwrite and even [`remove_resource`] dynamically in this way.
+
+Only use [`Commands`] to add resources where it's needed due to the need to initialize a resource with other data from the world.
+It's less clear, and like all commands, commands that insert resources are delayed and only take effect at the end of the current stage.
+
+[`'static`]: https://doc.rust-lang.org/rust-by-example/scope/lifetime/static_lifetime.html
+[`Send + Sync`]: https://doc.rust-lang.org/nomicon/send-and-sync.html
+[`App`]: https://docs.rs/bevy/latest/bevy/app/struct.App.html
+[`World`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html
+[`insert_resouce`]: https://docs.rs/bevy/latest/bevy/app/struct.AppBuilder.html#method.insert_resource
+[`init_resource`]: https://docs.rs/bevy/latest/bevy/app/struct.AppBuilder.html#method.init_resource
+[`Default`]: https://doc.rust-lang.org/beta/std/default/trait.Default.html
+[`FromWorld`]: https://docs.rs/bevy/latest/bevy/ecs/world/trait.FromWorld.html
+[`NonSend`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.NonSend.html
+[`Commands`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Commands.html
+[`remove_resource`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Commands.html#method.remove_resource
+
+## Reading and writing from resources
+
+Once our resources have been added to the app, we can read and write to them by adding systems that refer to them using the [`Res`] and [`ResMut`] system parameters.
+Let's take a look at how this works in a cohesive context by building a tiny guessing game.
+
+```rust
+use bevy::prelude::*;
+
+fn main() {
+    App::build()
+        .add_plugins(MinimalPlugins)
+        .init_resource::<Secret>()
+        .insert_resource(InputMode::Recording)
+        .add_system(record_secret.system())
+        .add_system(check_secret.system())
+        .run();
+}
+
+/// Resource to store our secret key
+#[derive(Default)]
+struct Secret {
+	// The default value of Option<T> fields is always None
+    val: Option<KeyCode>,
+}
+
+/// Resource to control the interaction mode of our game
+#[derive(PartialEq, Eq)]
+enum InputMode {
+    /// Stores inputs in the Secret resource
+    Recording,
+    /// Compares inputs to the Secret resource
+    Guessing,
+}
+
+/// Stores the keyboard input in our Secret resource
+fn record_secret(
+    mut input_mode: ResMut<InputMode>,
+    mut secret: ResMut<Secret>,
+    mut input: ResMut<Input<KeyCode>>,
+) {
+    // This system should only do work in the Recording input mode
+	// Note that we need to derefence out of the ResMut smart pointer
+	// using * to access the underlying InputMode data
+    if *input_mode == InputMode::Recording {
+        // Only display the text prompt once, when the input_mode changes
+        if input_mode.is_changed() {
+            println!("Press a key to store a secret to be guessed by a friend!")
+        }
+
+        // Input is stored in resources too!
+        // Here, we only want one key to store as our secret,
+        // so we arbitarily grab the first key in case multiple keys are pressed at once
+        let maybe_keycode = input.get_just_pressed().next();
+
+        // maybe_keycode may be None, if no key was pressed
+        // We only care about handling the case where a key was pressed,
+        // so we use `if let` to destructure our option
+        if let Some(keycode) = maybe_keycode {
+            // Storing our input in the Secret resource
+            secret.val = Some(*keycode);
+
+            // Now that we've stored a Secret, we should swap to guessing it
+            // Again, we need to derefence our resource to refer to the data rather than the wrapper
+            *input_mode = InputMode::Guessing;
+
+            // Clear the input so that check_secret doesn't spy on this data the same frame that it's stored!
+			// Note that we could avoid doing this by ensuring that check_secret always runs before record_secret
+			// See the page on system ordering for information on how to do this
+            *input = Input::<KeyCode>::default();
+        }
+    }
+}
+
+/// Checks if the new input matches the stored secret
+fn check_secret(
+    // We need to use mut + ResMut for input_mode and secret since their value is changed
+    mut input_mode: ResMut<InputMode>,
+    mut secret: ResMut<Secret>,
+    // input only needs a Res, since we're only reading the KeyCodes that were pressed
+    input: Res<Input<KeyCode>>,
+) {
+    if *input_mode == InputMode::Guessing {
+        if input_mode.is_changed() {
+            println!("Press a key to check if it matches the secret! Only one key will be checked per frame.")
+        }
+
+        let maybe_keycode = input.get_just_pressed().next();
+        if let Some(keycode) = maybe_keycode {
+            if Some(*keycode) == secret.val {
+                println!("You've guessed the secret!");
+                // Get a new secret if it was guessed successfully
+                secret.val = None;
+                *input_mode = InputMode::Recording;
+            } else {
+                println!("Nope! Try again.")
+            }
+        }
+    }
+}
+```
+
+## Singleton entity or Resource?
+
+As discussed in [**Systems access data through queries**](../systems-queries/_index.md), [`Query::single`](https://docs.rs/bevy/latest/bevy/ecs/system/struct.Query.html#method.single) is a convenient way to get access to the data of an entity when you know that exactly one entity will be returned by a query.
+So when should you use a singleton entity, and when should you use a resource?
+
+Let's list the advantage of each, beginning with resources:
+
+- fast and simple access model: no need for queries or unwrapping
+- will not be accidentally broken by later code that modifies your entity's components or creates more matching entities
+- can store data that is not thread-safe using [`NonSend`] resources
+- clearly communicates intent
+
+By contrast, singleton entities are useful because they:
+
+- can easily share behavior and data types with other entities through systems that operate on their components
+- can be extended and contracted at run time by adding or removing components
+- have more granular change detection: operating on a per component basis rather than the entire object
+- allows you to fetch only the data you immediately need, rather than the entire resource struct
+
+Overall, resources are a good default for one-off demands: they're clear and very ergonomic to access.
+You should turn to singleton entities when you want to share behavior with other entities (i.e. a singleton entity for the player is almost always going to be superior to a monolithic `Player` resource), or for when you want to be able to extend or modify behavior dynamically during gameplay.
+
+## Complex resource initialization using `FromWorld`
+
+Sometimes you may need to initialize resources in more complex ways, depending on data from the [`World`] at large.
+For this, we can use the [`FromWorld`] trait, which allows you to create a new copy of the type that it's implemented automatically from the world.
+
+Ordinarily, the [`Default`] trait is used to handle resource initialization, due to the blanket implementation of [`FromWorld`] for `T: Default`.
+Note that you cannot manually implement [`FromWorld`] on a type that has the [`Default`] trait, as Rust forbids conflicting implementations of the same trait.
+
+[`FromWorld`] is commonly used in asset loading to automatically create handles for simple assets, and its use in this case is demonstrated in the [section on loading assets](../../assets/loading-assets/_index.md).
+For advice on how to work with the [`World`] exposed by the [`FromWorld::from_world`] method, see the section on [exclusive world access](../exclusive-world-access/_index.md).
+
+[`FromWorld::from_world`]: https://docs.rs/bevy/latest/bevy/ecs/world/trait.FromWorld.html#tymethod.from_world
+
+## Optional Resources
+
+Sometimes, a resource may not exist by the time a regularly scheduled system is called.
+We can handle both the case where it exists and the case where it doesn't by requesting `Option<Res<T>>` (or other resource types like [`ResMut`], [`NonSend`] and [`NonSendMut`]) as a system parameter,
+and then branching on the resulting `Option<T>` returned.
+
+Here's a quick runnable example:
+
+```rust
+use bevy::prelude::*;
+
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .add_system(countdown.system())
+        .run()
+}
+
+struct Countdown {
+    time_remaining: u8,
+}
+
+// `countdown` does not need to be marked as `mut` here,
+// as destructuring (like via `match`) does not require mutation
+// Only the internal data (`validated_countdown`) needs to be marked as `mut`
+fn countdown(
+    countdown: Option<ResMut<Countdown>>,
+    mut commands: Commands,
+    mut app_exit: EventWriter<AppExit>,
+) {
+    match countdown {
+        // Resources can be inserted at runtime using commands
+        None => commands.insert_resource(Countdown { time_remaining: 10 }),
+        Some(mut validated_countdown) => {
+            info!("{} ticks remaining!", validated_countdown.time_remaining);
+            if validated_countdown.time_remaining > 1 {
+                validated_countdown.time_remaining -= 1;
+            } else {
+                info!("Ka-BOOM!");
+                app_exit.send(AppExit);
+            }
+        }
+    }
+}
+```
+
+[`NonSendMut]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.NonSendMut.html
+
+## `NonSend` resources
+
+Non-send resources are used to store data that do not meet the [`Send + Sync`] trait bounds: they cannot be sent safely across threads.
+Their use cases are typically quite advanced and tend to involve interfacing with external libraries for things like audio or networking.
+`NonSend<R>` and `NonSendMut<R>` can be directly substituted for `Res<R>` and `ResMut<R>` in any system.
+The inclusion of one or more non-send resources in your system will force that system to run on the main thread,
+rather than being automatically scheduled to the first available thread.
diff --git a/content/learn/book/ecs/rust-tips/_index.md b/content/learn/book/ecs/rust-tips/_index.md
new file mode 100644
index 0000000000..573565bb4a
--- /dev/null
+++ b/content/learn/book/ecs/rust-tips/_index.md
@@ -0,0 +1,102 @@
++++
+title = "Rust tips and tricks"
+weight = 7
+template = "book-section.html"
+page_template = "book-section.html"
+insert_anchor_links = "right"
++++
+
+There are a few standard Rust patterns and pitfalls that are particularly relevant to Bevy's ECS.
+Feel free to refer back to this section later as you learn more about Bevy!
+
+### Tuple structs
+
+[Tuple structs](https://doc.rust-lang.org/1.9.0/book/structs.html), defined like `struct Score(u64);` or `struct Position(u8, u8);`, are structs with unnamed fields, accessed by the order in which they were defined.
+`.0`, `.1` and so on are used to access fields, counting up from 0 in the order they were declared.
+
+`my_position.0 = 42` can seem opaque when you first read it, but in Rust, it just means that you're assigning `42` to the first field of the tuple struct `my_position` (by convention, the x coordinate).
+Using ordinary structs with named fields rather than tuple structs (even for simple components and resources!) can go a long way to improving the clarity of your code by providing more descriptive field names.
+In this example, `my_position.x = 42` immediately communicates intent, rather than relying on future developers to remember the convention used.
+
+### Smart pointers
+
+There are a few points to be aware of when working with "smart pointers" like components and resources:
+
+1. The value passed to a system when you ask for `Res<Score>` is not a plain `Score`, it is a `Res<Score>`. This is a resource that stores the score, similar to an ordinary `&` pointer, but with some special behavior (like change detection).
+2. Because {{rust_type(type="struct" crate="bevy" mod = "ecs/system" name="Res" no_mod = "true")}} and other smart pointers implement the {{rust_type(type="trait" crate="std" mod = "ops" name="Deref" no_mod = "true")}} trait, Rust will attempt to automatically dereference it to match required types when it can.
+   1. This is commonly done when accessing fields and methods: calling `.title` on `Res<WindowDescriptor>` will grab the title field of {{rust_type(type="struct" crate="bevy" mod = "window" name="WindowDescriptor" no_mod = "true")}}, not the wrapping `Res<WindowDescriptor>` as the {{rust_type(type="struct" crate="bevy" mod = "ecs/system" name="Res" no_mod = "true")}} type has no field named `title`.
+3. When your types cannot be automatically dereferenced, you will need to manually dereference out of the outer smart pointer (e.g. `Res`) using `*`.
+   1. This is commonly needed when assigning a value to your data (rather than just one of its fields), or using {{rust_type(type="keyword" crate="std" name="match" no_mod = "true")}}.
+
+### Initializing structs with some default values
+
+Bevy often requires defining complex structs when creating entities with bundles or configuring the app with resources.
+In many cases, we want to use *some* default fields, but not all of them.
+As Rust does not have default arguments, we instead use [struct update syntax](https://doc.rust-lang.org/book/ch05-01-defining-structs.html#creating-instances-from-other-instances-with-struct-update-syntax) in combination with the {{rust_type(type="trait" crate="std" mod = "default" name="Default" method = "default" no_mod = "true")}} method to allow us to quickly set some values while leaving others unchanged.
+
+```rust
+struct CombatStats {
+    attack: u8,
+    defense: u8,
+    speed: u8,
+}
+
+impl Default for CombatStats {
+    // This method is being used to create an initial struct
+    // whose values we copy and then override
+    fn default() -> Self {
+        CombatStats {
+            attack: 100,
+            defense: 100,
+            speed: 100,
+        }
+    }
+}
+
+let my_stats = CombatStats {
+    attack: 150,
+    defense: 50,
+    ..Default::default()
+}
+```
+
+This pattern is commonly used when working with bundles: groups of components typically used for entity initialization.
+
+### Type aliases don't play nice
+
+Bevy's ECS uses Rust's type system to dispatch data to our systems as required.
+This is very convenient for safety and ergonomic reasons but means that no two resources can have the same Rust type, and entities can, at most, only have one instance of each type of component.
+
+This has somewhat surprising consequences for new Rust users though: [type aliases](https://doc.rust-lang.org/reference/items/type-aliases.html) do not create new types, and as a result should generally not be used to define resource or component types.
+
+```rust
+use std::any::type_name;
+
+// Our first component type
+#[derive(Component)]
+struct Life(u32);
+
+// An attempt at a second component type, using a type alias
+type Health = Life;
+
+// Unfortunately, these two types share the same id :(
+// Attempting to insert both Life and Health would result in overwritten values,
+// and any query for one would return either
+assert_eq!(type_id(Life(42)), type_id(Health(42));
+```
+
+Instead, you have to define entirely new types for each component or resource you wish to use,
+commonly using the [`newtype` pattern](https://doc.rust-lang.org/book/ch19-03-advanced-traits.html#using-the-newtype-pattern-to-implement-external-traits-on-external-types) to wrap a single value of some common or external type.
+
+```rust
+use std::any::type_name;
+
+#[derive(Component)]
+struct Life(u32);
+
+#[derive(Component)]
+struct Health(u32);
+
+// Our components have different types now!
+assert_ne!(type_id(Life(42)), type_id(Health(42));
+```
diff --git a/content/learn/book/ecs/systems-queries/_index.md b/content/learn/book/ecs/systems-queries/_index.md
deleted file mode 100644
index cc714702f7..0000000000
--- a/content/learn/book/ecs/systems-queries/_index.md
+++ /dev/null
@@ -1,16 +0,0 @@
-+++
-title = "Systems access data through queries"
-weight = 2
-template = "book-section.html"
-page_template = "book-section.html"
-+++
-
-TODO: Explain what a system is
-
-TODO: Explain what a query is
-
-TODO: show how to create your first system
-
-TODO: show how to access entity data through simple queries
-
-TODO: discuss queries for `Entity` and `query.get`
diff --git a/content/learn/book/ecs/systems/_index.md b/content/learn/book/ecs/systems/_index.md
new file mode 100644
index 0000000000..7bb30f9a35
--- /dev/null
+++ b/content/learn/book/ecs/systems/_index.md
@@ -0,0 +1,53 @@
++++
+title = "Systems do work"
+weight = 4
+template = "book-section.html"
+page_template = "book-section.html"
+insert_anchor_links = "right"
++++
+
+In order to make useful, fun or interesting games or apps, you'll need to manipulate the data that you store in components and resources in some way.
+In Bevy, virtually all of your logic will be stored in **systems**, functions that automatically receive data from the [`World`] from the scheduler according to their **system parameters**, and can mutate that data to change the world.
+Any type which implements the [`SystemParam`] trait can be used as a function parameter in your system: this trait tells the scheduler how to pass out access to the [`World`] in a safe and efficient way.
+
+Most commonly, you'll be using:
+
+- [`Query`], to access entity-component database
+- [`Res`] and [`ResMut`], to access the global singleton data stored in resources
+- [`Commands`](https://docs.rs/bevy/latest/bevy/ecs/system/struct.Commands.html), to queue up complex changes to the world like spawning entities
+- [`EventWriter`](https://docs.rs/bevy/latest/bevy/app/struct.EventWriter.html) and [`EventReader`](https://docs.rs/bevy/latest/bevy/app/struct.EventReader.html), to work with events in an ergonomic fashion
+
+You can see the full list by checking [which types implement `SystemParam`](https://docs.rs/bevy/latest/bevy/ecs/system/trait.SystemParam.html#implementors).
+If you would like, you can even add your own custom system parameters by deriving the [`SystemParam`] trait on structs whose fields all `impl SystemParam`.
+
+Systems are added to your app using [`App::add_system`](https://docs.rs/bevy/latest/bevy/app/struct.App.html#method.add_system) and related methods on [`App`], which will cause them to run once on every pass through the game loop.
+
+[`World`]: https://docs.rs/bevy/latest/bevy/ecs/world/struct.World.html
+[`SystemParam`]: https://docs.rs/bevy/latest/bevy/ecs/system/trait.SystemParam.html
+[`Query`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Query.html
+[`Res`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.Res.html
+[`ResMut`]: https://docs.rs/bevy/latest/bevy/ecs/system/struct.ResMut.html
+[`App`]: https://docs.rs/bevy/latest/bevy/app/struct.App.html
+[`App::add_system`]: https://docs.rs/bevy/latest/bevy/app/struct.App.html#method.add_system
+
+## Startup systems
+
+In many cases, you don't *want* your systems to run constantly: instead, you may only want to have them run a single time at the beginning to perform some setup.
+To do this, use a **startup system**.
+
+Startup systems run exactly once, before any ordinary systems, and can add them using [`App::add_startup_system`].
+
+Carefully controlling if and when systems run is one of the most important tools you have for managing the behavior of the game.
+Check out the pages on [system ordering](../../game-logic/system-ordering/_index.md), [run criteria](../../game-logic/run-criteria/_index.md) and [states](../../game-logic/states/_index.md) in the next chapter for more details.
+
+[`App::add_startup_system`](https://docs.rs/bevy/latest/bevy/app/struct.App.html#method.add_startup_system)
+
+## Generic systems
+
+You are not limited to just *one* of a single system: you can insert more copies in different places through your schedule when you want to perform the work repeatedly.
+This fact becomes particularly useful when we combine it with [generic types](https://doc.rust-lang.org/book/ch10-01-syntax.html): creating **generic systems** whose behavior is specialized on individual types.
+
+Generic systems are useful for repeating the same logic across many related types, and are incredibly value for library authors who wish to provide configurable APIs that mesh nicely with their users code.
+In the latter case, note that entire *plugins* can be made generic in the same way.
+
+All of the standard tricks for Rust's generics work when used in systems, allowing you to create systems with [trait bounds](https://doc.rust-lang.org/book/ch10-02-traits.html#trait-bound-syntax), multiple generic type parameters and even [const generics](https://blog.rust-lang.org/2021/02/26/const-generics-mvp-beta.html) as type arguments.
diff --git a/content/learn/book/migration-guides/0.4-0.5/_index.md b/content/learn/book/migration-guides/0.4-0.5/_index.md
deleted file mode 100644
index 906c613b40..0000000000
--- a/content/learn/book/migration-guides/0.4-0.5/_index.md
+++ /dev/null
@@ -1,309 +0,0 @@
-+++
-title = "0.4 to 0.5"
-weight = 1
-sort_by = "weight"
-template = "book-section.html"
-page_template = "book-section.html"
-[extra]
-long_title = "Migration Guide: 0.4 to 0.5"
-+++
-
-<!-- TODO: link to release blog post here -->
-
-### "commands: &mut Commands" SystemParam is now "mut commands: Commands"
-
-```rust
-// 0.4
-fn foo(commands: &mut Commands) {
-}
-
-// 0.5
-fn foo(mut commands: Commands) {
-}
-```
-
-Systems using the old `commands: &mut Commands` syntax in 0.5 will fail to compile when calling `foo.system()`.
-
-This change was made because {{rust_type(type="struct" crate="bevy_ecs" mod="system" version="0.5.0" name="Commands" no_mod=true)}}
-now holds an internal {{rust_type(type="struct" crate="bevy_ecs" mod="world" version="0.5.0" name="World" no_mod=true)}}
-reference to enable safe entity allocations.
-
-Note: The internal {{rust_type(type="struct" crate="bevy_ecs" mod="world" version="0.5.0" name="World" no_mod=true)}} reference requires two lifetime parameters to pass Commands into a non-system function: `commands: &'a mut Commands<'b>`
-
-### Commands API
-
-The {{rust_type(type="struct" crate="bevy_ecs" version="0.5.0" mod="system" name="Commands" no_mod=true)}} API has been completely reworked for consistency with the {{rust_type(type="struct" crate="bevy_ecs" mod="world" version="0.5.0" name="World" no_mod=true)}} API.
-
-```rust
-// 0.4
-commands
-    .spawn(SomeBundle)
-    .with(SomeComponent)
-    .spawn(SomeBundle); // this sort of chaining is no longer possible
-
-let entity = commands.spawn(SomeBundle).current_entity().unwrap();
-
-commands.despawn(entity);
-
-// 0.5
-commands
-    .spawn()
-    .insert_bundle(SomeBundle)
-    .insert(Component);
-
-let entity = commands.spawn().insert_bundle(SomeBundle).id();
-
-commands.entity(entity).despawn();
-```
-
-`commands.spawn()` no longer accepts any parameters.  To spawn bundles, use `commands.spawn_bundle(bundle)`.
-
-Similarly, rather than using `with(some_component)` to spawn an object with multiple components, you must now use `insert(some_component)`:
-```rust
-// 0.4
-commands.spawn(some_bundle)
-    .with(some_component);
-    
-// 0.5
-commands.spawn_bundle(some_bundle)
-    .insert(some_component);
-    
-// or...
-commands.spawn()
-    .insert_bundle(some_bundle)
-    .insert(some_component);
-```
-
-Removing and adding components on entities has also been changed:
-```rust
-// 0.4
-commands.insert_one(some_entity, SomeComponent);
-commands.remove_one::<SomeComponent>(some_entity);
-
-// 0.5
-commands.entity(some_entity).insert(SomeComponent);
-commands.entity(some_entity).remove::<SomeComponent>();
-```
-
-### Timer now uses Duration
-
-```rust
-// 0.4
-if timer.tick(time.delta_seconds()).finished() { /* do stuff */ }
-timer.elapsed() // returns an `f32`
-
-// 0.5
-if timer.tick(time.delta()).finished() { /* do stuff */ }
-timer.elapsed() // returns a `Duration`
-```
-
-Most of the methods of {{rust_type(type="struct" crate="bevy_core" version="0.5.0" name="Timer" no_mod=true)}}
-now use `Duration` instead of `f32`.
-
-This change allows timers to have consistent, high precision. For convenience, there is also an
-`elapsed_secs` method that returns `f32`.  Otherwise, when you need an `f32`, use the
-`as_secs_f32()` method on `Duration` to make the conversion.
-
-### Simplified Events
-
-```rust
-// 0.4
-fn event_reader_system(
-    mut my_event_reader: Local<EventReader<MyEvent>>,
-    my_events: Res<Events<MyEvent>>,
-) {
-    for my_event in my_event_reader.iter(&my_events) {
-        // do things with your event
-    }
-}
-
-// 0.5
-fn event_reader_system(mut my_event_reader: EventReader<MyEvent>) {
-    for my_event in my_event_reader.iter() {
-        // do things with your event
-    }
-}
-```
-You no longer need two system parameters to read your events. One `EventReader` is sufficient.
-
-Following the above example of using an `EventReader` to read events, you can now use `EventWriter` to create new ones.
-```rust
-// 0.4
-fn event_writer_system(
-    mut my_events: ResMut<Events<MyEvent>>,
-) {
-    my_events.send(MyEvent);
-}
-
-// 0.5
-fn event_writer_system(
-    mut my_events: EventWriter<MyEvent>
-) {
-    my_events.send(MyEvent);
-}
-```
-
-### AppBuilder::add_resource is now called AppBuilder::insert_resource
-
-This is a small change to have function names on `AppBuilder` consistent with the `Commands` API.
-
-### TextBundle
-
-This bundle has been reworked to allow multiple differently-styled sections of text within a single bundle. `Text::with_section` was added to simplify the common case where you're only interested in one text section.
-
-```rust
-// 0.4
-TextBundle {
-    text: Text {
-        value: "hello!".to_string(),
-        font: asset_server.load("fonts/FiraSans-Bold.ttf"),
-        style: TextStyle {
-            font_size: 60.0,
-            color: Color::WHITE,
-            ..Default::default()
-        },
-    },
-    ..Default::default()
-}
-
-// 0.5
-TextBundle {
-    text: Text::with_section(
-        "hello!",
-        TextStyle {
-            font: asset_server.load("fonts/FiraSans-Bold.ttf"),
-            font_size: 60.0,
-            color: Color::WHITE,
-        },
-        TextAlignment::default()
-    ),
-    ..Default::default()
-}
-```
-
-### Scene must now be specified when loading a GLTF scene
-Previously, you were able to load a GLTF scene asset with only a path. Now, you must include a fragment specifying the scene you want to load. If you only have one scene in the file, it's `#Scene0`.
-```rust
-// 0.4
-asset_server.load("models/foo.glb");
-
-// 0.5
-asset_server.load("models/foo.glb#Scene0");
-```
-
-### State
-
-States are now registered with `AppBuilder::add_state`, which creates
-the `State` resource and registers a "driver" system that takes the
-place of `StateStage`.  States are registered using `SystemSet`.
-
-**IMPORTANT**: if you stop registering the `StateStage` but don't
-register the driver (using `add_state` or `State::get_driver`), Bevy
-0.5 will enter an infinite loop, causing your application to "lock up".
-
-```rust
-// 0.4
-app.insert_resource(State::new(MyState::InitState))
-   .add_stage_after(
-       bevy::app::stage::UPDATE,
-       MY_STATE_STAGE_NAME,
-       bevy::ecs::StateStage::<MyState>::default(),
-   )
-   .on_state_enter(
-       MY_STATE_STAGE_NAME,
-       MyState::InitState,
-       enter_init_state.system())
-   .on_state_update(
-       MY_STATE_STAGE_NAME,
-       MyState::InitState,
-       update_init_state.system())
-   .on_state_exit(
-       MY_STATE_STAGE_NAME,
-       MyState::InitState,
-       exit_init_state.system());
-
-// 0.5
-app.add_state(MyState::InitState)
-   .add_system_set(SystemSet::on_enter(MyState::InitState)
-       .with_system(enter_init_state.system()))
-   .add_system_set(SystemSet::on_update(MyState::InitState)
-       .with_system(update_init_state.system()))
-   .add_system_set(SystemSet::on_exit(MyState::InitState)
-       .with_system(exit_init_state.system()));
-```
-
-It is still possible to register the driver manually using
-`State::get_driver`, but this is not normally required.
-
-## ChangedRes removed
-
-This change was made to allow for more flexiblity and more consistent behavior with change detection for components.
-
-```rust
-// 0.4
-fn some_system(
-    res: ChangedRes<SomeResource>
-) {
-    // this system only runs if SomeResource has changed
-}
-
-// 0.5
-fn some_system(
-    res: Res<SomeResource> // or ResMut
-) {
-    // this system always runs
-
-    if !res.is_changed() { // or .is_added()
-        return;
-    }
-}
-```
-
-### Cameras
-`Camera3dBundle` is now known as `PerspectiveCameraBundle`, and `Camera2dBundle` is now known as `OrthographicCameraBundle`.
-
-`OrthographicCameraBundle` does not implement `Default`, so to change its transform at spawn while keeping everything else the same, consider something like the following:
-```rust
-let mut camera = OrthographicCameraBundle::new_2d();
-camera.transform = Transform::from_translation(Vec3::new(0.0, 0.0, 5.0));
-commands.spawn_bundle(camera);
-```
-
-### Render API changes
-`RasterizationStateDescriptor` no longer exists.  Much of its functionality has been moved to other fields on `PipelineDescriptor`.  `cull_mode`, for example, is now found in the `primitive: PrimitiveState` field.
-
-Buffers of type `Vec<Color>` can no longer be uploaded to the GPU directly due to limitations with `RenderResources` and the new `Byteable` requirement.  Consider using a `Vec<Vec4>` instead, and inserting colors with `as_rgba_f32()` and `.into()` instead:
-```rust
-#[derive(RenderResources, Default, TypeUuid)]
-struct SomeShader {
-    #[render_resources(buffer)]
-    pub colors: Vec<Vec4>
-}
-
-fn add_some_color(shader: SomeShader, color: Color) {
-    shader.colors.push(color.as_rgba_f32().into());
-}
-```
-
-### Shaders should now use `CameraViewProj`
-The `ViewProj` matrix is now set via the name `CameraViewProj` rather than `Camera`.  If you don't update this, bevy will fail silently and you won't be able to see anything!
-
-```glsl
-// 0.4
-layout(set = 0, binding = 0) uniform Camera {
-    mat4 ViewProj;
-}
-
-// 0.5
-layout(set = 0, binding = 0) uniform CameraViewProj {
-    mat4 ViewProj;
-}
-```
-
-### Diagnostics
-`PrintDiagnosticsPlugin` is now `LogDiagnosticsPlugin`.
-
-
-### System Ordering
-
-The parallel system executor has been redesigned. Systems that had implicit orderings might no longer run in the same order. For more detail on the new behavior, see [the release notes](/news/bevy-0-5#new-parallel-system-executor).
diff --git a/content/learn/book/next-steps/_index.md b/content/learn/book/next-steps/_index.md
index f2e2c893cb..05a0338425 100644
--- a/content/learn/book/next-steps/_index.md
+++ b/content/learn/book/next-steps/_index.md
@@ -10,7 +10,9 @@ You have reached the end of The Bevy Book! If you're hungry for more learning ma
 
 * **[The Bevy Examples](https://github.com/bevyengine/bevy/tree/latest/examples#examples)**: Runnable examples for every major Bevy feature.
 * **[Bevy API Docs](https://docs.rs/bevy)**: Bevy's Rust API documentation.
-* **[Bevy Assets](https://bevyengine.org/assets/)**: List of projects by the Bevy community, including:
-  * **[Learning Resources](https://bevyengine.org/assets/#learning)**: Tutorials, documentation, and examples.
-  * **[Plugins](https://bevyengine.org/assets/#assets)**: Extra functionality you can use in your projects.
-  * **[Games](https://bevyengine.org/assets/#apps)**: Open-source games in various stages of development.
+* **[Awesome Bevy](https://github.com/bevyengine/awesome-bevy)**: List of projects by the Bevy community, including:
+  * **[Learning Resources](https://github.com/bevyengine/awesome-bevy#learning)**: Tutorials, documentation, and examples.
+  * **[Plugins](https://github.com/bevyengine/awesome-bevy#plugins-and-crates)**: Extra functionality you can use in your projects.
+  * **[Games](https://github.com/bevyengine/awesome-bevy#games)**: Open-source games in various stages of development.
+
+TODO: add link to Quick-start Games
diff --git a/content/news/2020-08-10-introducing-bevy/index.md b/content/news/2020-08-10-introducing-bevy/index.md
index fc0dfb2aaf..ef3a0c3fe6 100644
--- a/content/news/2020-08-10-introducing-bevy/index.md
+++ b/content/news/2020-08-10-introducing-bevy/index.md
@@ -40,7 +40,7 @@ It also has many features most people expect from a modern, general purpose engi
 * <b class="fun-list">Scenes</b>: Save ECS Worlds to human-readable scene files and load scene files into ECS Worlds
 * <b class="fun-list">Plugins</b>: All engine and app features are implemented as modular plugins
 * <b class="fun-list">Sound</b>: Load audio files as assets and play them from within systems
-* <b class="fun-list">Multiple Render Backends</b>: Vulkan, DirectX 12, and Metal (with more on the way thanks to [wgpu](https://github.com/gfx-rs/wgpu))
+* <b class="fun-list">Multiple Render Backends</b>: Vulkan, DirectX 12, and Metal (with more on the way thanks to [wgpu](https://github.com/gfx-rs/wgpu-rs))
 * <b class="fun-list">Data Driven Shaders</b>: Easily bind ECS components directly to shader uniforms
 * <b class="fun-list">Hot Asset Reloading</b>: Automatically reload changes to assets at runtime without recompiles or restarts
 * <b class="fun-list">Events</b>: Efficiently consume and produce Events from within ECS systems
diff --git a/generate-assets/.gitignore b/generate-assets/.gitignore
deleted file mode 100644
index ebbe8e0e18..0000000000
--- a/generate-assets/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-target
-assets
diff --git a/generate-assets/Cargo.lock b/generate-assets/Cargo.lock
deleted file mode 100644
index 47fa3defe4..0000000000
--- a/generate-assets/Cargo.lock
+++ /dev/null
@@ -1,182 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "aho-corasick"
-version = "0.7.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "generate-assets"
-version = "0.1.0"
-dependencies = [
- "rand",
- "regex",
- "serde",
- "toml",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.95"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "789da6d93f1b866ffe175afc5322a4d76c038605a1c3319bb57b06967ca98a36"
-
-[[package]]
-name = "memchr"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc"
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0d8caf72986c1a598726adc988bb5984792ef84f5ee5aa50209145ee8077038"
-dependencies = [
- "unicode-xid",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "rand"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ef9e7e66b4468674bfcb0c81af8b7fa0bb154fa9f28eb840da5c447baeb8d7e"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
- "rand_hc",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e12735cf05c9e10bf21534da50a147b924d555dc7a547c42e6bb2d5b6017ae0d"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34cf66eb183df1c5876e2dcf6b13d57340741e8dc255b48e40a26de954d06ae7"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rand_hc"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3190ef7066a446f2e7f42e239d161e905420ccab01eb967c9eb27d21b2322a73"
-dependencies = [
- "rand_core",
-]
-
-[[package]]
-name = "regex"
-version = "1.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
-
-[[package]]
-name = "serde"
-version = "1.0.126"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec7505abeacaec74ae4778d9d9328fe5a5d04253220a85c4ee022239fc996d03"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.126"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "963a7dbc9895aeac7ac90e74f34a5d5261828f79df35cbed41e10189d3804d43"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "syn"
-version = "1.0.72"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1e8cdbefb79a9a5a65e0db8b47b723ee907b7c7f8496c76a1770b5c310bab82"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
-[[package]]
-name = "toml"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
-
-[[package]]
-name = "wasi"
-version = "0.10.2+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
diff --git a/generate-assets/Cargo.toml b/generate-assets/Cargo.toml
deleted file mode 100644
index bd87c24dda..0000000000
--- a/generate-assets/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "generate-assets"
-version = "0.1.0"
-authors = [
-  "Bevy Contributors <bevyengine@gmail.com>",
-  "Carter Anderson <mcanders1@gmail.com>",
-]
-license = "MIT"
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-toml = "0.5"
-serde = { version = "1", features = [ "derive" ] }
-rand = "0.8"
-regex = "1"
diff --git a/generate-assets/generate_assets.sh b/generate-assets/generate_assets.sh
deleted file mode 100755
index 4f2df91bee..0000000000
--- a/generate-assets/generate_assets.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/sh
-
-git clone https://github.com/bevyengine/bevy-assets assets
-
-cargo run --bin generate -- assets ../content
diff --git a/generate-assets/parse_old_readme.py b/generate-assets/parse_old_readme.py
deleted file mode 100644
index eb7e718099..0000000000
--- a/generate-assets/parse_old_readme.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import re
-import os
-import sys
-
-name_fix = {
-    'bevy_nbody': 'thallada-bevy_nbody',
-    'bevy-nbody': 'WhoisDavid-bevy-nbody',
-}
-
-f = open(sys.argv[1] + "/README.md")
-lines = f.readlines()
-
-root_folder = sys.argv[2] + "/"
-os.mkdir(root_folder)
-
-category = None
-subcategory = None
-current_path = root_folder
-for line in lines:
-    if line[0:3] == "## ":
-        category = line.split("# ")[1][0:-1]
-        current_path = root_folder + category
-        os.mkdir(current_path)
-    elif line[0:3] == "###":
-        subcategory = line.split("# ")[1][0:-1]
-        current_path = root_folder + category + "/" + subcategory
-        os.mkdir(current_path)
-    elif line[0:2] == "* ":
-        line = line[0:-1]
-        m = re.search('\* \[([^]]*)\]\(([^)]*)\)(: (.*))?', line)
-        name = m.group(1)
-        link = m.group(2)
-        desc = m.group(4)
-        if name in name_fix:
-            name = name_fix[name]
-        f = open(current_path + '/' + name.replace(' ', '-').replace('/', '-') + ".toml", "w")
-        f.write("name = \"" + name + "\"\n")
-        if desc is not None:
-            f.write("description = \"" + desc.replace('"', '\'') + "\"\n")
-        f.write("link = \"" + link + "\"\n")
-        f.close()
-
diff --git a/generate-assets/src/bin/generate.rs b/generate-assets/src/bin/generate.rs
deleted file mode 100644
index 30332aab94..0000000000
--- a/generate-assets/src/bin/generate.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-use rand::{prelude::SliceRandom, thread_rng};
-use serde::Serialize;
-use std::{
-    fs::{self, File},
-    io::{self, prelude::*},
-    path::Path,
-};
-
-use generate_assets::*;
-
-fn main() -> io::Result<()> {
-    let asset_dir = std::env::args().nth(1).unwrap();
-    let content_dir = std::env::args().nth(2).unwrap();
-    let _ = fs::create_dir(content_dir.clone());
-    let asset_root_section = parse_assets(&asset_dir)?;
-
-    asset_root_section.write(Path::new(&content_dir), Path::new(""), 0)?;
-    Ok(())
-}
-
-trait FrontMatterWriter {
-    fn write(&self, root_path: &Path, current_path: &Path, weight: usize) -> io::Result<()>;
-}
-
-#[derive(Serialize)]
-struct FrontMatterAsset {
-    title: String,
-    description: String,
-    weight: usize,
-    extra: FrontMatterAssetExtra,
-}
-
-#[derive(Serialize)]
-struct FrontMatterAssetExtra {
-    link: String,
-    image: Option<String>,
-}
-
-impl From<&Asset> for FrontMatterAsset {
-    fn from(asset: &Asset) -> Self {
-        FrontMatterAsset {
-            title: asset.name.clone(),
-            description: asset.description.clone(),
-            weight: asset.order.unwrap_or(0),
-            extra: FrontMatterAssetExtra {
-                link: asset.link.clone(),
-                image: asset.image.clone(),
-            },
-        }
-    }
-}
-
-impl FrontMatterWriter for Asset {
-    fn write(&self, root_path: &Path, current_path: &Path, weight: usize) -> io::Result<()> {
-        let path = root_path.join(&current_path);
-
-        let mut frontmatter = FrontMatterAsset::from(self);
-        if self.order.is_none() {
-            frontmatter.weight = weight;
-        }
-        if let Some(file) = self.image.as_ref() {
-            let image_file_path = path.join(file);
-            let image_file_link = current_path.join(file);
-            let original_image = self
-                .original_path
-                .as_ref()
-                .unwrap()
-                .clone()
-                .with_file_name(file);
-
-            frontmatter.extra.image = image_file_link.to_str().map(|link| link.to_string());
-            let _ = fs::copy(original_image, image_file_path);
-        }
-
-        let mut file = File::create(path.join(format!(
-            "{}.md",
-            self.name.to_ascii_lowercase().replace("/", "-")
-        )))?;
-        file.write_all(
-            format!(
-                r#"+++
-{}
-+++
-"#,
-                toml::to_string(&frontmatter).unwrap(),
-            )
-            .as_bytes(),
-        )?;
-
-        Ok(())
-    }
-}
-
-impl FrontMatterWriter for AssetNode {
-    fn write(&self, root_path: &Path, current_path: &Path, weight: usize) -> io::Result<()> {
-        match self {
-            AssetNode::Section(content) => content.write(root_path, current_path, weight),
-            AssetNode::Asset(content) => content.write(root_path, current_path, weight),
-        }
-    }
-}
-
-#[derive(Serialize)]
-struct FrontMatterSection {
-    title: String,
-    sort_by: String,
-    template: Option<String>,
-    weight: usize,
-    extra: FrontMatterSectionExtra,
-}
-
-#[derive(Serialize)]
-struct FrontMatterSectionExtra {
-    header_message: Option<String>,
-    sort_order_reversed: bool,
-}
-
-impl From<&Section> for FrontMatterSectionExtra {
-    fn from(section: &Section) -> Self {
-        FrontMatterSectionExtra {
-            header_message: section.header.clone(),
-            sort_order_reversed: section.sort_order_reversed,
-        }
-    }
-}
-
-impl From<&Section> for FrontMatterSection {
-    fn from(section: &Section) -> Self {
-        FrontMatterSection {
-            title: section.name.clone(),
-            sort_by: "weight".to_string(),
-            template: section.template.clone(),
-            weight: section.order.unwrap_or(0),
-            extra: section.into(),
-        }
-    }
-}
-
-impl FrontMatterWriter for Section {
-    fn write(&self, root_path: &Path, current_path: &Path, weight: usize) -> io::Result<()> {
-        let section_path = current_path.join(self.name.to_ascii_lowercase());
-        let path = root_path.join(&section_path);
-        fs::create_dir(path.clone())?;
-
-        let mut frontmatter = FrontMatterSection::from(self);
-        if self.order.is_none() {
-            frontmatter.weight = weight;
-        }
-
-        let mut file = File::create(path.join("_index.md"))?;
-        file.write_all(
-            format!(
-                r#"+++
-{}
-+++
-"#,
-                toml::to_string(&frontmatter).unwrap(),
-            )
-            .as_bytes(),
-        )?;
-
-        let mut sorted_section = vec![];
-        for content in self.content.iter() {
-            if let AssetNode::Section(section) = content {
-                sorted_section.push(AssetNode::Section(section.clone()));
-            }
-        }
-        sorted_section.sort_by_key(|section| format!("{}-{}", section.order(), section.name()));
-
-        let mut randomized_assets = vec![];
-        let mut manually_sorted_assets = vec![];
-        for content in self.content.iter() {
-            if let AssetNode::Asset(asset) = content {
-                if asset.order.is_some() {
-                    manually_sorted_assets.push(content.clone());
-                } else {
-                    randomized_assets.push(content.clone());
-                }
-            }
-        }
-        manually_sorted_assets.sort_by_key(AssetNode::order);
-        randomized_assets.shuffle(&mut thread_rng());
-
-        for (i, content) in sorted_section
-            .iter()
-            .chain(manually_sorted_assets.iter())
-            .chain(randomized_assets.iter())
-            .enumerate()
-        {
-            content.write(root_path, &section_path, i)?
-        }
-        Ok(())
-    }
-}
diff --git a/generate-assets/src/bin/validate.rs b/generate-assets/src/bin/validate.rs
deleted file mode 100644
index a3b37955cc..0000000000
--- a/generate-assets/src/bin/validate.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use regex::Regex;
-
-use generate_assets::*;
-
-fn main() -> Result<(), ()> {
-    let asset_dir = std::env::args().nth(1).unwrap();
-    if let Ok(asset_root_section) = parse_assets(&asset_dir) {
-        if asset_root_section.validate() {
-            Ok(())
-        } else {
-            Err(())
-        }
-    } else {
-        Err(())
-    }
-}
-
-trait AssetValidator {
-    fn validate(&self) -> bool;
-}
-
-#[derive(Debug)]
-enum AssetError {
-    DescriptionTooLong,
-    DescriptionWithFormatting,
-    ImageInvalidLink,
-}
-
-impl AssetValidator for Section {
-    fn validate(&self) -> bool {
-        let mut valid = true;
-        for content in self.content.iter() {
-            if !content.validate() {
-                valid = false;
-            }
-        }
-        valid
-    }
-}
-
-impl AssetValidator for AssetNode {
-    fn validate(&self) -> bool {
-        match self {
-            AssetNode::Section(content) => content.validate(),
-            AssetNode::Asset(content) => content.validate(),
-        }
-    }
-}
-
-impl AssetValidator for Asset {
-    fn validate(&self) -> bool {
-        let mut valid = true;
-        if self.description.len() > 100 {
-            valid = false;
-            println!("{:50} - {:?}", self.name, AssetError::DescriptionTooLong);
-        }
-        if has_forbidden_formatting(&self.description) {
-            valid = false;
-            println!(
-                "{:50} - {:?}",
-                self.name,
-                AssetError::DescriptionWithFormatting
-            );
-        }
-        if let Some(image) = self.image.as_ref() {
-            if image.starts_with('.')
-                || image.starts_with('/')
-                || image.starts_with("http")
-                || !(image.ends_with(".gif")
-                    || image.ends_with(".jpeg")
-                    || image.ends_with(".jpg")
-                    || image.ends_with(".png"))
-            {
-                valid = false;
-                println!("{:50} - {:?}", self.name, AssetError::ImageInvalidLink);
-            }
-        }
-
-        return valid;
-    }
-}
-
-fn has_forbidden_formatting(string: &str) -> bool {
-    if string.contains('\n') {
-        return true;
-    }
-    if string.starts_with('#') {
-        return true;
-    }
-    let re = Regex::new(r"\[(.+)\]\(((?:/|https?://)[\w\d./?=#]+)\)").unwrap();
-    if re.is_match(string) {
-        return true;
-    }
-
-    return false;
-}
diff --git a/generate-assets/src/lib.rs b/generate-assets/src/lib.rs
deleted file mode 100644
index 27321a5122..0000000000
--- a/generate-assets/src/lib.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use serde::Deserialize;
-use std::{fs, io, path::PathBuf, str::FromStr};
-
-#[derive(Deserialize, Debug, Clone)]
-#[serde(deny_unknown_fields)]
-pub struct Asset {
-    pub name: String,
-    pub link: String,
-    pub description: String,
-    pub order: Option<usize>,
-    pub image: Option<String>,
-
-    // this field is not read from the toml file
-    #[serde(skip)]
-    pub original_path: Option<PathBuf>,
-}
-
-#[derive(Debug, Clone)]
-pub struct Section {
-    pub name: String,
-    pub content: Vec<AssetNode>,
-    pub template: Option<String>,
-    pub header: Option<String>,
-    pub order: Option<usize>,
-    pub sort_order_reversed: bool,
-}
-
-#[derive(Debug, Clone)]
-pub enum AssetNode {
-    Section(Section),
-    Asset(Asset),
-}
-impl AssetNode {
-    pub fn name(&self) -> String {
-        match self {
-            AssetNode::Section(content) => content.name.clone(),
-            AssetNode::Asset(content) => content.name.clone(),
-        }
-    }
-    pub fn order(&self) -> usize {
-        match self {
-            AssetNode::Section(content) => content.order.unwrap_or(99999),
-            AssetNode::Asset(content) => content.order.unwrap_or(99999),
-        }
-    }
-}
-
-fn visit_dirs(dir: PathBuf, section: &mut Section) -> io::Result<()> {
-    if dir.is_dir() {
-        for entry in fs::read_dir(dir)? {
-            let entry = entry?;
-            let path = entry.path();
-            if path.file_name().unwrap() == ".git" || path.file_name().unwrap() == ".github" {
-                continue;
-            }
-            if path.is_dir() {
-                let folder = path.file_name().unwrap();
-                let (order, sort_order_reversed) = if path.join("_category.toml").exists() {
-                    let from_file: toml::Value = toml::de::from_str(
-                        &fs::read_to_string(path.join("_category.toml")).unwrap(),
-                    )
-                    .unwrap();
-                    (
-                        from_file
-                            .get("order")
-                            .and_then(|v| v.as_integer())
-                            .map(|v| v as usize),
-                        from_file
-                            .get("sort_order_reversed")
-                            .and_then(|v| v.as_bool())
-                            .unwrap_or(false),
-                    )
-                } else {
-                    (None, false)
-                };
-                let mut new_section = Section {
-                    name: folder.to_str().unwrap().to_string(),
-                    content: vec![],
-                    template: None,
-                    header: None,
-                    order,
-                    sort_order_reversed,
-                };
-                visit_dirs(path.clone(), &mut new_section)?;
-                section.content.push(AssetNode::Section(new_section));
-            } else {
-                if path.file_name().unwrap() == "_category.toml"
-                    || path.extension().unwrap() != "toml"
-                {
-                    continue;
-                }
-                let mut asset: Asset =
-                    toml::de::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
-                asset.original_path = Some(path);
-                section.content.push(AssetNode::Asset(asset));
-            }
-        }
-    }
-    Ok(())
-}
-
-pub fn parse_assets(asset_dir: &str) -> io::Result<Section> {
-    let mut asset_root_section = Section {
-        name: "Assets".to_string(),
-        content: vec![],
-        template: Some("assets.html".to_string()),
-        header: Some("Assets".to_string()),
-        order: None,
-        sort_order_reversed: false,
-    };
-    visit_dirs(
-        PathBuf::from_str(&asset_dir).unwrap(),
-        &mut asset_root_section,
-    )?;
-    Ok(asset_root_section)
-}
diff --git a/sass/_assets.scss b/sass/_assets.scss
deleted file mode 100644
index 64235076b4..0000000000
--- a/sass/_assets.scss
+++ /dev/null
@@ -1,42 +0,0 @@
-.assets {
-    display: flex;
-
-    .card-list {
-        display: flex;
-        flex-wrap: wrap;
-    }
-
-    .card {
-        width: 30%;
-        margin-right: $card-list-gap;
-        height: 8rem;
-    }
-
-    .card-title {
-        font-size: 1.3rem;
-        overflow-wrap: break-word;
-    }
-
-    .card-description {
-        font-size: 1rem;
-        height: initial;
-    }
-
-    .card-image > img {
-        display: block;
-        height: auto;
-        max-width: 100%;
-    }
-
-    a {
-        text-decoration: none;
-    }
-
-    .book-content {
-        h3 {
-            font-size: 1.9rem;
-            font-weight: 700;
-            text-decoration: none;
-        }
-    }
-}
\ No newline at end of file
diff --git a/sass/_base.scss b/sass/_base.scss
index e0f5c937aa..7da6f5b8a2 100644
--- a/sass/_base.scss
+++ b/sass/_base.scss
@@ -9,7 +9,7 @@ html, body {
     font-family: 'Fira Sans', sans-serif;
     background-color: #232326;
 }
-@media screen and (max-width: 790px) {
+@media screen and (max-width: 712px) {
     html, body {
         font-size: 0.7rem;
     }
diff --git a/sass/_book-nav.scss b/sass/_book-nav.scss
index 98de04abc9..a385eb51a8 100644
--- a/sass/_book-nav.scss
+++ b/sass/_book-nav.scss
@@ -16,7 +16,7 @@ $book-nav-width: 210px;
 }
 
 .book-nav {
-    margin-top: $default-padding;
+    margin-top: $content-padding;
     flex: 0 0 $book-nav-width;
     user-select: none;
     transition: transform 0.3s;
diff --git a/sass/_book.scss b/sass/_book.scss
index c552f0fb74..7c1fcd05c1 100644
--- a/sass/_book.scss
+++ b/sass/_book.scss
@@ -12,14 +12,16 @@
     vertical-align: middle;
 }
 
+$content-padding: 15px;
+
 .book-content {
-    padding-left: $default-padding;
-    padding-right: $default-padding;
+    padding-left: $content-padding;
+    padding-right: $content-padding;
     position: relative;
     width: 100%;
     min-width: 0;
     h1 {
-        margin-top: $default-padding;
+        margin-top: $content-padding;
         font-size: 2.4rem;
         margin-bottom: 15px;
     }
@@ -93,12 +95,12 @@ $pager-bar-background-color-in: #29292c;
 
 .book-pager-image-left {
     float: left;
-    margin-left: $default-padding;
+    margin-left: $content-padding;
 }
 
 .book-pager-image-right {
     float: right;
-    margin-right: $default-padding;
+    margin-right: $content-padding;
 }
 
 $pager-bar-icon-width: 200px;
diff --git a/sass/_card.scss b/sass/_card.scss
index 2effc2cb09..34a761e714 100644
--- a/sass/_card.scss
+++ b/sass/_card.scss
@@ -1,3 +1,5 @@
+$card-list-gap: 15px;
+
 .card {
     display: block;
     flex-direction: left;
diff --git a/sass/_features.scss b/sass/_features.scss
index 28d21ee2fd..243817ed99 100644
--- a/sass/_features.scss
+++ b/sass/_features.scss
@@ -92,15 +92,4 @@
     font-size: 1.5rem !important;
     line-height: 2.2rem !important;
     margin-bottom: 8rem;
-}
-
-.bronze-sponsors {
-    display: flex;
-    width: 100%;
-    justify-content: center;
-}
-
-.bronze-sponsor-image {
-    height: 3.8rem;
-    margin: 1rem;
 }
\ No newline at end of file
diff --git a/sass/_headerbar.scss b/sass/_headerbar.scss
index 842b6781db..27da66a112 100644
--- a/sass/_headerbar.scss
+++ b/sass/_headerbar.scss
@@ -16,7 +16,7 @@
 }
 
 .logo {
-    height: 75%;
+    height: 100%;
 }
 
 .header-logo, .header-logo-mobile, .toggle-nav-mobile {
@@ -69,7 +69,7 @@ $header-active-color: #b1d9ff;
 .header-message {
     text-align: center;
     color: #797979;
-    font-size: 1.725rem;
+    font-size: 2.3rem;
 }
 
 .header-button {
@@ -95,19 +95,19 @@ $header-active-color: #b1d9ff;
 }
 
 
-@media screen and (max-width: 580px) {
+@media screen and (max-width: 515px) {
     .header-button {
         display: none;
     }
 }
 
-@media screen and (max-width: 1120px) {
+@media screen and (max-width: 1100px) {
     .header-message {
         display: none;
     }
 }
 
-@media screen and (max-width: 965px) {
+@media screen and (max-width: 900px) {
     .header-logo-mobile, .toggle-nav-mobile {
         display: flex;
     }
@@ -115,4 +115,4 @@ $header-active-color: #b1d9ff;
     .header-logo {
         display: none;
     }
-}
+}
\ No newline at end of file
diff --git a/sass/_syntax-theme.scss b/sass/_syntax-theme.scss
deleted file mode 100644
index 80df341a41..0000000000
--- a/sass/_syntax-theme.scss
+++ /dev/null
@@ -1,192 +0,0 @@
-.z-code {
- color: #c0c5ce;
- background-color: $syntax-theme-background;
-}
-
-.z-variable.z-parameter.z-function {
- color: #c0c5ce;
-}
-.z-comment, .z-punctuation.z-definition.z-comment {
- color: #65737e;
-}
-.z-punctuation.z-definition.z-string, .z-punctuation.z-definition.z-variable, .z-punctuation.z-definition.z-string, .z-punctuation.z-definition.z-parameters, .z-punctuation.z-definition.z-string, .z-punctuation.z-definition.z-array {
- color: #c0c5ce;
-}
-.z-none {
- color: #c0c5ce;
-}
-.z-keyword.z-operator {
- color: #c0c5ce;
-}
-.z-keyword {
- color: #c594c5ff;
-}
-.z-variable {
- color: #c0c5ce;
-}
-.z-entity.z-name.z-function, .z-meta.z-require, .z-support.z-function.z-any-method {
- color: #6699ccff;
-}
-.z-support.z-class, .z-entity.z-name.z-class, .z-entity.z-name.z-type.z-class {
-    color: #dfc479;
-}
-.z-meta.z-class {
- color: #eff1f5;
-}
-.z-keyword.z-other.z-special-method {
- color: #8fa1b3;
-}
-.z-storage {
- color: #b48ead;
-}
-.z-support.z-function {
- color: #6699ccff;
-}
-.z-string, .z-constant.z-other.z-symbol, .z-entity.z-other.z-inherited-class {
- color: #9fc37f;
-}
-.z-none {
- color: #e79e6d;
-}
-.z-constant {
- color: #e79e6d;
-}
-.z-entity.z-name.z-tag {
- color: #e05a67;
-}
-.z-entity.z-other.z-attribute-name {
- color: #d08770;
-}
-.z-entity.z-other.z-attribute-name.z-id, .z-punctuation.z-definition.z-entity {
- color: #8fa1b3;
-}
-.z-meta.z-selector {
- color: #b48ead;
-}
-.z-markup.z-heading .z-punctuation.z-definition.z-heading, .z-entity.z-name.z-section {
- color: #8fa1b3;
-}
-.z-keyword.z-other.z-unit {
- color: #e79e6d;
-}
-.z-markup.z-bold, .z-punctuation.z-definition.z-bold {
-    color: #dfc479;
-    font-weight: bold;
-}
-.z-markup.z-italic, .z-punctuation.z-definition.z-italic {
- color: #b48ead;
-font-style: italic;
-}
-.z-markup.z-raw.z-inline {
- color: #a3be8c;
-}
-.z-string.z-other.z-link {
- color: #bf616a;
-}
-.z-meta.z-link {
- color: #e79e6d;
-}
-.z-markup.z-list {
- color: #bf616a;
-}
-.z-markup.z-quote {
- color: #e79e6d;
-}
-.z-meta.z-separator {
- color: #c0c5ce;
- background-color: #4f5b66;
-}
-.z-markup.z-inserted, .z-markup.z-inserted.z-git_gutter {
- color: #a3be8c;
-}
-.z-markup.z-deleted, .z-markup.z-deleted.z-git_gutter {
- color: #bf616a;
-}
-.z-markup.z-changed, .z-markup.z-changed.z-git_gutter {
- color: #b48ead;
-}
-.z-markup.z-ignored, .z-markup.z-ignored.z-git_gutter {
- color: #4f5b66;
-}
-.z-markup.z-untracked, .z-markup.z-untracked.z-git_gutter {
- color: #4f5b66;
-}
-.z-constant.z-other.z-color {
- color: #96b5b4;
-}
-.z-string.z-regexp {
- color: #96b5b4;
-}
-.z-constant.z-character.z-escape {
- color: #96b5b4;
-}
-.z-punctuation.z-section.z-embedded, .z-variable.z-interpolation {
- color: #ab7967;
-}
-.z-invalid.z-illegal {
- color: #2b303b;
- background-color: #bf616a;
-}
-.z-markup.z-deleted.z-git_gutter {
- color: #f92672;
-}
-.z-markup.z-inserted.z-git_gutter {
- color: #a6e22e;
-}
-.z-markup.z-changed.z-git_gutter {
- color: #967efb;
-}
-.z-markup.z-ignored.z-git_gutter {
- color: #565656;
-}
-.z-markup.z-untracked.z-git_gutter {
- color: #565656;
-}
-
-
-// RUST OVERRIDES
-
-.z-meta.z-generic.z-rust, .z-entity.z-name.z-struct.z-rust, .z-entity.z-name.z-impl.z-rust {
-    color: #dfc479;
-} 
-
-.z-punctuation.z-definition.z-generic.z-rust {
-    color: #c0c5ce;
-}
-
-.z-storage.z-type.z-function, .z-keyword.z-operator.z-rust, .z-storage.z-type.z-struct.z-rust,
-.z-punctuation.z-accessor.z-rust, .z-storage.z-modifier.z-rust {
-    color: #c594c5ff;
-}
-
-.z-support.z-macro.z-rust {
-    color: #6699ccff;
-}
-
-.z-punctuation.z-definition.z-string {
-    color: #9fc37f;
-}
-
-.z-entity.z-name.z-trait.z-rust {
-    color: #56b6c2;
-}
-
-.z-meta.z-annotation.z-rust, .z-variable.z-annotation.z-rust {
-    color: #d19a66;
-}
-
-.z-meta.z-annotation.z-parameters.z-rust {
-    .z-begin, .z-end, .z-punctuation {
-        color: #d19a66;
-    }
-    color: #d1af8f;
-}
-
-// SHELL OVERRIDES
-.z-variable.z-function.z-shell, .z-support.z-function.z-shell {
-    color: #6699ccff;
-}
-
-.z-variable.z-parameter.z-option {
-    color: #c594c5ff;
-}
\ No newline at end of file
diff --git a/sass/site.scss b/sass/site.scss
index 34e0147ba7..249b3d4e92 100644
--- a/sass/site.scss
+++ b/sass/site.scss
@@ -9,18 +9,15 @@ $default-color: #ececec;
 $content-top-margin: 30px;
 $default-padding: 15px;
 $subtitle-color: #8f8f8f;
-$syntax-theme-background: #2b2c2f;
+$syntax-theme-background: #2b303b;
 $syntax-theme-background-hover: #414247;
 $default-image-background-color: #1b1b1b;
 $card-hover-background: #2f3033;
 $media-max-width: 1000px;
 $border-radius: 10px;
-$card-list-gap: 15px;
 
-@import "syntax-theme";
 @import "headerbar";
 @import "community";
-@import "assets";
 @import "book";
 @import "book-nav";
 @import "news";
diff --git a/static/assets/metabuild.png b/static/assets/metabuild.png
deleted file mode 100644
index af056dba55..0000000000
Binary files a/static/assets/metabuild.png and /dev/null differ
diff --git a/static/assets/q_and_a.svg b/static/assets/q_and_a.svg
deleted file mode 100644
index 8049d2cd40..0000000000
--- a/static/assets/q_and_a.svg
+++ /dev/null
@@ -1,77 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   width="61.005001mm"
-   height="43.25259mm"
-   viewBox="0 0 61.005 43.252591"
-   version="1.1"
-   id="svg5"
-   inkscape:version="1.1 (c4e8f9ed74, 2021-05-24)"
-   sodipodi:docname="q_and_a.svg"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <sodipodi:namedview
-     id="namedview7"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageshadow="2"
-     inkscape:pageopacity="0.0"
-     inkscape:pagecheckerboard="0"
-     inkscape:document-units="mm"
-     showgrid="false"
-     fit-margin-top="0"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0"
-     inkscape:zoom="6.4070146"
-     inkscape:cx="54.15939"
-     inkscape:cy="74.215533"
-     inkscape:window-width="3440"
-     inkscape:window-height="1440"
-     inkscape:window-x="0"
-     inkscape:window-y="0"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="layer1" />
-  <defs
-     id="defs2" />
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(-57.369482,-72.497175)">
-    <g
-       aria-label="?"
-       id="text2211"
-       style="font-size:25.7894px;line-height:1.25;letter-spacing:0px;word-spacing:0px;stroke-width:0.644736"
-       transform="matrix(2.2787309,0,0,2.2787309,-71.943846,-148.27628)">
-      <path
-         d="m 70.433534,96.884391 c -2.965781,0 -4.977354,1.186313 -6.421561,2.888413 l 3.172096,2.475786 c 0.851051,-0.90263 1.779469,-1.39263 2.682098,-1.39263 0.85105,0 1.315259,0.36105 1.315259,1.00579 0,1.7021 -3.816831,1.49578 -3.816831,6.03472 v 0.48999 h 4.538935 v -0.33526 c 0,-2.60473 4.616302,-2.44999 4.616302,-6.67945 0,-2.424207 -2.011573,-4.487359 -6.086298,-4.487359 z m -0.773682,13.668379 c -1.469996,0 -2.656308,1.21211 -2.656308,2.65631 0,1.44421 1.186312,2.65631 2.656308,2.65631 1.469996,0 2.656308,-1.2121 2.656308,-2.65631 0,-1.4442 -1.186312,-2.65631 -2.656308,-2.65631 z"
-         style="font-weight:900;font-family:'Fira Sans';-inkscape-font-specification:'Fira Sans, Heavy';fill:#ececec;fill-opacity:1"
-         id="path22653" />
-    </g>
-    <g
-       aria-label="?"
-       transform="matrix(2.2066287,-0.56868636,0.56868636,2.2066287,-72.833159,-147.63635)"
-       id="text2211-0"
-       style="font-size:12.4356px;line-height:1.25;letter-spacing:0px;word-spacing:0px;fill:#ececec;fill-opacity:1;stroke-width:0.31089">
-      <path
-         d="m 32.441708,113.69452 c -1.430094,0 -2.400071,0.57204 -3.096464,1.39279 l 1.529579,1.19382 c 0.410374,-0.43525 0.858056,-0.67153 1.293302,-0.67153 0.410375,0 0.634216,0.1741 0.634216,0.48499 0,0.82075 -1.840469,0.72127 -1.840469,2.90993 v 0.23628 h 2.188665 v -0.16166 c 0,-1.256 2.225973,-1.18139 2.225973,-3.22082 0,-1.16895 -0.969977,-2.1638 -2.934802,-2.1638 z m -0.373068,6.59087 c -0.708829,0 -1.280867,0.58447 -1.280867,1.28087 0,0.69639 0.572038,1.28086 1.280867,1.28086 0.708829,0 1.280867,-0.58447 1.280867,-1.28086 0,-0.6964 -0.572038,-1.28087 -1.280867,-1.28087 z"
-         style="font-weight:900;font-family:'Fira Sans';-inkscape-font-specification:'Fira Sans, Heavy';fill:#ececec;fill-opacity:1"
-         id="path22656" />
-    </g>
-    <g
-       aria-label="?"
-       transform="matrix(2.1366867,0.79194998,-0.79194998,2.1366867,-72.833163,-148.27628)"
-       id="text2211-0-8"
-       style="font-size:12.4356px;line-height:1.25;letter-spacing:0px;word-spacing:0px;fill:#ececec;fill-opacity:1;stroke-width:0.31089">
-      <path
-         d="m 111.81357,67.601157 c -1.40523,0.265608 -2.25207,1.007837 -2.78393,1.943647 l 1.72469,0.888965 c 0.32241,-0.503891 0.71842,-0.819202 1.1461,-0.900039 0.40322,-0.07621 0.65551,0.05328 0.71324,0.358761 0.15243,0.806471 -1.67449,1.050539 -1.26799,3.201124 l 0.0438,0.23217 2.15058,-0.406491 -0.0301,-0.158846 c -0.23324,-1.234147 1.96783,-1.574247 1.58906,-3.578201 -0.21716,-1.148603 -1.35497,-1.945999 -3.28561,-1.581082 z m 0.8575,6.545487 c -0.69649,0.13165 -1.15004,0.812194 -1.0207,1.49647 0.12936,0.684277 0.79998,1.15234 1.49647,1.020694 0.69651,-0.131651 1.15004,-0.812194 1.02071,-1.496473 -0.12936,-0.684275 -0.79998,-1.152338 -1.49648,-1.020691 z"
-         style="font-weight:900;font-family:'Fira Sans';-inkscape-font-specification:'Fira Sans, Heavy';fill:#ececec;fill-opacity:1"
-         id="path22659" />
-    </g>
-  </g>
-</svg>
diff --git a/static/assets/stack-overflow.svg b/static/assets/stack-overflow.svg
new file mode 100644
index 0000000000..887e8570ba
--- /dev/null
+++ b/static/assets/stack-overflow.svg
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   inkscape:version="1.0 (4035a4fb49, 2020-05-01)"
+   sodipodi:docname="stack-overflow.svg"
+   id="svg4"
+   version="1.1"
+   viewBox="0 0 384 512">
+  <metadata
+     id="metadata10">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs8" />
+  <sodipodi:namedview
+     inkscape:current-layer="svg4"
+     inkscape:window-maximized="1"
+     inkscape:window-y="0"
+     inkscape:window-x="0"
+     inkscape:cy="262.19697"
+     inkscape:cx="129.24414"
+     inkscape:zoom="2.0039062"
+     showgrid="false"
+     id="namedview6"
+     inkscape:window-height="1440"
+     inkscape:window-width="3440"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0"
+     guidetolerance="10"
+     gridtolerance="10"
+     objecttolerance="10"
+     borderopacity="1"
+     bordercolor="#666666"
+     pagecolor="#ffffff" />
+  <path
+     style="fill:#f48024;fill-opacity:1"
+     id="path2"
+     d="M290.7 311L95 269.7 86.8 309l195.7 41zm51-87L188.2 95.7l-25.5 30.8 153.5 128.3zm-31.2 39.7L129.2 179l-16.7 36.5L293.7 300zM262 32l-32 24 119.3 160.3 32-24zm20.5 328h-200v39.7h200zm39.7 80H42.7V320h-40v160h359.5V320h-40z" />
+</svg>
diff --git a/templates/assets-macros.html b/templates/assets-macros.html
deleted file mode 100644
index 365bf473b6..0000000000
--- a/templates/assets-macros.html
+++ /dev/null
@@ -1,17 +0,0 @@
-{% macro card(post) %}
-<div class="card" id="{{ post.title | slugify }}">
-    <a href="{{ post.extra.link }}">
-        {% if post.extra.image %}
-        <div class="card-image card-image-default">
-            <img src="{{ get_url(path=post.extra.image) }}" />
-        </div>
-        {% endif %}
-        <div class="card-text">
-            <div class="card-title">{{ post.title }}</div>
-            <div class="card-description">
-                {{ post.description | striptags | truncate(length=100) | safe }}
-            </div>
-        </div>
-    </a>
-</div>
-{% endmacro card %}
diff --git a/templates/assets.html b/templates/assets.html
deleted file mode 100644
index 730f761cb0..0000000000
--- a/templates/assets.html
+++ /dev/null
@@ -1,77 +0,0 @@
-{% import "assets-macros.html" as macros %}
-
-{% extends "base.html" %}
-
-{% block content %}
-<div class="assets">
-    <input type="checkbox" style="display: none" id="show-book-nav" />
-    <nav class="book-nav" role="navigation">
-        <ul class="book-nav-sections-container book-nav-sections">
-            {% for subsection in section.subsections %}
-            {% set section = get_section(path=subsection) %}
-            <li class="book-nav-section">
-                <a href="#{{ section.title | slugify }}" class="book-nav-section-title">{{ section.title }}</a>
-                {% if section.subsections %}
-                <ul class="book-nav-sections book-nav-sections-indented">
-                    {% set subsections = section.subsections %}
-                    {% if section.extra.sort_order_reversed %}
-                    {% set subsections = section.subsections | reverse %}
-                    {% endif %}
-                    {% for subsection in subsections %}
-                    {% set section = get_section(path=subsection) %}
-                    <li class="book-nav-section">
-                        <a href="#{{ section.title | slugify }}" class="book-nav-section-title">{{ section.title }}</a>
-                    </li>
-
-                    {% endfor %}
-                </ul>
-                {% endif %}
-            </li>
-            {% endfor %}
-        </ul>
-    </nav>
-    <div class="book-content">
-        {% for subsection in section.subsections %}
-        {% set section = get_section(path=subsection) %}
-
-        <h1 id="{{ section.title | slugify }}" class="asset-section">
-            {{ section.title }}<a class="anchor-link" href="#{{ section.title | slugify }}">#</a>
-        </h1>
-
-        {% if section.pages %}
-        <div class="card-list padded-content">
-            {% set pages = section.pages %}
-            {% if section.extra.sort_order_reversed %}
-            {% set pages = section.pages | reverse %}
-            {% endif %}
-            {% for post in pages %}
-            {{ macros::card(post=post) }}
-            {% endfor %}
-        </div>
-        {% endif %}
-
-        {% set subsections = section.subsections %}
-        {% if section.extra.sort_order_reversed %}
-        {% set subsections = section.subsections | reverse %}
-        {% endif %}
-        {% for subsection in subsections %}
-        {% set section = get_section(path=subsection) %}
-
-        <h3 id="{{ section.title | slugify }}">
-            {{ section.title }}<a class="anchor-link" href="#{{ section.title | slugify }}">#</a>
-        </h3>
-        <div class="card-list padded-content">
-            {% set pages = section.pages %}
-            {% if section.extra.sort_order_reversed %}
-            {% set pages = section.pages | reverse %}
-            {% endif %}
-            {% for post in pages %}
-            {{ macros::card(post=post) }}
-            {% endfor %}
-        </div>
-
-        {% endfor %}
-        {% endfor %}
-    </div>
-</div>
-{% endblock content %}
\ No newline at end of file
diff --git a/templates/base.html b/templates/base.html
index 0635e8145a..467018af25 100644
--- a/templates/base.html
+++ b/templates/base.html
@@ -15,13 +15,6 @@
 {% set path = ""%}
 {% endif %}
 
-{% if section %}
-    {% if section.path is starting_with("/learn/book/") %}
-        {% set show_nav_toggle = true %}
-    {% elif section.path is starting_with("/assets/") %}
-        {% set show_nav_toggle = true %}
-    {% endif %}
-{% endif %}
 <!doctype html>
 <html lang="en">
     <head>
@@ -45,7 +38,7 @@
                 <a href="/" class="header-logo">
                     <img src="/assets/bevy_logo_dark.svg" class="logo" alt="bevy logo" />
                 </a>
-                {% if show_nav_toggle %}
+                {% if section and section.path is starting_with("/learn/book/") %}
                     <label class="toggle-nav-mobile" for=show-book-nav>
                         <svg alt="nav bars" width="24" height="24">
                             <g fill="none" stroke="#ececec" stroke-width="2">
@@ -80,7 +73,6 @@
                 {{header_macros::header_item(name="Learn", current_path=current_path)}}
                 {{header_macros::header_item(name="News", current_path=current_path)}}
                 {{header_macros::header_item(name="Community", current_path=current_path)}}
-                {{header_macros::header_item(name="Assets", current_path=current_path)}}
                 <a class="header-item header-button header-button-donate" href="https://github.com/sponsors/cart">Donate <img src="/assets/heart.svg" class="header-button-donate-heart" alt="heart icon"/></a>
                 <a class="header-item header-button" href="/learn/book/getting-started/">Get Started</a>
             </nav>
diff --git a/templates/book-macros.html b/templates/book-macros.html
index c09a6889f4..d7cc97815f 100644
--- a/templates/book-macros.html
+++ b/templates/book-macros.html
@@ -5,7 +5,7 @@
         <strong class="book-nav-section-number">{{ section_number }}.</strong>
         {{ section.title | lower }}
     </a>
-    {% if section.subsections and section.path in current_path %}
+    {% if section.subsections %}
     <ul class="book-nav-sections book-nav-sections-indented">
         {% for s in section.subsections %}
         {% set subsection_number = section_number ~ "." ~ loop.index %}
diff --git a/templates/community.html b/templates/community.html
index 2691bdcbd8..43d2121cf4 100644
--- a/templates/community.html
+++ b/templates/community.html
@@ -4,7 +4,7 @@
 <div class="card-list padded-content">
     <a class="card" href="https://github.com/bevyengine/bevy">
         <div class="card-image">
-            <img src="/assets/github.svg" class="centered-card-image community-icon" alt="Github logo" />
+            <img src="/assets/github.svg" class="centered-card-image community-icon" alt="Github logo"/>
         </div>
         <div class="card-text">
             <div class="card-title">
@@ -18,25 +18,25 @@
             </div>
         </div>
     </a>
-    <a class="card" href="https://github.com/bevyengine/bevy/discussions/categories/q-a">
+    <a class="card" href="https://twitter.com/BevyEngine">
         <div class="card-image">
-            <img src="/assets/q_and_a.svg" class="centered-card-image community-icon" alt="Q and A logo" />
+            <img src="/assets/twitter.svg" class="centered-card-image community-icon" alt="Twitter logo"/>
         </div>
         <div class="card-text">
             <div class="card-title">
-                Bevy Q&A
+                Twitter
             </div>
             <div class="card-subtitle">
-                github.com/bevyengine
+                twitter.com/bevyengine
             </div>
             <div class="card-description">
-                The go-to place to ask Bevy questions and get Bevy answers
+                Quick updates and shared Bevy content from the community
             </div>
         </div>
     </a>
     <a class="card" href="https://discord.gg/bevy">
         <div class="card-image">
-            <img src="/assets/discord.svg" class="centered-card-image community-icon" alt="Discord logo" />
+            <img src="/assets/discord.svg" class="centered-card-image community-icon" alt="Discord logo"/>
         </div>
         <div class="card-text">
             <div class="card-title">
@@ -50,25 +50,25 @@
             </div>
         </div>
     </a>
-    <a class="card" href="https://twitter.com/BevyEngine">
+    <a class="card" href="https://stackoverflow.com/questions/tagged/bevy">
         <div class="card-image">
-            <img src="/assets/twitter.svg" class="centered-card-image community-icon" alt="Twitter logo" />
+            <img src="/assets/stack-overflow.svg" class="centered-card-image community-icon" alt="StackOverflow logo"/>
         </div>
         <div class="card-text">
             <div class="card-title">
-                Twitter
+                Stack Overflow
             </div>
             <div class="card-subtitle">
-                twitter.com/bevyengine
+                bevy
             </div>
             <div class="card-description">
-                Quick updates and shared Bevy content from the community
+                The go-to place to ask Bevy questions and get Bevy answers
             </div>
         </div>
     </a>
     <a class="card" href="https://www.reddit.com/r/bevy/">
         <div class="card-image">
-            <img src="/assets/reddit.svg" class="centered-card-image community-icon" alt="Reddit logo" />
+            <img src="/assets/reddit.svg" class="centered-card-image community-icon" alt="Reddit logo"/>
         </div>
         <div class="card-text">
             <div class="card-title">
@@ -82,16 +82,16 @@
             </div>
         </div>
     </a>
-    <a class="card" href="https://bevyengine.org/assets/">
+    <a class="card" href="https://github.com/bevyengine/awesome-bevy">
         <div class="card-image">
-            <img src="/assets/bevy_icon_dark.svg" class="centered-card-image community-icon" alt="Bevy logo" />
+            <img src="/assets/bevy_icon_dark.svg" class="centered-card-image community-icon" alt="Bevy logo"/>
         </div>
         <div class="card-text">
             <div class="card-title">
-                Bevy Assets
+                Awesome Bevy
             </div>
             <div class="card-subtitle">
-                bevyengine.org/assets/
+                github.com/bevyengine/awesome-bevy
             </div>
             <div class="card-description">
                 List of community projects in Bevy, including plugins, games, books, and tutorials.
@@ -100,7 +100,7 @@
     </a>
     <a class="card" href="https://itch.io/games/tag-bevy">
         <div class="card-image">
-            <img src="/assets/itchio-textless.svg" class="centered-card-image community-icon" alt="itch.io logo" />
+            <img src="/assets/itchio-textless.svg" class="centered-card-image community-icon" alt="itch.io logo"/>
         </div>
         <div class="card-text">
             <div class="card-title">
@@ -115,4 +115,4 @@
         </div>
     </a>
 </div>
-{% endblock content %}
\ No newline at end of file
+{% endblock content %}
diff --git a/templates/index.html b/templates/index.html
index b69342851b..c19186dc16 100644
--- a/templates/index.html
+++ b/templates/index.html
@@ -194,10 +194,8 @@ <h2>Platinum Sponsors</h2>
         <a href="https://www.embark-studios.com/"><img src="assets/embark.png" style="height: 6rem"
                 alt="Embark Studios logo" /></a>
         <h2>Bronze Sponsors</h2>
-        <div class="bronze-sponsors">
-            <a href="https://vertexstudio.co/"><img src="assets/vertex_studio.png" class="bronze-sponsor-image" alt="Vertex Studio logo"/></a>
-            <a href="https://www.metabuild.io/"><img src="assets/metabuild.png" class="bronze-sponsor-image" alt="Metabuild Logo"/></a>
-        </div>
+        <a href="https://vertexstudio.co/"><img src="assets/vertex_studio.png" style="height: 4rem"
+                alt="Vertex Studio logo" /></a>
     </div>
 </div>
 {% endblock content %}
\ No newline at end of file
diff --git a/templates/learn.html b/templates/learn.html
index af47516403..479d426537 100644
--- a/templates/learn.html
+++ b/templates/learn.html
@@ -4,7 +4,7 @@
 <div class="card-list padded-content">
   <a class="card" href="/learn/book/welcome">
     <div class="card-image">
-      <img src="/assets/book.svg" class="centered-card-image" alt="Bevy book" />
+      <img src="/assets/book.svg" class="centered-card-image" alt="Bevy book"/>
     </div>
     <div class="card-text">
       <div class="card-title">
@@ -17,7 +17,7 @@
   </a>
   <a class="card" href="https://docs.rs/bevy">
     <div class="card-image">
-      <img src="/assets/rust-logo-light.svg" class="centered-card-image" alt="Rust logo" />
+      <img src="/assets/rust-logo-light.svg" class="centered-card-image" alt="Rust logo"/>
     </div>
     <div class="card-text">
       <div class="card-title">
@@ -30,7 +30,7 @@
   </a>
   <a class="card" href="https://github.com/bevyengine/bevy/tree/latest/examples#examples">
     <div class="card-image">
-      <img src="/assets/github.svg" class="centered-card-image" alt="Github logo" />
+      <img src="/assets/github.svg" class="centered-card-image" alt="Github logo"/>
     </div>
     <div class="card-text">
       <div class="card-title">
@@ -41,19 +41,18 @@
       </div>
     </div>
   </a>
-  <a class="card" href="/assets">
+  <a class="card" href="https://github.com/bevyengine/awesome-bevy">
     <div class="card-image">
-      <img src="/assets/bevy_icon_dark.svg" class="centered-card-image" alt="Bevy logo" />
+      <img src="/assets/bevy_icon_dark.svg" class="centered-card-image" alt="Bevy logo"/>
     </div>
     <div class="card-text">
       <div class="card-title">
-        Bevy Assets
+        Awesome Bevy
       </div>
       <div class="card-description">
-        Find Assets to use in your games. Learn by example with a list of cool Bevy projects. Read community-made
-        tutorials and documentation.
+        Learn by example with an awesome-style list of cool Bevy projects. Read community-made tutorials and documentation.
       </div>
     </div>
   </a>
 </div>
-{% endblock content %}
\ No newline at end of file
+{% endblock content %}
diff --git a/templates/shortcodes/file_code_block.html b/templates/shortcodes/file_code_block.html
index db5ff35a43..45bd75c982 100644
--- a/templates/shortcodes/file_code_block.html
+++ b/templates/shortcodes/file_code_block.html
@@ -1,35 +1,6 @@
 {% if not lang %}
     {% set lang = "" %}
 {% endif %}
-
-{% set code = load_data(path=path) %}
-
-{% if anchor %}
-
-    {% set code_lines = code | split(pat="\n") %}
-    {% set code = "" %}
-    {% set in_anchor = false %}
-
-    {% for line in code_lines %}
-
-        {% if line is ending_with("// ANCHOR_END: " ~ anchor) %}
-            {% set_global in_anchor = false %}
-        {% endif %}
-
-        {% if in_anchor %}
-            {% set_global code = code ~ line ~ "
-" %}
-        {% endif %}
-
-        {% if line is ending_with("// ANCHOR: " ~ anchor) %}
-            {% set_global in_anchor = true %}
-        {% endif %}
-
-    {% endfor %}
-
-{% endif %}
-
 {% set data = "```" ~ lang ~ "
-" ~ code ~ "```" %}
-
+" ~ load_data(path=path) ~ "```" %}
 {{data | markdown(inline=true) | safe}}
\ No newline at end of file