diff --git a/crates/bevy_ecs/macros/src/component.rs b/crates/bevy_ecs/macros/src/component.rs
index 440fe31468df7..1f56d840fd45b 100644
--- a/crates/bevy_ecs/macros/src/component.rs
+++ b/crates/bevy_ecs/macros/src/component.rs
@@ -2,7 +2,9 @@ use bevy_macro_utils::{get_lit_str, Symbol};
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::{quote, ToTokens};
-use syn::{parse_macro_input, parse_quote, DeriveInput, Error, Ident, Path, Result};
+use syn::{
+    parse_macro_input, parse_quote, DataStruct, DeriveInput, Error, Fields, Ident, Path, Result,
+};
 
 pub fn derive_component(input: TokenStream) -> TokenStream {
     let mut ast = parse_macro_input!(input as DeriveInput);
@@ -23,18 +25,61 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
     let struct_name = &ast.ident;
     let (impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();
 
+    let (lens_type, ext) = match attrs.lens {
+        Lens::None => (quote! {#bevy_ecs_path::lens::NoopLens<Self>}, None),
+        Lens::Declared(decl) => (decl, None),
+        Lens::Derived => {
+            let inner_type = match &ast.data {
+                syn::Data::Struct(DataStruct {
+                    fields: Fields::Unnamed(f),
+                    ..
+                }) if f.unnamed.len() == 1 => &f.unnamed[0].ty,
+                _ => return quote! {
+                    compile_error!("Automatic lensing is only available for unit structs with one element")
+                }.into(),
+            };
+            (
+                quote! {Self},
+                Some(quote! {
+                    impl #impl_generics #bevy_ecs_path::lens::Lens for #struct_name #type_generics #where_clause {
+                        type In = Self;
+                        type Out = #inner_type;
+
+                        fn get(input: &Self::In) -> &Self::Out {
+                            &input.0
+                        }
+                        fn get_mut(input: &mut Self::In) -> &mut Self::Out {
+                            &mut input.0
+                        }
+                    }
+                }),
+            )
+        }
+    };
+
     TokenStream::from(quote! {
+        #ext
+
         impl #impl_generics #bevy_ecs_path::component::Component for #struct_name #type_generics #where_clause {
             type Storage = #storage;
+            type DefaultLens = #lens_type;
         }
     })
 }
 
 pub const COMPONENT: Symbol = Symbol("component");
 pub const STORAGE: Symbol = Symbol("storage");
+pub const LENS: Symbol = Symbol("lens");
 
 struct Attrs {
     storage: StorageTy,
+    lens: Lens,
+}
+
+enum Lens {
+    None,
+    Declared(TokenStream2),
+    Derived,
 }
 
 #[derive(Clone, Copy)]
@@ -52,11 +97,12 @@ fn parse_component_attr(ast: &DeriveInput) -> Result<Attrs> {
 
     let mut attrs = Attrs {
         storage: StorageTy::Table,
+        lens: Lens::None,
     };
 
     for meta in meta_items {
         use syn::{
-            Meta::NameValue,
+            Meta::{NameValue, Path},
             NestedMeta::{Lit, Meta},
         };
         match meta {
@@ -75,6 +121,16 @@ fn parse_component_attr(ast: &DeriveInput) -> Result<Attrs> {
                     }
                 };
             }
+            Meta(NameValue(m)) if m.path == LENS => {
+                attrs.lens = Lens::Declared(get_lit_str(LENS, &m.lit)?.value().as_str().parse()?);
+            }
+            Meta(Path(p))
+                if p.leading_colon.is_none()
+                    && p.segments.len() == 1
+                    && p.segments[0].ident == LENS =>
+            {
+                attrs.lens = Lens::Derived;
+            }
             Meta(meta_item) => {
                 return Err(Error::new_spanned(
                     meta_item.path(),
diff --git a/crates/bevy_ecs/src/change_detection.rs b/crates/bevy_ecs/src/change_detection.rs
index 369d9ecfab486..f00b63ecef315 100644
--- a/crates/bevy_ecs/src/change_detection.rs
+++ b/crates/bevy_ecs/src/change_detection.rs
@@ -1,6 +1,6 @@
 //! Types that detect when their internal data mutate.
 
-use crate::{component::ComponentTicks, system::Resource};
+use crate::{component::ComponentTicks, lens::Lens, system::Resource};
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::Reflect;
 use std::ops::{Deref, DerefMut};
@@ -116,6 +116,32 @@ macro_rules! impl_into_inner {
     };
 }
 
+macro_rules! impl_lens {
+    ($name:ident < $( $generics:tt ),+ >, $target:ty, $($traits:ident)?) => {
+        impl<$($generics),* $(: $traits)?> $name<$($generics),*> {
+            #[inline]
+            pub fn lens<L: Lens<In = $target>>(self) -> Mut<'a, L::Out> {
+                Mut {
+                    value: L::get_mut(self.value),
+                    ticks: self.ticks,
+                }
+            }
+
+            #[inline]
+            pub fn lens_borrow<'b, L: Lens<In = $target>>(&'b mut self) -> Mut<'b, L::Out> {
+                Mut {
+                    value: L::get_mut(self.value),
+                    ticks: Ticks {
+                        component_ticks: self.ticks.component_ticks,
+                        last_change_tick: self.ticks.last_change_tick,
+                        change_tick: self.ticks.change_tick,
+                    },
+                }
+            }
+        }
+    };
+}
+
 macro_rules! impl_debug {
     ($name:ident < $( $generics:tt ),+ >, $($traits:ident)?) => {
         impl<$($generics),* $(: $traits)?> std::fmt::Debug for $name<$($generics),*>
@@ -154,6 +180,7 @@ pub struct ResMut<'a, T: Resource> {
 }
 
 change_detection_impl!(ResMut<'a, T>, T, Resource);
+impl_lens!(ResMut<'a, T>, T, Resource);
 impl_into_inner!(ResMut<'a, T>, T, Resource);
 impl_debug!(ResMut<'a, T>, Resource);
 
@@ -175,6 +202,7 @@ pub struct NonSendMut<'a, T: 'static> {
 }
 
 change_detection_impl!(NonSendMut<'a, T>, T,);
+impl_lens!(NonSendMut<'a, T>, T,);
 impl_into_inner!(NonSendMut<'a, T>, T,);
 impl_debug!(NonSendMut<'a, T>,);
 
@@ -185,6 +213,7 @@ pub struct Mut<'a, T> {
 }
 
 change_detection_impl!(Mut<'a, T>, T,);
+impl_lens!(Mut<'a, T>, T,);
 impl_into_inner!(Mut<'a, T>, T,);
 impl_debug!(Mut<'a, T>,);
 
@@ -199,3 +228,70 @@ pub struct ReflectMut<'a> {
 change_detection_impl!(ReflectMut<'a>, dyn Reflect,);
 #[cfg(feature = "bevy_reflect")]
 impl_into_inner!(ReflectMut<'a>, dyn Reflect,);
+
+mod ops_passthrough {
+    use std::ops::*;
+
+    use super::Mut;
+
+    macro_rules! binary_ops {
+        ($trait:ident, $method:ident) => {
+            impl<Rhs, T: $trait<Rhs> + Copy> $trait<Rhs> for Mut<'_, T> {
+                type Output = T::Output;
+
+                fn $method(self, rhs: Rhs) -> Self::Output {
+                    T::$method(*self, rhs)
+                }
+            }
+        };
+    }
+    macro_rules! unary_ops {
+        ($trait:ident, $method:ident) => {
+            impl<T: $trait + Copy> $trait for Mut<'_, T> {
+                type Output = T::Output;
+
+                fn $method(self) -> Self::Output {
+                    T::$method(*self)
+                }
+            }
+        };
+    }
+    macro_rules! assign_ops {
+        ($trait:ident, $method:ident) => {
+            impl<Rhs, T: $trait<Rhs>> $trait<Rhs> for Mut<'_, T> {
+                fn $method(&mut self, rhs: Rhs) {
+                    T::$method(&mut *self, rhs)
+                }
+            }
+        };
+    }
+
+    binary_ops!(Add, add);
+    binary_ops!(Sub, sub);
+    binary_ops!(Mul, mul);
+    binary_ops!(Div, div);
+
+    binary_ops!(Rem, rem);
+
+    binary_ops!(BitAnd, bitand);
+    binary_ops!(BitOr, bitor);
+    binary_ops!(BitXor, bitxor);
+    binary_ops!(Shr, shr);
+    binary_ops!(Shl, shl);
+
+    unary_ops!(Neg, neg);
+    unary_ops!(Not, not);
+
+    assign_ops!(AddAssign, add_assign);
+    assign_ops!(SubAssign, sub_assign);
+    assign_ops!(MulAssign, mul_assign);
+    assign_ops!(DivAssign, div_assign);
+
+    assign_ops!(RemAssign, rem_assign);
+
+    assign_ops!(BitAndAssign, bitand_assign);
+    assign_ops!(BitOrAssign, bitor_assign);
+    assign_ops!(BitXorAssign, bitxor_assign);
+    assign_ops!(ShrAssign, shr_assign);
+    assign_ops!(ShlAssign, shl_assign);
+}
diff --git a/crates/bevy_ecs/src/component.rs b/crates/bevy_ecs/src/component.rs
index ebb9896a606d3..9ad2b16a3e634 100644
--- a/crates/bevy_ecs/src/component.rs
+++ b/crates/bevy_ecs/src/component.rs
@@ -1,6 +1,7 @@
 //! Types for declaring and storing [`Component`]s.
 
 use crate::{
+    lens::{Lens, NoopLens},
     storage::{SparseSetIndex, Storages},
     system::Resource,
 };
@@ -32,6 +33,8 @@ use std::{
 /// Components can be grouped together into a [`Bundle`](crate::bundle::Bundle).
 pub trait Component: Send + Sync + 'static {
     type Storage: ComponentStorage;
+
+    type DefaultLens: Lens<In = Self>;
 }
 
 pub struct TableStorage;
@@ -61,6 +64,7 @@ where
     Self: Send + Sync + 'static,
 {
     type Storage = TableStorage;
+    type DefaultLens = NoopLens<Self>;
 }
 
 /// The storage used for a specific component type.
diff --git a/crates/bevy_ecs/src/lens.rs b/crates/bevy_ecs/src/lens.rs
new file mode 100644
index 0000000000000..9de0a868b25e7
--- /dev/null
+++ b/crates/bevy_ecs/src/lens.rs
@@ -0,0 +1,76 @@
+use std::marker::PhantomData;
+
+pub trait Lens {
+    type In: 'static;
+    type Out: 'static;
+
+    fn get(input: &Self::In) -> &Self::Out;
+    fn get_mut(input: &mut Self::In) -> &mut Self::Out;
+}
+
+pub struct ComposedLens<A, B>(PhantomData<(A, B)>);
+
+impl<A, B> Lens for ComposedLens<A, B>
+where
+    A: Lens,
+    B: Lens<In = A::Out>,
+{
+    type In = A::In;
+    type Out = B::Out;
+
+    fn get(input: &Self::In) -> &Self::Out {
+        B::get(A::get(input))
+    }
+
+    fn get_mut(input: &mut Self::In) -> &mut Self::Out {
+        B::get_mut(A::get_mut(input))
+    }
+}
+
+pub struct NoopLens<T>(PhantomData<T>);
+
+impl<T: 'static> Lens for NoopLens<T> {
+    type In = T;
+    type Out = T;
+
+    fn get(input: &Self::In) -> &Self::Out {
+        input
+    }
+
+    fn get_mut(input: &mut Self::In) -> &mut Self::Out {
+        input
+    }
+}
+
+#[macro_export]
+macro_rules! declare_lens {
+    ($name:ident, $in:ty, $out:ty, $($path:tt).*) => {
+        struct $name;
+
+        impl $crate::lens::Lens for $name {
+            type In = $in;
+            type Out = $out;
+
+            fn get(input: &Self::In) -> &Self::Out {
+                &input$(.$path)*
+            }
+
+            fn get_mut(input: &mut Self::In) -> &mut Self::Out {
+                &mut input$(.$path)*
+            }
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! composed_lens {
+    ($last:ty) => {
+        $last
+    };
+    ($first:ty, $second:ty) => {
+        $crate::lens::ComposedLens<$first, $second>
+    };
+    ($first:ty, $second:ty, $($rest:ty),*) => {
+        $crate::lens::ComposedLens<composed_lens![$first, $second], composed_lens![$($rest),*]>
+    };
+}
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index ad93f91d0d150..88114556faf92 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -6,6 +6,7 @@ pub mod change_detection;
 pub mod component;
 pub mod entity;
 pub mod event;
+pub mod lens;
 pub mod query;
 #[cfg(feature = "bevy_reflect")]
 pub mod reflect;
@@ -26,7 +27,9 @@ pub mod prelude {
         component::Component,
         entity::Entity,
         event::{EventReader, EventWriter},
-        query::{Added, AnyOf, ChangeTrackers, Changed, Or, QueryState, With, Without},
+        query::{
+            Added, AnyOf, ChangeTrackers, Changed, Or, QueryState, Raw, RawMut, With, Without,
+        },
         schedule::{
             AmbiguitySetLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
             RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaLabel, RunCriteriaPiping,
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index d68c64375e2e5..7d20bf4afa1f7 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -3,6 +3,7 @@ use crate::{
     change_detection::Ticks,
     component::{Component, ComponentId, ComponentStorage, ComponentTicks, StorageType},
     entity::Entity,
+    lens::{Lens, NoopLens},
     query::{Access, FilteredAccess},
     storage::{ComponentSparseSet, Table, Tables},
     world::{Mut, World},
@@ -495,10 +496,19 @@ impl<'w, 's> Fetch<'w, 's> for EntityFetch {
     }
 }
 
+/// Equivalent to querying with `&T`, but ignores the default lens. Useful with generic code
+pub struct Raw<T: Component>(PhantomData<T>);
+
+impl<T: Component> WorldQuery for Raw<T> {
+    type Fetch = ReadFetch<T, NoopLens<T>>;
+    type State = ReadState<T>;
+    type ReadOnlyFetch = ReadFetch<T, NoopLens<T>>;
+}
+
 impl<T: Component> WorldQuery for &T {
-    type Fetch = ReadFetch<T>;
+    type Fetch = ReadFetch<T, T::DefaultLens>;
     type State = ReadState<T>;
-    type ReadOnlyFetch = ReadFetch<T>;
+    type ReadOnlyFetch = ReadFetch<T, T::DefaultLens>;
 }
 
 /// The [`FetchState`] of `&T`.
@@ -550,30 +560,31 @@ unsafe impl<T: Component> FetchState for ReadState<T> {
 }
 
 /// The [`Fetch`] of `&T`.
-#[doc(hidden)]
-pub struct ReadFetch<T> {
+pub struct ReadFetch<T, L> {
     table_components: NonNull<T>,
     entity_table_rows: *const usize,
     entities: *const Entity,
     sparse_set: *const ComponentSparseSet,
+    lens: PhantomData<L>,
 }
 
-impl<T> Clone for ReadFetch<T> {
+impl<T, L> Clone for ReadFetch<T, L> {
     fn clone(&self) -> Self {
         Self {
             table_components: self.table_components,
             entity_table_rows: self.entity_table_rows,
             entities: self.entities,
             sparse_set: self.sparse_set,
+            lens: PhantomData,
         }
     }
 }
 
 /// SAFETY: access is read only
-unsafe impl<T> ReadOnlyFetch for ReadFetch<T> {}
+unsafe impl<T, Lens> ReadOnlyFetch for ReadFetch<T, Lens> {}
 
-impl<'w, 's, T: Component> Fetch<'w, 's> for ReadFetch<T> {
-    type Item = &'w T;
+impl<'w, 's, T: Component, L: Lens<In = T>> Fetch<'w, 's> for ReadFetch<T, L> {
+    type Item = &'w L::Out;
     type State = ReadState<T>;
 
     const IS_DENSE: bool = {
@@ -594,6 +605,7 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for ReadFetch<T> {
             entities: ptr::null::<Entity>(),
             entity_table_rows: ptr::null::<usize>(),
             sparse_set: ptr::null::<ComponentSparseSet>(),
+            lens: PhantomData,
         };
         if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
             value.sparse_set = world
@@ -635,7 +647,7 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for ReadFetch<T> {
 
     #[inline]
     unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
-        match T::Storage::STORAGE_TYPE {
+        L::get(match T::Storage::STORAGE_TYPE {
             StorageType::Table => {
                 let table_row = *self.entity_table_rows.add(archetype_index);
                 &*self.table_components.as_ptr().add(table_row)
@@ -644,24 +656,32 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for ReadFetch<T> {
                 let entity = *self.entities.add(archetype_index);
                 &*(*self.sparse_set).get(entity).unwrap().cast::<T>()
             }
-        }
+        })
     }
 
     #[inline]
     unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item {
-        &*self.table_components.as_ptr().add(table_row)
+        L::get(&*self.table_components.as_ptr().add(table_row))
     }
 }
 
+/// Equivalent to querying with `&mut T`, but ignores the default lens. Useful with generic code
+pub struct RawMut<T: Component>(PhantomData<T>);
+
+impl<T: Component> WorldQuery for RawMut<T> {
+    type Fetch = WriteFetch<T, NoopLens<T>>;
+    type State = WriteState<T>;
+    type ReadOnlyFetch = ReadOnlyWriteFetch<T, NoopLens<T>>;
+}
+
 impl<T: Component> WorldQuery for &mut T {
-    type Fetch = WriteFetch<T>;
+    type Fetch = WriteFetch<T, T::DefaultLens>;
     type State = WriteState<T>;
-    type ReadOnlyFetch = ReadOnlyWriteFetch<T>;
+    type ReadOnlyFetch = ReadOnlyWriteFetch<T, T::DefaultLens>;
 }
 
 /// The [`Fetch`] of `&mut T`.
-#[doc(hidden)]
-pub struct WriteFetch<T> {
+pub struct WriteFetch<T, L> {
     table_components: NonNull<T>,
     table_ticks: *const UnsafeCell<ComponentTicks>,
     entities: *const Entity,
@@ -669,9 +689,10 @@ pub struct WriteFetch<T> {
     sparse_set: *const ComponentSparseSet,
     last_change_tick: u32,
     change_tick: u32,
+    lens: PhantomData<L>,
 }
 
-impl<T> Clone for WriteFetch<T> {
+impl<T, L> Clone for WriteFetch<T, L> {
     fn clone(&self) -> Self {
         Self {
             table_components: self.table_components,
@@ -681,29 +702,31 @@ impl<T> Clone for WriteFetch<T> {
             sparse_set: self.sparse_set,
             last_change_tick: self.last_change_tick,
             change_tick: self.change_tick,
+            lens: PhantomData,
         }
     }
 }
 
 /// The [`ReadOnlyFetch`] of `&mut T`.
-#[doc(hidden)]
-pub struct ReadOnlyWriteFetch<T> {
+pub struct ReadOnlyWriteFetch<T, L> {
     table_components: NonNull<T>,
     entities: *const Entity,
     entity_table_rows: *const usize,
     sparse_set: *const ComponentSparseSet,
+    lens: PhantomData<L>,
 }
 
 /// SAFETY: access is read only
-unsafe impl<T> ReadOnlyFetch for ReadOnlyWriteFetch<T> {}
+unsafe impl<T, L> ReadOnlyFetch for ReadOnlyWriteFetch<T, L> {}
 
-impl<T> Clone for ReadOnlyWriteFetch<T> {
+impl<T, L> Clone for ReadOnlyWriteFetch<T, L> {
     fn clone(&self) -> Self {
         Self {
             table_components: self.table_components,
             entities: self.entities,
             entity_table_rows: self.entity_table_rows,
             sparse_set: self.sparse_set,
+            lens: PhantomData,
         }
     }
 }
@@ -756,8 +779,8 @@ unsafe impl<T: Component> FetchState for WriteState<T> {
     }
 }
 
-impl<'w, 's, T: Component> Fetch<'w, 's> for WriteFetch<T> {
-    type Item = Mut<'w, T>;
+impl<'w, 's, T: Component, L: Lens<In = T>> Fetch<'w, 's> for WriteFetch<T, L> {
+    type Item = Mut<'w, L::Out>;
     type State = WriteState<T>;
 
     const IS_DENSE: bool = {
@@ -781,6 +804,7 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for WriteFetch<T> {
             table_ticks: ptr::null::<UnsafeCell<ComponentTicks>>(),
             last_change_tick,
             change_tick,
+            lens: PhantomData,
         };
         if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
             value.sparse_set = world
@@ -825,7 +849,7 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for WriteFetch<T> {
             StorageType::Table => {
                 let table_row = *self.entity_table_rows.add(archetype_index);
                 Mut {
-                    value: &mut *self.table_components.as_ptr().add(table_row),
+                    value: L::get_mut(&mut *self.table_components.as_ptr().add(table_row)),
                     ticks: Ticks {
                         component_ticks: &mut *(*self.table_ticks.add(table_row)).get(),
                         change_tick: self.change_tick,
@@ -838,7 +862,7 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for WriteFetch<T> {
                 let (component, component_ticks) =
                     (*self.sparse_set).get_with_ticks(entity).unwrap();
                 Mut {
-                    value: &mut *component.cast::<T>(),
+                    value: L::get_mut(&mut *component.cast::<T>()),
                     ticks: Ticks {
                         component_ticks: &mut *component_ticks,
                         change_tick: self.change_tick,
@@ -852,7 +876,7 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for WriteFetch<T> {
     #[inline]
     unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item {
         Mut {
-            value: &mut *self.table_components.as_ptr().add(table_row),
+            value: L::get_mut(&mut *self.table_components.as_ptr().add(table_row)),
             ticks: Ticks {
                 component_ticks: &mut *(*self.table_ticks.add(table_row)).get(),
                 change_tick: self.change_tick,
@@ -862,8 +886,8 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for WriteFetch<T> {
     }
 }
 
-impl<'w, 's, T: Component> Fetch<'w, 's> for ReadOnlyWriteFetch<T> {
-    type Item = &'w T;
+impl<'w, 's, T: Component, L: Lens<In = T>> Fetch<'w, 's> for ReadOnlyWriteFetch<T, L> {
+    type Item = &'w L::Out;
     type State = WriteState<T>;
 
     const IS_DENSE: bool = {
@@ -884,6 +908,7 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for ReadOnlyWriteFetch<T> {
             entities: ptr::null::<Entity>(),
             entity_table_rows: ptr::null::<usize>(),
             sparse_set: ptr::null::<ComponentSparseSet>(),
+            lens: PhantomData,
         };
         if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
             value.sparse_set = world
@@ -922,7 +947,7 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for ReadOnlyWriteFetch<T> {
 
     #[inline]
     unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
-        match T::Storage::STORAGE_TYPE {
+        L::get(match T::Storage::STORAGE_TYPE {
             StorageType::Table => {
                 let table_row = *self.entity_table_rows.add(archetype_index);
                 &*self.table_components.as_ptr().add(table_row)
@@ -931,12 +956,12 @@ impl<'w, 's, T: Component> Fetch<'w, 's> for ReadOnlyWriteFetch<T> {
                 let entity = *self.entities.add(archetype_index);
                 &*(*self.sparse_set).get(entity).unwrap().cast::<T>()
             }
-        }
+        })
     }
 
     #[inline]
     unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item {
-        &*self.table_components.as_ptr().add(table_row)
+        L::get(&*self.table_components.as_ptr().add(table_row))
     }
 }
 
diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index 528926ebd4be9..8fd722846b051 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -15,7 +15,7 @@ use bevy_ecs::{
     component::Component,
     entity::Entity,
     event::EventReader,
-    prelude::With,
+    prelude::{RawMut, With},
     query::Added,
     reflect::ReflectComponent,
     system::{Commands, ParamSet, Query, Res, ResMut},
@@ -155,7 +155,7 @@ pub fn camera_system<T: CameraProjection + Component>(
     windows: Res<Windows>,
     images: Res<Assets<Image>>,
     mut queries: ParamSet<(
-        Query<(Entity, &mut Camera, &mut T)>,
+        Query<(Entity, &mut Camera, RawMut<T>)>,
         Query<Entity, Added<Camera>>,
     )>,
 ) {
diff --git a/crates/bevy_render/src/render_component.rs b/crates/bevy_render/src/render_component.rs
index f4e901587ee8a..acaf6d79cde7d 100644
--- a/crates/bevy_render/src/render_component.rs
+++ b/crates/bevy_render/src/render_component.rs
@@ -103,7 +103,7 @@ fn prepare_uniform_components<C: Component>(
     render_device: Res<RenderDevice>,
     render_queue: Res<RenderQueue>,
     mut component_uniforms: ResMut<ComponentUniforms<C>>,
-    components: Query<(Entity, &C)>,
+    components: Query<(Entity, Raw<C>)>,
 ) where
     C: AsStd140 + Clone,
 {
diff --git a/crates/bevy_render/src/view/visibility/mod.rs b/crates/bevy_render/src/view/visibility/mod.rs
index e7cd28c78ce61..ed2cc4d026d03 100644
--- a/crates/bevy_render/src/view/visibility/mod.rs
+++ b/crates/bevy_render/src/view/visibility/mod.rs
@@ -124,7 +124,7 @@ pub fn calculate_bounds(
 }
 
 pub fn update_frusta<T: Component + CameraProjection + Send + Sync + 'static>(
-    mut views: Query<(&GlobalTransform, &T, &mut Frustum)>,
+    mut views: Query<(&GlobalTransform, Raw<T>, &mut Frustum)>,
 ) {
     for (transform, projection, mut frustum) in views.iter_mut() {
         let view_projection =
diff --git a/examples/2d/sprite_sheet.rs b/examples/2d/sprite_sheet.rs
index d3d313fab226e..97c854600de35 100644
--- a/examples/2d/sprite_sheet.rs
+++ b/examples/2d/sprite_sheet.rs
@@ -8,7 +8,8 @@ fn main() {
         .run();
 }
 
-#[derive(Component, Deref, DerefMut)]
+#[derive(Component)]
+#[component(lens)]
 struct AnimationTimer(Timer);
 
 fn animate_sprite(
diff --git a/examples/ecs/component_change_detection.rs b/examples/ecs/component_change_detection.rs
index 01473c7749bc0..c60f6477ff55c 100644
--- a/examples/ecs/component_change_detection.rs
+++ b/examples/ecs/component_change_detection.rs
@@ -13,6 +13,7 @@ fn main() {
 }
 
 #[derive(Component, Debug)]
+#[component(lens)]
 struct MyComponent(f64);
 
 fn setup(mut commands: Commands) {
@@ -24,7 +25,7 @@ fn change_component(time: Res<Time>, mut query: Query<(Entity, &mut MyComponent)
     for (entity, mut component) in query.iter_mut() {
         if rand::thread_rng().gen_bool(0.1) {
             info!("changing component {:?}", entity);
-            component.0 = time.seconds_since_startup();
+            *component = time.seconds_since_startup();
         }
     }
 }
diff --git a/examples/ecs/custom_query_param.rs b/examples/ecs/custom_query_param.rs
index 4d7bb3727116f..dde3c031c608a 100644
--- a/examples/ecs/custom_query_param.rs
+++ b/examples/ecs/custom_query_param.rs
@@ -105,7 +105,9 @@ struct NestedQuery<'w> {
 #[derive(WorldQuery)]
 #[world_query(derive(Debug))]
 struct GenericQuery<'w, T: Component, P: Component> {
-    generic: (&'w T, &'w P),
+    generic: (Raw<T>, Raw<P>),
+    #[world_query(ignore)]
+    _marker: PhantomData<&'w ()>,
 }
 
 #[derive(WorldQuery)]
diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index 99c4052a340ea..f7048ccc8cf6e 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -44,9 +44,8 @@ struct Player {
 
 // Each player also has a score. This component holds on to that score
 #[derive(Component)]
-struct Score {
-    value: usize,
-}
+#[component(lens)]
+struct Score(usize);
 
 // RESOURCES: "Global" state accessible by systems. These are also just normal Rust data types!
 //
@@ -91,15 +90,12 @@ fn score_system(mut query: Query<(&Player, &mut Score)>) {
     for (player, mut score) in query.iter_mut() {
         let scored_a_point = random::<bool>();
         if scored_a_point {
-            score.value += 1;
-            println!(
-                "{} scored a point! Their score is: {}",
-                player.name, score.value
-            );
+            score += 1;
+            println!("{} scored a point! Their score is: {}", player.name, *score);
         } else {
             println!(
                 "{} did not score a point! Their score is: {}",
-                player.name, score.value
+                player.name, *score
             );
         }
     }
@@ -115,7 +111,7 @@ fn score_check_system(
     query: Query<(&Player, &Score)>,
 ) {
     for (player, score) in query.iter() {
-        if score.value == game_rules.winning_score {
+        if *score == game_rules.winning_score {
             game_state.winning_player = Some(player.name.clone());
         }
     }
@@ -159,13 +155,13 @@ fn startup_system(mut commands: Commands, mut game_state: ResMut<GameState>) {
             Player {
                 name: "Alice".to_string(),
             },
-            Score { value: 0 },
+            Score(0),
         ),
         (
             Player {
                 name: "Bob".to_string(),
             },
-            Score { value: 0 },
+            Score(0),
         ),
     ]);
 
@@ -191,7 +187,7 @@ fn new_player_system(
             Player {
                 name: format!("Player {}", game_state.total_players),
             },
-            Score { value: 0 },
+            Score(0),
         ));
 
         println!("Player {} joined the game!", game_state.total_players);
@@ -217,7 +213,7 @@ fn exclusive_player_system(world: &mut World) {
             Player {
                 name: format!("Player {}", total_players),
             },
-            Score { value: 0 },
+            Score(0),
         ));
 
         let mut game_state = world.resource_mut::<GameState>();
@@ -243,7 +239,7 @@ struct State {
 #[allow(dead_code)]
 fn local_state_system(mut state: Local<State>, query: Query<(&Player, &Score)>) {
     for (player, score) in query.iter() {
-        println!("processed: {} {}", player.name, score.value);
+        println!("processed: {} {}", player.name, score);
     }
     println!("this system ran {} times", state.counter);
     state.counter += 1;
diff --git a/examples/ecs/generic_system.rs b/examples/ecs/generic_system.rs
index 2e3a13099989f..52b0a5449679f 100644
--- a/examples/ecs/generic_system.rs
+++ b/examples/ecs/generic_system.rs
@@ -18,9 +18,12 @@ enum AppState {
 }
 
 #[derive(Component)]
+#[component(lens)]
 struct TextToPrint(String);
 
-#[derive(Component, Deref, DerefMut)]
+#[derive(Component)]
+#[component(lens)]
+
 struct PrinterTick(bevy::prelude::Timer);
 
 #[derive(Component)]
@@ -68,7 +71,7 @@ fn setup_system(mut commands: Commands) {
 fn print_text_system(time: Res<Time>, mut query: Query<(&mut PrinterTick, &TextToPrint)>) {
     for (mut timer, text) in query.iter_mut() {
         if timer.tick(time.delta()).just_finished() {
-            info!("{}", text.0);
+            info!("{}", text);
         }
     }
 }
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index e4122f17f7cae..14132c353986c 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -32,10 +32,15 @@ const GRAVITY_CONSTANT: f32 = 0.001;
 const NUM_BODIES: usize = 100;
 
 #[derive(Component, Default)]
+#[component(lens)]
 struct Mass(f32);
+
 #[derive(Component, Default)]
+#[component(lens)]
 struct Acceleration(Vec3);
+
 #[derive(Component, Default)]
+#[component(lens)]
 struct LastPos(Vec3);
 #[derive(Component)]
 struct Star;
@@ -148,16 +153,14 @@ fn generate_bodies(
 
 fn interact_bodies(mut query: Query<(&Mass, &GlobalTransform, &mut Acceleration)>) {
     let mut iter = query.iter_combinations_mut();
-    while let Some([(Mass(m1), transform1, mut acc1), (Mass(m2), transform2, mut acc2)]) =
-        iter.fetch_next()
-    {
+    while let Some([(m1, transform1, mut acc1), (m2, transform2, mut acc2)]) = iter.fetch_next() {
         let delta = transform2.translation - transform1.translation;
         let distance_sq: f32 = delta.length_squared();
 
         let f = GRAVITY_CONSTANT / distance_sq;
         let force_unit_mass = delta * f;
-        acc1.0 += force_unit_mass * *m2;
-        acc2.0 -= force_unit_mass * *m1;
+        acc1 += force_unit_mass * *m2;
+        acc2 -= force_unit_mass * *m1;
     }
 }
 
@@ -168,9 +171,9 @@ fn integrate(mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>
         // x(t+dt) = 2x(t) - x(t-dt) + a(t)dt^2 + O(dt^4)
 
         let new_pos =
-            transform.translation + transform.translation - last_pos.0 + acceleration.0 * dt_sq;
-        acceleration.0 = Vec3::ZERO;
-        last_pos.0 = transform.translation;
+            transform.translation + transform.translation - *last_pos + *acceleration * dt_sq;
+        *acceleration = Vec3::ZERO;
+        *last_pos = transform.translation;
         transform.translation = new_pos;
     }
 }
diff --git a/examples/ecs/parallel_query.rs b/examples/ecs/parallel_query.rs
index a70eecf6d8b1a..9be74d62cb663 100644
--- a/examples/ecs/parallel_query.rs
+++ b/examples/ecs/parallel_query.rs
@@ -1,7 +1,8 @@
 use bevy::{prelude::*, tasks::prelude::*};
 use rand::random;
 
-#[derive(Component, Deref)]
+#[derive(Component)]
+#[component(lens)]
 struct Velocity(Vec2);
 
 fn spawn_system(mut commands: Commands, asset_server: Res<AssetServer>) {
@@ -58,7 +59,7 @@ fn bounce_system(
                 && transform.translation.y < top)
             {
                 // For simplicity, just reverse the velocity; don't use realistic bounces
-                v.0 = -v.0;
+                v *= -1.0;
             }
         });
 }
diff --git a/examples/ecs/system_param.rs b/examples/ecs/system_param.rs
index fdb9e5038d885..8588c47aa6074 100644
--- a/examples/ecs/system_param.rs
+++ b/examples/ecs/system_param.rs
@@ -1,4 +1,10 @@
-use bevy::{ecs::system::SystemParam, prelude::*};
+use bevy::{
+    ecs::{
+        query::{FilterFetch, WorldQuery},
+        system::SystemParam,
+    },
+    prelude::*,
+};
 
 /// This example creates a [`SystemParam`] struct that counts the number of players
 fn main() {
@@ -11,7 +17,6 @@ fn main() {
 
 #[derive(Component)]
 pub struct Player;
-#[derive(Component)]
 pub struct PlayerCount(usize);
 
 /// The [`SystemParam`] struct can contain any types that can also be included in a
@@ -24,6 +29,18 @@ struct PlayerCounter<'w, 's> {
     count: ResMut<'w, PlayerCount>,
 }
 
+#[derive(SystemParam)]
+pub struct MySystemParam<
+    'w,
+    's,
+    Q: 'static + WorldQuery + Send + Sync,
+    F: 'static + WorldQuery + Send + Sync,
+> where
+    F::Fetch: FilterFetch,
+{
+    _query: Query<'w, 's, Q, F>,
+}
+
 impl<'w, 's> PlayerCounter<'w, 's> {
     fn count(&mut self) {
         self.count.0 = self.players.iter().len();
@@ -38,7 +55,7 @@ fn spawn(mut commands: Commands) {
 }
 
 /// The [`SystemParam`] can be used directly in a system argument.
-fn count_players(mut counter: PlayerCounter) {
+fn count_players(mut counter: PlayerCounter, _p: MySystemParam<&'static Player, ()>) {
     counter.count();
 
     println!("{} players in the game", counter.count.0);
diff --git a/examples/ecs/timers.rs b/examples/ecs/timers.rs
index 4ed3767555039..a435a260d1ba4 100644
--- a/examples/ecs/timers.rs
+++ b/examples/ecs/timers.rs
@@ -10,7 +10,8 @@ fn main() {
         .run();
 }
 
-#[derive(Component, Deref, DerefMut)]
+#[derive(Component)]
+#[component(lens)]
 pub struct PrintOnCompletionTimer(Timer);
 
 pub struct Countdown {
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index d00e5200df6ad..dd176575f8cd1 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -76,7 +76,8 @@ struct Paddle;
 #[derive(Component)]
 struct Ball;
 
-#[derive(Component, Deref, DerefMut)]
+#[derive(Component)]
+#[component(lens)]
 struct Velocity(Vec2);
 
 #[derive(Component)]
diff --git a/examples/game/game_menu.rs b/examples/game/game_menu.rs
index 87613503275e7..65f01e2ddbc06 100644
--- a/examples/game/game_menu.rs
+++ b/examples/game/game_menu.rs
@@ -371,7 +371,10 @@ mod menu {
     // This system updates the settings when a new value for a setting is selected, and marks
     // the button as the one currently selected
     fn setting_button<T: Component + PartialEq + Copy>(
-        interaction_query: Query<(&Interaction, &T, Entity), (Changed<Interaction>, With<Button>)>,
+        interaction_query: Query<
+            (&Interaction, Raw<T>, Entity),
+            (Changed<Interaction>, With<Button>),
+        >,
         mut selected_query: Query<(Entity, &mut UiColor), With<SelectedOption>>,
         mut commands: Commands,
         mut setting: ResMut<T>,
diff --git a/examples/stress_tests/transform_hierarchy.rs b/examples/stress_tests/transform_hierarchy.rs
index 360f992f129f6..c033dcbab8669 100644
--- a/examples/stress_tests/transform_hierarchy.rs
+++ b/examples/stress_tests/transform_hierarchy.rs
@@ -240,13 +240,14 @@ struct UpdateFilter {
 
 /// update component with some per-component value
 #[derive(Component)]
+#[component(lens)]
 struct Update(f32);
 
 /// update positions system
 fn update(time: Res<Time>, mut query: Query<(&mut Transform, &mut Update)>) {
     for (mut t, mut u) in query.iter_mut() {
-        u.0 += time.delta_seconds() * 0.1;
-        set_translation(&mut t.translation, u.0);
+        u += time.delta_seconds() * 0.1;
+        set_translation(&mut t.translation, *u);
     }
 }