diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index b8674daf0095f..4166e00de037c 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -228,7 +228,7 @@ pub fn impl_param_set(_input: TokenStream) -> TokenStream {
                 // Conflicting params in ParamSet are not accessible at the same time
                 // ParamSets are guaranteed to not conflict with other SystemParams
                 unsafe {
-                    <#param::State as SystemParamState>::get_param(&mut self.param_states.#index, &self.system_meta, self.world, self.change_tick)
+                    <#param::State as SystemParamState<Infallible>>::get_param(&mut self.param_states.#index, &self.system_meta, self.world, self.change_tick)
                 }
             }
         });
@@ -240,7 +240,7 @@ pub fn impl_param_set(_input: TokenStream) -> TokenStream {
         let meta = &metas[0..param_count];
         let param_fn_mut = &param_fn_muts[0..param_count];
         tokens.extend(TokenStream::from(quote! {
-            impl<'w, 's, #(#param: SystemParam,)*> SystemParam for ParamSet<'w, 's, (#(#param,)*)>
+            impl<'w, 's, #(#param: SystemParam<Infallible>,)*> SystemParam<Infallible> for ParamSet<'w, 's, (#(#param,)*)>
             {
                 type State = ParamSetState<(#(#param::State,)*)>;
             }
@@ -254,9 +254,9 @@ pub fn impl_param_set(_input: TokenStream) -> TokenStream {
             // SAFETY: Relevant parameter ComponentId and ArchetypeComponentId access is applied to SystemMeta. If any ParamState conflicts
             // with any prior access, a panic will occur.
 
-            unsafe impl<#(#param_state: SystemParamState,)*> SystemParamState for ParamSetState<(#(#param_state,)*)>
+            unsafe impl<#(#param_state: SystemParamState<Infallible>,)*> SystemParamState<Infallible> for ParamSetState<(#(#param_state,)*)>
             {
-                type Item<'w, 's> = ParamSet<'w, 's, (#(<#param_state as SystemParamState>::Item::<'w, 's>,)*)>;
+                type Item<'w, 's> = ParamSet<'w, 's, (#(<#param_state as SystemParamState<Infallible>>::Item::<'w, 's>,)*)>;
 
                 fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
                     #(
@@ -305,7 +305,7 @@ pub fn impl_param_set(_input: TokenStream) -> TokenStream {
                 }
             }
 
-            impl<'w, 's, #(#param: SystemParam,)*> ParamSet<'w, 's, (#(#param,)*)>
+            impl<'w, 's, #(#param: SystemParam<Infallible>,)*> ParamSet<'w, 's, (#(#param,)*)>
             {
 
                 #(#param_fn_mut)*
@@ -322,9 +322,17 @@ struct SystemParamFieldAttributes {
 }
 
 static SYSTEM_PARAM_ATTRIBUTE_NAME: &str = "system_param";
+static FALLIBILITY_ATTRIBUTE_NAME: &str = "fallibility";
+
+#[derive(PartialEq)]
+enum Fallibility {
+    Infallible,
+    Optional,
+    Resultful,
+}
 
 /// Implement `SystemParam` to use a struct as a parameter in a system
-#[proc_macro_derive(SystemParam, attributes(system_param))]
+#[proc_macro_derive(SystemParam, attributes(fallibility, system_param))]
 pub fn derive_system_param(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
     let fields = match get_named_struct_fields(&ast.data) {
@@ -333,6 +341,66 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
     };
     let path = bevy_ecs_path();
 
+    let mut fallibility = None;
+
+    // Read struct-level attributes
+    for attr in &ast.attrs {
+        let Some(attr_ident) = attr.path.get_ident() else { continue };
+        if attr_ident == FALLIBILITY_ATTRIBUTE_NAME {
+            if fallibility.is_none() {
+                if let Ok(fallible_ident) =
+                    attr.parse_args_with(|input: ParseStream| input.parse::<Ident>())
+                {
+                    match fallible_ident.to_string().as_str() {
+                        "Infallible" => {
+                            fallibility = Some(Fallibility::Infallible);
+                        }
+                        "Optional" => {
+                            fallibility = Some(Fallibility::Optional);
+                        }
+                        "Resultful" => {
+                            fallibility = Some(Fallibility::Resultful);
+                        },
+                        _ => return syn::Error::new_spanned(
+                            attr,
+                            "The content of `fallibility` should be either `Infallible`, `Optional`, or `Resultful`."
+                        )
+                        .into_compile_error()
+                        .into()
+                    }
+                } else {
+                    return syn::Error::new_spanned(
+                        attr,
+                        "The content of `fallibility` should be a single identifier.",
+                    )
+                    .into_compile_error()
+                    .into();
+                }
+            } else {
+                return syn::Error::new_spanned(
+                    attr,
+                    "There should only be one `fallibility` attribute.",
+                )
+                .into_compile_error()
+                .into();
+            }
+        }
+    }
+
+    let fallibility = fallibility.unwrap_or(Fallibility::Infallible);
+
+    let fallible = {
+        let mut f = path.clone();
+        f.segments.push(format_ident!("system").into());
+        match fallibility {
+            Fallibility::Infallible => f.segments.push(format_ident!("Infallible").into()),
+            Fallibility::Optional => f.segments.push(format_ident!("Optional").into()),
+            Fallibility::Resultful => f.segments.push(format_ident!("Resultful").into()),
+        }
+        f
+    };
+
+    // Read field-level attributes
     let field_attributes = fields
         .iter()
         .map(|field| {
@@ -429,18 +497,54 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
     let struct_name = &ast.ident;
     let state_struct_visibility = &ast.vis;
 
+    let returned_struct = quote! {
+        #struct_name {
+            #(#fields,)*
+            #(#ignored_fields: <#ignored_field_types>::default(),)*
+        }
+    };
+
+    let (get_param_body, get_param_return) = match fallibility {
+        Fallibility::Infallible => (
+            quote! {
+                #(let #fields = <<#field_types as #path::system::SystemParam<#fallible>>::State as #path::system::SystemParamState<#fallible>>::get_param(&mut state.state.#field_indices, system_meta, world, change_tick);)*
+
+                #returned_struct
+            },
+            quote! { Self::Item<'w, 's> },
+        ),
+        Fallibility::Optional => (
+            quote! {
+                #(let Some(#fields) = <<#field_types as #path::system::SystemParam<#fallible>>::State as #path::system::SystemParamState<#fallible>>::get_param(&mut state.state.#field_indices, system_meta, world, change_tick) else {
+                    return None;
+                };)*
+
+                Some(#returned_struct)
+            },
+            quote! { Option<Self::Item<'w, 's>> },
+        ),
+        Fallibility::Resultful => (
+            quote! {
+                #(let #fields = <<#field_types as #path::system::SystemParam<#fallible>>::State as #path::system::SystemParamState<#fallible>>::get_param(&mut state.state.#field_indices, system_meta, world, change_tick)?;)*
+
+                Ok(#returned_struct)
+            },
+            quote! { Result<Self::Item<'w, 's>, &'s dyn std::error::Error> },
+        ),
+    };
+
     TokenStream::from(quote! {
         // We define the FetchState struct in an anonymous scope to avoid polluting the user namespace.
         // The struct can still be accessed via SystemParam::State, e.g. EventReaderState can be accessed via
         // <EventReader<'static, 'static, T> as SystemParam>::State
         const _: () = {
-            impl<'w, 's, #punctuated_generics> #path::system::SystemParam for #struct_name #ty_generics #where_clause {
+            impl<'w, 's, #punctuated_generics> #path::system::SystemParam<#fallible> for #struct_name #ty_generics #where_clause {
                 type State = State<'w, 's, #punctuated_generic_idents>;
             }
 
             #[doc(hidden)]
             type State<'w, 's, #punctuated_generic_idents> = FetchState<
-                (#(<#field_types as #path::system::SystemParam>::State,)*),
+                (#(<#field_types as #path::system::SystemParam<#fallible>>::State,)*),
                 #punctuated_generic_idents
             >;
 
@@ -450,7 +554,7 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
                 marker: std::marker::PhantomData<fn()->(#punctuated_generic_idents)>
             }
 
-            unsafe impl<'__w, '__s, #punctuated_generics> #path::system::SystemParamState for
+            unsafe impl<'__w, '__s, #punctuated_generics> #path::system::SystemParamState<#fallible> for
                 State<'__w, '__s, #punctuated_generic_idents>
             #where_clause {
                 type Item<'w, 's> = #struct_name #ty_generics;
@@ -467,7 +571,7 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
                 }
 
                 fn apply(&mut self, system_meta: &#path::system::SystemMeta, world: &mut #path::world::World) {
-                    self.state.apply(system_meta, world)
+                    #path::system::SystemParamState::apply(&mut self.state, system_meta, world)
                 }
 
                 unsafe fn get_param<'w, 's>(
@@ -475,11 +579,8 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
                     system_meta: &#path::system::SystemMeta,
                     world: &'w #path::world::World,
                     change_tick: u32,
-                ) -> Self::Item<'w, 's> {
-                    #struct_name {
-                        #(#fields: <<#field_types as #path::system::SystemParam>::State as #path::system::SystemParamState>::get_param(&mut state.state.#field_indices, system_meta, world, change_tick),)*
-                        #(#ignored_fields: <#ignored_field_types>::default(),)*
-                    }
+                ) -> #get_param_return {
+                    #get_param_body
                 }
             }
 
diff --git a/crates/bevy_ecs/src/system/commands/parallel_scope.rs b/crates/bevy_ecs/src/system/commands/parallel_scope.rs
index 72c8118aa5152..2f0d71efc9cf1 100644
--- a/crates/bevy_ecs/src/system/commands/parallel_scope.rs
+++ b/crates/bevy_ecs/src/system/commands/parallel_scope.rs
@@ -5,7 +5,7 @@ use thread_local::ThreadLocal;
 use crate::{
     entity::Entities,
     prelude::World,
-    system::{SystemMeta, SystemParam, SystemParamState},
+    system::{Infallible, SystemMeta, SystemParam, SystemParamState},
 };
 
 use super::{CommandQueue, Commands};
@@ -48,12 +48,12 @@ pub struct ParallelCommands<'w, 's> {
     entities: &'w Entities,
 }
 
-impl SystemParam for ParallelCommands<'_, '_> {
+impl SystemParam<Infallible> for ParallelCommands<'_, '_> {
     type State = ParallelCommandsState;
 }
 
 // SAFETY: no component or resource access to report
-unsafe impl SystemParamState for ParallelCommandsState {
+unsafe impl SystemParamState<Infallible> for ParallelCommandsState {
     type Item<'w, 's> = ParallelCommands<'w, 's>;
 
     fn init(_: &mut World, _: &mut crate::system::SystemMeta) -> Self {
diff --git a/crates/bevy_ecs/src/system/exclusive_system_param.rs b/crates/bevy_ecs/src/system/exclusive_system_param.rs
index 6c52738901254..f7babfa7b9185 100644
--- a/crates/bevy_ecs/src/system/exclusive_system_param.rs
+++ b/crates/bevy_ecs/src/system/exclusive_system_param.rs
@@ -1,7 +1,7 @@
 use crate::{
     prelude::{FromWorld, QueryState},
     query::{ReadOnlyWorldQuery, WorldQuery},
-    system::{Local, LocalState, SystemMeta, SystemParam, SystemState},
+    system::{Infallible, Local, LocalState, SystemMeta, SystemParam, SystemState},
     world::World,
 };
 use bevy_ecs_macros::all_tuples;
@@ -45,11 +45,11 @@ impl<Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> ExclusiveSystemPa
     }
 }
 
-impl<'a, P: SystemParam + 'static> ExclusiveSystemParam for &'a mut SystemState<P> {
+impl<'a, P: SystemParam<Infallible> + 'static> ExclusiveSystemParam for &'a mut SystemState<P> {
     type State = SystemState<P>;
 }
 
-impl<P: SystemParam> ExclusiveSystemParamState for SystemState<P> {
+impl<P: SystemParam<Infallible>> ExclusiveSystemParamState for SystemState<P> {
     type Item<'s> = &'s mut SystemState<P>;
 
     fn init(world: &mut World, _system_meta: &mut SystemMeta) -> Self {
diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 2cc88f9e30b77..2c8602c31ba4a 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -6,8 +6,8 @@ use crate::{
     query::{Access, FilteredAccessSet},
     schedule::{SystemLabel, SystemLabelId},
     system::{
-        check_system_change_tick, ReadOnlySystemParam, System, SystemParam, SystemParamItem,
-        SystemParamState,
+        check_system_change_tick, Infallible, ReadOnlySystemParam, System, SystemParam,
+        SystemParamItem, SystemParamState,
     },
     world::{World, WorldId},
 };
@@ -139,18 +139,18 @@ impl SystemMeta {
 ///     };
 /// });
 /// ```
-pub struct SystemState<Param: SystemParam + 'static> {
+pub struct SystemState<Param: SystemParam<Infallible> + 'static> {
     meta: SystemMeta,
-    param_state: <Param as SystemParam>::State,
+    param_state: <Param as SystemParam<Infallible>>::State,
     world_id: WorldId,
     archetype_generation: ArchetypeGeneration,
 }
 
-impl<Param: SystemParam> SystemState<Param> {
+impl<Param: SystemParam<Infallible>> SystemState<Param> {
     pub fn new(world: &mut World) -> Self {
         let mut meta = SystemMeta::new::<Param>();
         meta.last_change_tick = world.change_tick().wrapping_sub(MAX_CHANGE_AGE);
-        let param_state = <Param::State as SystemParamState>::init(world, &mut meta);
+        let param_state = <Param::State as SystemParamState<Infallible>>::init(world, &mut meta);
         Self {
             meta,
             param_state,
@@ -223,7 +223,7 @@ impl<Param: SystemParam> SystemState<Param> {
         world: &'w World,
     ) -> SystemParamItem<'w, 's, Param> {
         let change_tick = world.increment_change_tick();
-        let param = <Param::State as SystemParamState>::get_param(
+        let param = <Param::State as SystemParamState<Infallible>>::get_param(
             &mut self.param_state,
             &self.meta,
             world,
@@ -234,7 +234,7 @@ impl<Param: SystemParam> SystemState<Param> {
     }
 }
 
-impl<Param: SystemParam> FromWorld for SystemState<Param> {
+impl<Param: SystemParam<Infallible>> FromWorld for SystemState<Param> {
     fn from_world(world: &mut World) -> Self {
         Self::new(world)
     }
@@ -312,7 +312,7 @@ pub struct InputMarker;
 /// [`FunctionSystem`] must be `.initialized` before they can be run.
 pub struct FunctionSystem<In, Out, Param, Marker, F>
 where
-    Param: SystemParam,
+    Param: SystemParam<Infallible>,
 {
     func: F,
     param_state: Option<Param::State>,
@@ -329,7 +329,7 @@ impl<In, Out, Param, Marker, F> IntoSystem<In, Out, (IsFunctionSystem, Param, Ma
 where
     In: 'static,
     Out: 'static,
-    Param: SystemParam + 'static,
+    Param: SystemParam<Infallible> + 'static,
     Marker: 'static,
     F: SystemParamFunction<In, Out, Param, Marker> + Send + Sync + 'static,
 {
@@ -348,7 +348,7 @@ where
 
 impl<In, Out, Param, Marker, F> FunctionSystem<In, Out, Param, Marker, F>
 where
-    Param: SystemParam,
+    Param: SystemParam<Infallible>,
 {
     /// Message shown when a system isn't initialised
     // When lines get too long, rustfmt can sometimes refuse to format them.
@@ -360,7 +360,7 @@ impl<In, Out, Param, Marker, F> System for FunctionSystem<In, Out, Param, Marker
 where
     In: 'static,
     Out: 'static,
-    Param: SystemParam + 'static,
+    Param: SystemParam<Infallible> + 'static,
     Marker: 'static,
     F: SystemParamFunction<In, Out, Param, Marker> + Send + Sync + 'static,
 {
@@ -400,7 +400,7 @@ where
         // We update the archetype component access correctly based on `Param`'s requirements
         // in `update_archetype_component_access`.
         // Our caller upholds the requirements.
-        let params = <Param as SystemParam>::State::get_param(
+        let params = <Param as SystemParam<Infallible>>::State::get_param(
             self.param_state.as_mut().expect(Self::PARAM_MESSAGE),
             &self.system_meta,
             world,
@@ -429,7 +429,7 @@ where
     fn initialize(&mut self, world: &mut World) {
         self.world_id = Some(world.id());
         self.system_meta.last_change_tick = world.change_tick().wrapping_sub(MAX_CHANGE_AGE);
-        self.param_state = Some(<Param::State as SystemParamState>::init(
+        self.param_state = Some(<Param::State as SystemParamState<Infallible>>::init(
             world,
             &mut self.system_meta,
         ));
@@ -505,7 +505,7 @@ impl<T> Copy for SystemTypeIdLabel<T> {}
 /// use std::num::ParseIntError;
 ///
 /// use bevy_ecs::prelude::*;
-/// use bevy_ecs::system::{SystemParam, SystemParamItem};
+/// use bevy_ecs::system::{Infallible, SystemParam, SystemParamItem};
 ///
 /// // Unfortunately, we need all of these generics. `A` is the first system, with its
 /// // parameters and marker type required for coherence. `B` is the second system, and
@@ -519,8 +519,8 @@ impl<T> Copy for SystemTypeIdLabel<T> {}
 ///     // We need A and B to be systems, add those bounds
 ///     A: SystemParamFunction<AIn, Shared, AParam, AMarker>,
 ///     B: SystemParamFunction<Shared, BOut, BParam, BMarker>,
-///     AParam: SystemParam,
-///     BParam: SystemParam,
+///     AParam: SystemParam<Infallible>,
+///     BParam: SystemParam<Infallible>,
 /// {
 ///     // The type of `params` is inferred based on the return of this function above
 ///     move |In(a_in), mut params| {
@@ -553,14 +553,16 @@ impl<T> Copy for SystemTypeIdLabel<T> {}
 /// ```
 /// [`PipeSystem`]: crate::system::PipeSystem
 /// [`ParamSet`]: crate::system::ParamSet
-pub trait SystemParamFunction<In, Out, Param: SystemParam, Marker>: Send + Sync + 'static {
+pub trait SystemParamFunction<In, Out, Param: SystemParam<Infallible>, Marker>:
+    Send + Sync + 'static
+{
     fn run(&mut self, input: In, param_value: SystemParamItem<Param>) -> Out;
 }
 
 macro_rules! impl_system_function {
     ($($param: ident),*) => {
         #[allow(non_snake_case)]
-        impl<Out, Func: Send + Sync + 'static, $($param: SystemParam),*> SystemParamFunction<(), Out, ($($param,)*), ()> for Func
+        impl<Out, Func: Send + Sync + 'static, $($param: SystemParam<Infallible>),*> SystemParamFunction<(), Out, ($($param,)*), ()> for Func
         where
         for <'a> &'a mut Func:
                 FnMut($($param),*) -> Out +
@@ -584,7 +586,7 @@ macro_rules! impl_system_function {
         }
 
         #[allow(non_snake_case)]
-        impl<Input, Out, Func: Send + Sync + 'static, $($param: SystemParam),*> SystemParamFunction<Input, Out, ($($param,)*), InputMarker> for Func
+        impl<Input, Out, Func: Send + Sync + 'static, $($param: SystemParam<Infallible>),*> SystemParamFunction<Input, Out, ($($param,)*), InputMarker> for Func
         where
         for <'a> &'a mut Func:
                 FnMut(In<Input>, $($param),*) -> Out +
@@ -617,8 +619,13 @@ pub trait AsSystemLabel<Marker> {
     fn as_system_label(&self) -> SystemLabelId;
 }
 
-impl<In, Out, Param: SystemParam, Marker, T: SystemParamFunction<In, Out, Param, Marker>>
-    AsSystemLabel<(In, Out, Param, Marker)> for T
+impl<
+        In,
+        Out,
+        Param: SystemParam<Infallible>,
+        Marker,
+        T: SystemParamFunction<In, Out, Param, Marker>,
+    > AsSystemLabel<(In, Out, Param, Marker)> for T
 {
     #[inline]
     fn as_system_label(&self) -> SystemLabelId {
diff --git a/crates/bevy_ecs/src/system/system_param.rs b/crates/bevy_ecs/src/system/system_param.rs
index 63f356c4b592c..42c60017cedca 100644
--- a/crates/bevy_ecs/src/system/system_param.rs
+++ b/crates/bevy_ecs/src/system/system_param.rs
@@ -18,13 +18,249 @@ use bevy_ptr::UnsafeCellDeref;
 use bevy_utils::synccell::SyncCell;
 use std::{
     borrow::Cow,
+    error::Error,
     fmt::Debug,
     marker::PhantomData,
     ops::{Deref, DerefMut},
 };
 
+/// A [`SystemParam`] that can be used as `T`.
+///
+/// `SystemParam<Infallible>` is best implemented for parameters that can't fail.
+///
+/// # Example
+///
+/// ```
+/// # use bevy_ecs::prelude::*;
+/// use bevy_ecs::system::{
+///     Infallible, ResState, SystemMeta,
+///     SystemParam, SystemParamState,
+/// };
+/// # #[derive(Resource)]
+/// # struct SomeResource {
+/// #   value: u32,
+/// # }
+///
+/// #[derive(Debug)]
+/// struct MyParam<'w> {
+///     value: &'w u32,
+/// }
+///
+/// impl<'w> SystemParam<Infallible> for MyParam<'w> {
+///     type State = MyParamState;
+/// }
+///
+/// struct MyParamState {
+///     res_state: ResState<SomeResource>,
+/// }
+///
+/// unsafe impl SystemParamState<Infallible> for MyParamState {
+///     fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
+///         Self {
+///             res_state: <ResState<SomeResource> as SystemParamState<Infallible>>::init(world, system_meta),
+///         }
+///     }
+///
+///     type Item<'w, 's> = MyParam<'w>;
+///
+///     #[inline]
+///     unsafe fn get_param<'w, 's>(
+///         state: &'s mut Self,
+///         system_meta: &SystemMeta,
+///         world: &'w World,
+///         change_tick: u32,
+///     ) -> Self::Item<'w, 's> {
+///         let some_res = <<Res<SomeResource> as SystemParam<Infallible>>::State as SystemParamState<Infallible>>::get_param(
+///             &mut state.res_state,
+///             system_meta,
+///             world,
+///             change_tick,
+///         );
+///         let r = some_res.into_inner();
+///         MyParam {
+///             value: &r.value,
+///         }
+///     }
+/// }
+/// ```
+pub struct Infallible;
+
+/// A [`SystemParam`] that can be used as `Option<T>` and `T`.
+///
+/// `SystemParam<Optional>` is best implemented for parameters that have a single point of failure.
+///
+/// By implementing `SystemParam<Optional>`, `SystemParam<Infallible>` is implemented for `Option<T>` and `T`.
+///
+/// # Example
+///
+/// ```
+/// # use bevy_ecs::prelude::*;
+/// use bevy_ecs::system::{
+///     Infallible, Optional, OptionState, ResState, SystemMeta,
+///     SystemParam, SystemParamState,
+/// };
+/// # #[derive(Resource)]
+/// # struct SomeResource {
+/// #   value: u32,
+/// # }
+///
+/// #[derive(Debug)]
+/// struct MyParam<'w> {
+///     value: &'w u32,
+/// }
+///
+/// impl<'w> SystemParam<Optional> for MyParam<'w> {
+///     type State = MyParamState;
+/// }
+///
+/// struct MyParamState {
+///     res_state: OptionState<ResState<SomeResource>>,
+/// }
+///
+/// unsafe impl SystemParamState<Optional> for MyParamState {
+///     fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
+///         Self {
+///             res_state: OptionState::init(world, system_meta),
+///         }
+///     }
+///     
+///     type Item<'w, 's> = MyParam<'w>;
+///     
+///     #[inline]
+///     unsafe fn get_param<'w, 's>(
+///         state: &'s mut Self,
+///         system_meta: &SystemMeta,
+///         world: &'w World,
+///         change_tick: u32,
+///     ) -> Option<Self::Item<'w, 's>> {
+///         let some_res = <<Option<Res<SomeResource>> as SystemParam<Infallible>>::State as SystemParamState<Infallible>>::get_param(
+///             &mut state.res_state,
+///             system_meta,
+///             world,
+///             change_tick,
+///         );
+///         some_res.map(|r| {
+///             let r = r.into_inner();
+///             MyParam {
+///                 value: &r.value,
+///             }
+///         })
+///     }
+/// }
+/// ```
+pub struct Optional;
+
+/// A [`SystemParam`] that can be used as `Result<T, &dyn Error>`, `Option<T>`, and `T`.
+///
+/// `SystemParam<Resultful>` is best implemented for parameters that have multiple points of failure.
+///
+/// By implementing `SystemParam<Resultful>`, `SystemParam<Optional>` is implemented for `T` and `SystemParam<Infallible>` is implemented for `Result<T, &dyn Error>`.
+///
+/// # Example
+///
+/// ```
+/// # use bevy_ecs::prelude::*;
+/// use bevy_ecs::system::{
+///     Infallible, Resultful, OptionState, ResState, SystemMeta,
+///     SystemParam, SystemParamState,
+/// };
+/// use std::error::Error;
+/// # #[derive(Resource)]
+/// # struct SomeResource {
+/// #   value: u32,
+/// # }
+///
+/// #[derive(Debug)]
+/// struct MyParam<'w> {
+///     value: &'w u32,
+/// }
+///
+/// impl<'w> SystemParam<Resultful> for MyParam<'w> {
+///     type State = MyParamState;
+/// }
+///
+/// struct MyParamState {
+///     res_state: OptionState<ResState<SomeResource>>,
+/// }
+///
+/// unsafe impl SystemParamState<Resultful> for MyParamState {
+///     fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
+///         Self {
+///             res_state: OptionState::init(world, system_meta),
+///         }
+///     }
+///     
+///     type Item<'w, 's> = MyParam<'w>;
+///     
+///     #[inline]
+///     unsafe fn get_param<'w, 's>(
+///         state: &'s mut Self,
+///         system_meta: &SystemMeta,
+///         world: &'w World,
+///         change_tick: u32,
+///     ) -> Result<Self::Item<'w, 's>, &'s dyn Error> {
+///         // Since `Res<T>` doesn't implement `SystemParam<Resultful>`, we have to use `Option<Res<T>>` and map it to a result.
+///         let some_res = <<Option<Res<SomeResource>> as SystemParam<Infallible>>::State as SystemParamState<Infallible>>::get_param(
+///             &mut state.res_state,
+///             system_meta,
+///             world,
+///             change_tick,
+///         );
+///         
+///         match some_res {
+///             Some(r) => {
+///                 let r = r.into_inner();
+///                 Ok(MyParam {
+///                     value: &r.value,
+///                 })
+///             }
+///             None => {
+///                 Err(&MyError(45))
+///             }
+///         }
+///     }
+/// }
+///
+/// #[derive(Debug)]
+/// struct MyError(u32);
+///
+/// impl std::fmt::Display for MyError {
+///     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+///         write!(f, "MyError has {}!", self.0)
+///     }
+/// }
+///
+/// impl Error for MyError {}
+/// ```
+pub struct Resultful;
+
+mod sealed {
+    use std::error::Error;
+
+    /// Describes a [`SystemParam`](super::SystemParam)'s level of fallibility.
+    pub trait Fallibility {
+        /// Maps `T` to some form of error-handling.
+        type Fallible<'s, T>;
+    }
+    impl Fallibility for super::Infallible {
+        type Fallible<'s, T> = T;
+    }
+    impl Fallibility for super::Optional {
+        type Fallible<'s, T> = Option<T>;
+    }
+    impl Fallibility for super::Resultful {
+        type Fallible<'s, T> = Result<T, &'s dyn Error>;
+    }
+}
+
 /// A parameter that can be used in a [`System`](super::System).
 ///
+/// This trait comes in three variants, where [`Infallible`] is the base variant:
+///
+/// - [`Infallible`]: Which can be used as `T`.
+/// - [`Optional`]: Which can be used as `Option<T>` or `T`.
+/// - [`Resultful`]: Which can be used as `Result<T, &dyn Error>`, `Option<T>`, or `T`.
+///
 /// # Derive
 ///
 /// This trait can be derived with the [`derive@super::SystemParam`] macro.
@@ -38,6 +274,11 @@ use std::{
 ///
 /// ## Attributes
 ///
+/// `#[fallibility(T)]`:
+/// Can be added to the struct. `T` can be one of [`Infallible`], [`Optional`], or [`Resultful`].
+/// This requires the fields to have the same fallibility.
+/// If the attribute is not specified, the fallibility defaults to [`Infallible`].
+///
 /// `#[system_param(ignore)]`:
 /// Can be added to any field in the struct. Fields decorated with this attribute
 /// will be created with the default value upon realisation.
@@ -53,6 +294,7 @@ use std::{
 /// use bevy_ecs::system::SystemParam;
 ///
 /// #[derive(SystemParam)]
+/// #[fallibility(Optional)]
 /// struct MyParam<'w, Marker: 'static> {
 ///     foo: Res<'w, SomeResource>,
 ///     #[system_param(ignore)]
@@ -121,11 +363,143 @@ use std::{
 ///
 /// [`SyncCell`]: bevy_utils::synccell::SyncCell
 /// [`Exclusive`]: https://doc.rust-lang.org/nightly/std/sync/struct.Exclusive.html
-pub trait SystemParam: Sized {
-    type State: SystemParamState;
+pub trait SystemParam<T: sealed::Fallibility>: Sized {
+    type State: SystemParamState<T>;
+}
+
+impl<T: SystemParam<Optional>> SystemParam<Infallible> for T {
+    type State = T::State;
+}
+
+// SAFETY: `SystemParamState<Optional>` must be safely implemented.
+unsafe impl<T: SystemParamState<Optional>> SystemParamState<Infallible> for T {
+    fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
+        T::init(world, system_meta)
+    }
+    #[inline]
+    fn new_archetype(&mut self, archetype: &Archetype, system_meta: &mut SystemMeta) {
+        self.new_archetype(archetype, system_meta);
+    }
+    #[inline]
+    fn apply(&mut self, system_meta: &SystemMeta, world: &mut World) {
+        self.apply(system_meta, world);
+    }
+
+    type Item<'world, 'state> = T::Item<'world, 'state>;
+
+    unsafe fn get_param<'world, 'state>(
+        state: &'state mut Self,
+        system_meta: &SystemMeta,
+        world: &'world World,
+        change_tick: u32,
+    ) -> Self::Item<'world, 'state> {
+        T::get_param(state, system_meta, world, change_tick).unwrap_or_else(|| {
+            panic!(
+                "Failed to get system param `{}`",
+                std::any::type_name::<T::Item<'world, 'state>>()
+            )
+        })
+    }
+}
+
+impl<T: SystemParam<Optional>> SystemParam<Infallible> for Option<T> {
+    type State = OptionState<T::State>;
+}
+
+#[doc(hidden)]
+pub struct OptionState<T: SystemParamState<Optional>>(T);
+
+// SAFETY: `SystemParamState<Optional>` must be safely implemented.
+unsafe impl<T: SystemParamState<Optional>> SystemParamState<Infallible> for OptionState<T> {
+    fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
+        Self(T::init(world, system_meta))
+    }
+    #[inline]
+    fn new_archetype(&mut self, archetype: &Archetype, system_meta: &mut SystemMeta) {
+        self.0.new_archetype(archetype, system_meta);
+    }
+    #[inline]
+    fn apply(&mut self, system_meta: &SystemMeta, world: &mut World) {
+        self.0.apply(system_meta, world);
+    }
+
+    type Item<'world, 'state> = Option<T::Item<'world, 'state>>;
+
+    unsafe fn get_param<'world, 'state>(
+        state: &'state mut Self,
+        system_meta: &SystemMeta,
+        world: &'world World,
+        change_tick: u32,
+    ) -> Self::Item<'world, 'state> {
+        T::get_param(&mut state.0, system_meta, world, change_tick)
+    }
 }
 
-pub type SystemParamItem<'w, 's, P> = <<P as SystemParam>::State as SystemParamState>::Item<'w, 's>;
+impl<T: SystemParam<Resultful>> SystemParam<Optional> for T {
+    type State = T::State;
+}
+
+// SAFETY: `SystemParamState<Resultful>` must be safely implemented.
+unsafe impl<T: SystemParamState<Resultful>> SystemParamState<Optional> for T {
+    fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
+        T::init(world, system_meta)
+    }
+    #[inline]
+    fn new_archetype(&mut self, archetype: &Archetype, system_meta: &mut SystemMeta) {
+        self.new_archetype(archetype, system_meta);
+    }
+    #[inline]
+    fn apply(&mut self, system_meta: &SystemMeta, world: &mut World) {
+        self.apply(system_meta, world);
+    }
+
+    type Item<'world, 'state> = T::Item<'world, 'state>;
+
+    unsafe fn get_param<'world, 'state>(
+        state: &'state mut Self,
+        system_meta: &SystemMeta,
+        world: &'world World,
+        change_tick: u32,
+    ) -> Option<Self::Item<'world, 'state>> {
+        T::get_param(state, system_meta, world, change_tick).ok()
+    }
+}
+
+impl<'s, T: SystemParam<Resultful>> SystemParam<Infallible> for Result<T, &'s dyn Error> {
+    type State = ResultState<T::State>;
+}
+
+#[doc(hidden)]
+pub struct ResultState<T: SystemParamState<Resultful>>(T);
+
+// SAFETY: `SystemParamState<Resultful>` must be safely implemented.
+unsafe impl<T: SystemParamState<Resultful>> SystemParamState<Infallible> for ResultState<T> {
+    fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
+        Self(T::init(world, system_meta))
+    }
+    #[inline]
+    fn new_archetype(&mut self, archetype: &Archetype, system_meta: &mut SystemMeta) {
+        self.0.new_archetype(archetype, system_meta);
+    }
+    #[inline]
+    fn apply(&mut self, system_meta: &SystemMeta, world: &mut World) {
+        self.0.apply(system_meta, world);
+    }
+
+    type Item<'world, 'state> = Result<T::Item<'world, 'state>, &'state dyn Error>;
+
+    unsafe fn get_param<'world, 'state>(
+        state: &'state mut Self,
+        system_meta: &SystemMeta,
+        world: &'world World,
+        change_tick: u32,
+    ) -> Self::Item<'world, 'state> {
+        T::get_param(&mut state.0, system_meta, world, change_tick)
+    }
+}
+
+pub type SystemParamItem<'w, 's, P> =
+    <<P as SystemParam<Infallible>>::State as SystemParamState<Infallible>>::Item<'w, 's>;
 
 /// The state of a [`SystemParam`].
 ///
@@ -135,7 +509,7 @@ pub type SystemParamItem<'w, 's, P> = <<P as SystemParam>::State as SystemParamS
 /// [`World`] access used by the [`SystemParamState`].
 /// Additionally, it is the implementor's responsibility to ensure there is no
 /// conflicting access across all [`SystemParam`]'s.
-pub unsafe trait SystemParamState: Send + Sync + 'static {
+pub unsafe trait SystemParamState<T: sealed::Fallibility>: Send + Sync + 'static {
     fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self;
     #[inline]
     fn new_archetype(&mut self, _archetype: &Archetype, _system_meta: &mut SystemMeta) {}
@@ -143,7 +517,7 @@ pub unsafe trait SystemParamState: Send + Sync + 'static {
     #[allow(unused_variables)]
     fn apply(&mut self, system_meta: &SystemMeta, _world: &mut World) {}
 
-    type Item<'world, 'state>: SystemParam<State = Self>;
+    type Item<'world, 'state>: SystemParam<T, State = Self>;
     /// # Safety
     ///
     /// This call might access any of the input parameters in an unsafe way. Make sure the data
@@ -153,16 +527,16 @@ pub unsafe trait SystemParamState: Send + Sync + 'static {
         system_meta: &SystemMeta,
         world: &'world World,
         change_tick: u32,
-    ) -> Self::Item<'world, 'state>;
+    ) -> T::Fallible<'state, Self::Item<'world, 'state>>;
 }
 
 /// A [`SystemParam`] that only reads a given [`World`].
 ///
 /// # Safety
 /// This must only be implemented for [`SystemParam`] impls that exclusively read the World passed in to [`SystemParamState::get_param`]
-pub unsafe trait ReadOnlySystemParam: SystemParam {}
+pub unsafe trait ReadOnlySystemParam: SystemParam<Infallible> {}
 
-impl<'w, 's, Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> SystemParam
+impl<'w, 's, Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> SystemParam<Infallible>
     for Query<'w, 's, Q, F>
 {
     type State = QueryState<Q, F>;
@@ -176,7 +550,7 @@ unsafe impl<'w, 's, Q: ReadOnlyWorldQuery + 'static, F: ReadOnlyWorldQuery + 'st
 
 // SAFETY: Relevant query ComponentId and ArchetypeComponentId access is applied to SystemMeta. If
 // this QueryState conflicts with any prior access, a panic will occur.
-unsafe impl<Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> SystemParamState
+unsafe impl<Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> SystemParamState<Infallible>
     for QueryState<Q, F>
 {
     type Item<'w, 's> = Query<'w, 's, Q, F>;
@@ -239,14 +613,14 @@ fn assert_component_access_compatibility(
            query_type, filter_type, system_name, accesses);
 }
 
-pub struct ParamSet<'w, 's, T: SystemParam> {
+pub struct ParamSet<'w, 's, T: SystemParam<Infallible>> {
     param_states: &'s mut T::State,
     world: &'w World,
     system_meta: SystemMeta,
     change_tick: u32,
 }
 /// The [`SystemParamState`] of [`ParamSet<T::Item>`].
-pub struct ParamSetState<T: SystemParamState>(T);
+pub struct ParamSetState<T: SystemParamState<Infallible>>(T);
 
 impl_param_set!();
 
@@ -390,13 +764,13 @@ pub struct ResState<T> {
     marker: PhantomData<T>,
 }
 
-impl<'a, T: Resource> SystemParam for Res<'a, T> {
+impl<'a, T: Resource> SystemParam<Optional> for Res<'a, T> {
     type State = ResState<T>;
 }
 
 // SAFETY: Res ComponentId and ArchetypeComponentId access is applied to SystemMeta. If this Res
 // conflicts with any prior access, a panic will occur.
-unsafe impl<T: Resource> SystemParamState for ResState<T> {
+unsafe impl<T: Resource> SystemParamState<Optional> for ResState<T> {
     type Item<'w, 's> = Res<'w, T>;
 
     fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
@@ -430,56 +804,9 @@ unsafe impl<T: Resource> SystemParamState for ResState<T> {
         system_meta: &SystemMeta,
         world: &'w World,
         change_tick: u32,
-    ) -> Self::Item<'w, 's> {
-        let (ptr, ticks) = world
-            .get_resource_with_ticks(state.component_id)
-            .unwrap_or_else(|| {
-                panic!(
-                    "Resource requested by {} does not exist: {}",
-                    system_meta.name,
-                    std::any::type_name::<T>()
-                )
-            });
-        Res {
-            value: ptr.deref(),
-            added: ticks.added.deref(),
-            changed: ticks.changed.deref(),
-            last_change_tick: system_meta.last_change_tick,
-            change_tick,
-        }
-    }
-}
-
-/// The [`SystemParamState`] of [`Option<Res<T>>`].
-/// See: [`Res<T>`]
-#[doc(hidden)]
-pub struct OptionResState<T>(ResState<T>);
-
-impl<'a, T: Resource> SystemParam for Option<Res<'a, T>> {
-    type State = OptionResState<T>;
-}
-
-// SAFETY: Only reads a single World resource
-unsafe impl<'a, T: Resource> ReadOnlySystemParam for Option<Res<'a, T>> {}
-
-// SAFETY: this impl defers to `ResState`, which initializes
-// and validates the correct world access
-unsafe impl<T: Resource> SystemParamState for OptionResState<T> {
-    type Item<'w, 's> = Option<Res<'w, T>>;
-
-    fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
-        Self(ResState::init(world, system_meta))
-    }
-
-    #[inline]
-    unsafe fn get_param<'w, 's>(
-        state: &'s mut Self,
-        system_meta: &SystemMeta,
-        world: &'w World,
-        change_tick: u32,
-    ) -> Self::Item<'w, 's> {
+    ) -> Option<Self::Item<'w, 's>> {
         world
-            .get_resource_with_ticks(state.0.component_id)
+            .get_resource_with_ticks(state.component_id)
             .map(|(ptr, ticks)| Res {
                 value: ptr.deref(),
                 added: ticks.added.deref(),
@@ -497,13 +824,13 @@ pub struct ResMutState<T> {
     marker: PhantomData<T>,
 }
 
-impl<'a, T: Resource> SystemParam for ResMut<'a, T> {
+impl<'a, T: Resource> SystemParam<Optional> for ResMut<'a, T> {
     type State = ResMutState<T>;
 }
 
 // SAFETY: Res ComponentId and ArchetypeComponentId access is applied to SystemMeta. If this Res
 // conflicts with any prior access, a panic will occur.
-unsafe impl<T: Resource> SystemParamState for ResMutState<T> {
+unsafe impl<T: Resource> SystemParamState<Optional> for ResMutState<T> {
     type Item<'w, 's> = ResMut<'w, T>;
 
     fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
@@ -540,55 +867,9 @@ unsafe impl<T: Resource> SystemParamState for ResMutState<T> {
         system_meta: &SystemMeta,
         world: &'w World,
         change_tick: u32,
-    ) -> Self::Item<'w, 's> {
-        let value = world
-            .get_resource_unchecked_mut_with_id(state.component_id)
-            .unwrap_or_else(|| {
-                panic!(
-                    "Resource requested by {} does not exist: {}",
-                    system_meta.name,
-                    std::any::type_name::<T>()
-                )
-            });
-        ResMut {
-            value: value.value,
-            ticks: Ticks {
-                added: value.ticks.added,
-                changed: value.ticks.changed,
-                last_change_tick: system_meta.last_change_tick,
-                change_tick,
-            },
-        }
-    }
-}
-
-/// The [`SystemParamState`] of [`Option<ResMut<T>>`].
-/// See: [`ResMut<T>`]
-#[doc(hidden)]
-pub struct OptionResMutState<T>(ResMutState<T>);
-
-impl<'a, T: Resource> SystemParam for Option<ResMut<'a, T>> {
-    type State = OptionResMutState<T>;
-}
-
-// SAFETY: this impl defers to `ResMutState`, which initializes
-// and validates the correct world access
-unsafe impl<T: Resource> SystemParamState for OptionResMutState<T> {
-    type Item<'w, 's> = Option<ResMut<'w, T>>;
-
-    fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
-        Self(ResMutState::init(world, system_meta))
-    }
-
-    #[inline]
-    unsafe fn get_param<'w, 's>(
-        state: &'s mut Self,
-        system_meta: &SystemMeta,
-        world: &'w World,
-        change_tick: u32,
-    ) -> Self::Item<'w, 's> {
+    ) -> Option<Self::Item<'w, 's>> {
         world
-            .get_resource_unchecked_mut_with_id(state.0.component_id)
+            .get_resource_unchecked_mut_with_id(state.component_id)
             .map(|value| ResMut {
                 value: value.value,
                 ticks: Ticks {
@@ -601,7 +882,7 @@ unsafe impl<T: Resource> SystemParamState for OptionResMutState<T> {
     }
 }
 
-impl<'w, 's> SystemParam for Commands<'w, 's> {
+impl<'w, 's> SystemParam<Infallible> for Commands<'w, 's> {
     type State = CommandQueue;
 }
 
@@ -609,7 +890,7 @@ impl<'w, 's> SystemParam for Commands<'w, 's> {
 unsafe impl<'w, 's> ReadOnlySystemParam for Commands<'w, 's> {}
 
 // SAFETY: only local state is accessed
-unsafe impl SystemParamState for CommandQueue {
+unsafe impl SystemParamState<Infallible> for CommandQueue {
     type Item<'w, 's> = Commands<'w, 's>;
 
     fn init(_world: &mut World, _system_meta: &mut SystemMeta) -> Self {
@@ -642,12 +923,12 @@ unsafe impl<'w> ReadOnlySystemParam for &'w World {}
 #[doc(hidden)]
 pub struct WorldState;
 
-impl<'w> SystemParam for &'w World {
+impl<'w> SystemParam<Infallible> for &'w World {
     type State = WorldState;
 }
 
 // SAFETY: `read_all` access is set and conflicts result in a panic
-unsafe impl SystemParamState for WorldState {
+unsafe impl SystemParamState<Infallible> for WorldState {
     type Item<'w, 's> = &'w World;
 
     fn init(_world: &mut World, system_meta: &mut SystemMeta) -> Self {
@@ -787,12 +1068,12 @@ where
 #[doc(hidden)]
 pub struct LocalState<T: Send + 'static>(pub(crate) SyncCell<T>);
 
-impl<'a, T: FromWorld + Send + 'static> SystemParam for Local<'a, T> {
+impl<'a, T: FromWorld + Send + 'static> SystemParam<Infallible> for Local<'a, T> {
     type State = LocalState<T>;
 }
 
 // SAFETY: only local state is accessed
-unsafe impl<T: FromWorld + Send + 'static> SystemParamState for LocalState<T> {
+unsafe impl<T: FromWorld + Send + 'static> SystemParamState<Infallible> for LocalState<T> {
     type Item<'w, 's> = Local<'s, T>;
 
     fn init(world: &mut World, _system_meta: &mut SystemMeta) -> Self {
@@ -875,13 +1156,13 @@ pub struct RemovedComponentsState<T> {
     marker: PhantomData<T>,
 }
 
-impl<'a, T: Component> SystemParam for RemovedComponents<'a, T> {
+impl<'a, T: Component> SystemParam<Infallible> for RemovedComponents<'a, T> {
     type State = RemovedComponentsState<T>;
 }
 
 // SAFETY: no component access. removed component entity collections can be read in parallel and are
 // never mutably borrowed during system execution
-unsafe impl<T: Component> SystemParamState for RemovedComponentsState<T> {
+unsafe impl<T: Component> SystemParamState<Infallible> for RemovedComponentsState<T> {
     type Item<'w, 's> = RemovedComponents<'w, T>;
 
     fn init(world: &mut World, _system_meta: &mut SystemMeta) -> Self {
@@ -978,13 +1259,13 @@ pub struct NonSendState<T> {
     marker: PhantomData<fn() -> T>,
 }
 
-impl<'a, T: 'static> SystemParam for NonSend<'a, T> {
+impl<'a, T: 'static> SystemParam<Optional> for NonSend<'a, T> {
     type State = NonSendState<T>;
 }
 
 // SAFETY: NonSendComponentId and ArchetypeComponentId access is applied to SystemMeta. If this
 // NonSend conflicts with any prior access, a panic will occur.
-unsafe impl<T: 'static> SystemParamState for NonSendState<T> {
+unsafe impl<T: 'static> SystemParamState<Optional> for NonSendState<T> {
     type Item<'w, 's> = NonSend<'w, T>;
 
     fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
@@ -1020,58 +1301,10 @@ unsafe impl<T: 'static> SystemParamState for NonSendState<T> {
         system_meta: &SystemMeta,
         world: &'w World,
         change_tick: u32,
-    ) -> Self::Item<'w, 's> {
-        world.validate_non_send_access::<T>();
-        let (ptr, ticks) = world
-            .get_resource_with_ticks(state.component_id)
-            .unwrap_or_else(|| {
-                panic!(
-                    "Non-send resource requested by {} does not exist: {}",
-                    system_meta.name,
-                    std::any::type_name::<T>()
-                )
-            });
-
-        NonSend {
-            value: ptr.deref(),
-            ticks: ticks.read(),
-            last_change_tick: system_meta.last_change_tick,
-            change_tick,
-        }
-    }
-}
-
-/// The [`SystemParamState`] of [`Option<NonSend<T>>`].
-/// See: [`NonSend<T>`]
-#[doc(hidden)]
-pub struct OptionNonSendState<T>(NonSendState<T>);
-
-impl<'w, T: 'static> SystemParam for Option<NonSend<'w, T>> {
-    type State = OptionNonSendState<T>;
-}
-
-// SAFETY: Only reads a single non-send resource
-unsafe impl<'w, T: 'static> ReadOnlySystemParam for Option<NonSend<'w, T>> {}
-
-// SAFETY: this impl defers to `NonSendState`, which initializes
-// and validates the correct world access
-unsafe impl<T: 'static> SystemParamState for OptionNonSendState<T> {
-    type Item<'w, 's> = Option<NonSend<'w, T>>;
-
-    fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
-        Self(NonSendState::init(world, system_meta))
-    }
-
-    #[inline]
-    unsafe fn get_param<'w, 's>(
-        state: &'s mut Self,
-        system_meta: &SystemMeta,
-        world: &'w World,
-        change_tick: u32,
-    ) -> Self::Item<'w, 's> {
+    ) -> Option<Self::Item<'w, 's>> {
         world.validate_non_send_access::<T>();
         world
-            .get_resource_with_ticks(state.0.component_id)
+            .get_resource_with_ticks(state.component_id)
             .map(|(ptr, ticks)| NonSend {
                 value: ptr.deref(),
                 ticks: ticks.read(),
@@ -1088,13 +1321,13 @@ pub struct NonSendMutState<T> {
     marker: PhantomData<fn() -> T>,
 }
 
-impl<'a, T: 'static> SystemParam for NonSendMut<'a, T> {
+impl<'a, T: 'static> SystemParam<Optional> for NonSendMut<'a, T> {
     type State = NonSendMutState<T>;
 }
 
 // SAFETY: NonSendMut ComponentId and ArchetypeComponentId access is applied to SystemMeta. If this
 // NonSendMut conflicts with any prior access, a panic will occur.
-unsafe impl<T: 'static> SystemParamState for NonSendMutState<T> {
+unsafe impl<T: 'static> SystemParamState<Optional> for NonSendMutState<T> {
     type Item<'w, 's> = NonSendMut<'w, T>;
 
     fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
@@ -1133,52 +1366,10 @@ unsafe impl<T: 'static> SystemParamState for NonSendMutState<T> {
         system_meta: &SystemMeta,
         world: &'w World,
         change_tick: u32,
-    ) -> Self::Item<'w, 's> {
-        world.validate_non_send_access::<T>();
-        let (ptr, ticks) = world
-            .get_resource_with_ticks(state.component_id)
-            .unwrap_or_else(|| {
-                panic!(
-                    "Non-send resource requested by {} does not exist: {}",
-                    system_meta.name,
-                    std::any::type_name::<T>()
-                )
-            });
-        NonSendMut {
-            value: ptr.assert_unique().deref_mut(),
-            ticks: Ticks::from_tick_cells(ticks, system_meta.last_change_tick, change_tick),
-        }
-    }
-}
-
-/// The [`SystemParamState`] of [`Option<NonSendMut<T>>`].
-/// See: [`NonSendMut<T>`]
-#[doc(hidden)]
-pub struct OptionNonSendMutState<T>(NonSendMutState<T>);
-
-impl<'a, T: 'static> SystemParam for Option<NonSendMut<'a, T>> {
-    type State = OptionNonSendMutState<T>;
-}
-
-// SAFETY: this impl defers to `NonSendMutState`, which initializes
-// and validates the correct world access
-unsafe impl<T: 'static> SystemParamState for OptionNonSendMutState<T> {
-    type Item<'w, 's> = Option<NonSendMut<'w, T>>;
-
-    fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self {
-        Self(NonSendMutState::init(world, system_meta))
-    }
-
-    #[inline]
-    unsafe fn get_param<'w, 's>(
-        state: &'s mut Self,
-        system_meta: &SystemMeta,
-        world: &'w World,
-        change_tick: u32,
-    ) -> Self::Item<'w, 's> {
+    ) -> Option<Self::Item<'w, 's>> {
         world.validate_non_send_access::<T>();
         world
-            .get_resource_with_ticks(state.0.component_id)
+            .get_resource_with_ticks(state.component_id)
             .map(|(ptr, ticks)| NonSendMut {
                 value: ptr.assert_unique().deref_mut(),
                 ticks: Ticks::from_tick_cells(ticks, system_meta.last_change_tick, change_tick),
@@ -1186,7 +1377,7 @@ unsafe impl<T: 'static> SystemParamState for OptionNonSendMutState<T> {
     }
 }
 
-impl<'a> SystemParam for &'a Archetypes {
+impl<'a> SystemParam<Infallible> for &'a Archetypes {
     type State = ArchetypesState;
 }
 
@@ -1198,7 +1389,7 @@ unsafe impl<'a> ReadOnlySystemParam for &'a Archetypes {}
 pub struct ArchetypesState;
 
 // SAFETY: no component value access
-unsafe impl SystemParamState for ArchetypesState {
+unsafe impl SystemParamState<Infallible> for ArchetypesState {
     type Item<'w, 's> = &'w Archetypes;
 
     fn init(_world: &mut World, _system_meta: &mut SystemMeta) -> Self {
@@ -1216,7 +1407,7 @@ unsafe impl SystemParamState for ArchetypesState {
     }
 }
 
-impl<'a> SystemParam for &'a Components {
+impl<'a> SystemParam<Infallible> for &'a Components {
     type State = ComponentsState;
 }
 
@@ -1228,7 +1419,7 @@ unsafe impl<'a> ReadOnlySystemParam for &'a Components {}
 pub struct ComponentsState;
 
 // SAFETY: no component value access
-unsafe impl SystemParamState for ComponentsState {
+unsafe impl SystemParamState<Infallible> for ComponentsState {
     type Item<'w, 's> = &'w Components;
 
     fn init(_world: &mut World, _system_meta: &mut SystemMeta) -> Self {
@@ -1246,7 +1437,7 @@ unsafe impl SystemParamState for ComponentsState {
     }
 }
 
-impl<'a> SystemParam for &'a Entities {
+impl<'a> SystemParam<Infallible> for &'a Entities {
     type State = EntitiesState;
 }
 
@@ -1258,7 +1449,7 @@ unsafe impl<'a> ReadOnlySystemParam for &'a Entities {}
 pub struct EntitiesState;
 
 // SAFETY: no component value access
-unsafe impl SystemParamState for EntitiesState {
+unsafe impl SystemParamState<Infallible> for EntitiesState {
     type Item<'w, 's> = &'w Entities;
 
     fn init(_world: &mut World, _system_meta: &mut SystemMeta) -> Self {
@@ -1276,7 +1467,7 @@ unsafe impl SystemParamState for EntitiesState {
     }
 }
 
-impl<'a> SystemParam for &'a Bundles {
+impl<'a> SystemParam<Infallible> for &'a Bundles {
     type State = BundlesState;
 }
 
@@ -1288,7 +1479,7 @@ unsafe impl<'a> ReadOnlySystemParam for &'a Bundles {}
 pub struct BundlesState;
 
 // SAFETY: no component value access
-unsafe impl SystemParamState for BundlesState {
+unsafe impl SystemParamState<Infallible> for BundlesState {
     type Item<'w, 's> = &'w Bundles;
 
     fn init(_world: &mut World, _system_meta: &mut SystemMeta) -> Self {
@@ -1338,7 +1529,7 @@ impl SystemChangeTick {
 // SAFETY: Only reads internal system state
 unsafe impl ReadOnlySystemParam for SystemChangeTick {}
 
-impl SystemParam for SystemChangeTick {
+impl SystemParam<Infallible> for SystemChangeTick {
     type State = SystemChangeTickState;
 }
 
@@ -1347,7 +1538,7 @@ impl SystemParam for SystemChangeTick {
 pub struct SystemChangeTickState {}
 
 // SAFETY: `SystemParamTickState` doesn't require any world access
-unsafe impl SystemParamState for SystemChangeTickState {
+unsafe impl SystemParamState<Infallible> for SystemChangeTickState {
     type Item<'w, 's> = SystemChangeTick;
 
     fn init(_world: &mut World, _system_meta: &mut SystemMeta) -> Self {
@@ -1414,7 +1605,7 @@ impl<'s> std::fmt::Display for SystemName<'s> {
     }
 }
 
-impl<'s> SystemParam for SystemName<'s> {
+impl<'s> SystemParam<Infallible> for SystemName<'s> {
     type State = SystemNameState;
 }
 
@@ -1428,7 +1619,7 @@ pub struct SystemNameState {
 }
 
 // SAFETY: no component value access
-unsafe impl SystemParamState for SystemNameState {
+unsafe impl SystemParamState<Infallible> for SystemNameState {
     type Item<'w, 's> = SystemName<'s>;
 
     fn init(_world: &mut World, system_meta: &mut SystemMeta) -> Self {
@@ -1452,7 +1643,7 @@ unsafe impl SystemParamState for SystemNameState {
 
 macro_rules! impl_system_param_tuple {
     ($($param: ident),*) => {
-        impl<$($param: SystemParam),*> SystemParam for ($($param,)*) {
+        impl<$($param: SystemParam<Infallible>),*> SystemParam<Infallible> for ($($param,)*) {
             type State = ($($param::State,)*);
         }
 
@@ -1463,7 +1654,7 @@ macro_rules! impl_system_param_tuple {
         // SAFETY: implementors of each `SystemParamState` in the tuple have validated their impls
         #[allow(clippy::undocumented_unsafe_blocks)] // false positive by clippy
         #[allow(non_snake_case)]
-        unsafe impl<$($param: SystemParamState),*> SystemParamState for ($($param,)*) {
+        unsafe impl<$($param: SystemParamState<Infallible>),*> SystemParamState<Infallible> for ($($param,)*) {
             type Item<'w, 's> = ($($param::Item::<'w, 's>,)*);
 
             #[inline]
@@ -1523,14 +1714,14 @@ pub mod lifetimeless {
 ///
 /// ```
 /// # use bevy_ecs::prelude::*;
-/// use bevy_ecs::system::{SystemParam, StaticSystemParam};
+/// use bevy_ecs::system::{Infallible, SystemParam, StaticSystemParam};
 /// #[derive(SystemParam)]
-/// struct GenericParam<'w,'s, T: SystemParam + 'static> {
+/// struct GenericParam<'w,'s, T: SystemParam<Infallible> + 'static> {
 ///     field: StaticSystemParam<'w, 's, T>,
 /// }
-/// fn do_thing_generically<T: SystemParam + 'static>(t: StaticSystemParam<T>) {}
+/// fn do_thing_generically<T: SystemParam<Infallible> + 'static>(t: StaticSystemParam<T>) {}
 ///
-/// fn check_always_is_system<T: SystemParam + 'static>(){
+/// fn check_always_is_system<T: SystemParam<Infallible> + 'static>(){
 ///     bevy_ecs::system::assert_is_system(do_thing_generically::<T>);
 /// }
 /// ```
@@ -1563,9 +1754,9 @@ pub mod lifetimeless {
 /// # }
 /// ```
 ///
-pub struct StaticSystemParam<'w, 's, P: SystemParam>(SystemParamItem<'w, 's, P>);
+pub struct StaticSystemParam<'w, 's, P: SystemParam<Infallible>>(SystemParamItem<'w, 's, P>);
 
-impl<'w, 's, P: SystemParam> Deref for StaticSystemParam<'w, 's, P> {
+impl<'w, 's, P: SystemParam<Infallible>> Deref for StaticSystemParam<'w, 's, P> {
     type Target = SystemParamItem<'w, 's, P>;
 
     fn deref(&self) -> &Self::Target {
@@ -1573,13 +1764,13 @@ impl<'w, 's, P: SystemParam> Deref for StaticSystemParam<'w, 's, P> {
     }
 }
 
-impl<'w, 's, P: SystemParam> DerefMut for StaticSystemParam<'w, 's, P> {
+impl<'w, 's, P: SystemParam<Infallible>> DerefMut for StaticSystemParam<'w, 's, P> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
 }
 
-impl<'w, 's, P: SystemParam> StaticSystemParam<'w, 's, P> {
+impl<'w, 's, P: SystemParam<Infallible>> StaticSystemParam<'w, 's, P> {
     /// Get the value of the parameter
     pub fn into_inner(self) -> SystemParamItem<'w, 's, P> {
         self.0
@@ -1596,15 +1787,15 @@ unsafe impl<'w, 's, P: ReadOnlySystemParam + 'static> ReadOnlySystemParam
 {
 }
 
-impl<'world, 'state, P: SystemParam + 'static> SystemParam
+impl<'world, 'state, P: SystemParam<Infallible> + 'static> SystemParam<Infallible>
     for StaticSystemParam<'world, 'state, P>
 {
     type State = StaticSystemParamState<P::State, P>;
 }
 
 // SAFETY: all methods are just delegated to `S`'s `SystemParamState` implementation
-unsafe impl<S: SystemParamState, P: SystemParam<State = S> + 'static> SystemParamState
-    for StaticSystemParamState<S, P>
+unsafe impl<S: SystemParamState<Infallible>, P: SystemParam<Infallible, State = S> + 'static>
+    SystemParamState<Infallible> for StaticSystemParamState<S, P>
 {
     type Item<'world, 'state> = StaticSystemParam<'world, 'state, P>;
 
@@ -1663,4 +1854,10 @@ mod tests {
 
     #[derive(SystemParam)]
     pub struct UnitParam {}
+
+    #[derive(SystemParam)]
+    #[fallibility(Optional)]
+    pub struct OptionalParam<'w, T: Resource> {
+        _res: Res<'w, T>,
+    }
 }
diff --git a/crates/bevy_render/src/extract_param.rs b/crates/bevy_render/src/extract_param.rs
index b3d4ba665a55a..a0b9cb1292d32 100644
--- a/crates/bevy_render/src/extract_param.rs
+++ b/crates/bevy_render/src/extract_param.rs
@@ -2,8 +2,8 @@ use crate::MainWorld;
 use bevy_ecs::{
     prelude::*,
     system::{
-        ReadOnlySystemParam, ResState, SystemMeta, SystemParam, SystemParamItem, SystemParamState,
-        SystemState,
+        Infallible, ReadOnlySystemParam, ResState, SystemMeta, SystemParam, SystemParamItem,
+        SystemParamState, SystemState,
     },
 };
 use std::ops::{Deref, DerefMut};
@@ -49,7 +49,7 @@ where
     item: SystemParamItem<'w, 's, P>,
 }
 
-impl<'w, 's, P> SystemParam for Extract<'w, 's, P>
+impl<'w, 's, P> SystemParam<Infallible> for Extract<'w, 's, P>
 where
     P: ReadOnlySystemParam,
 {
@@ -57,14 +57,14 @@ where
 }
 
 #[doc(hidden)]
-pub struct ExtractState<P: SystemParam + 'static> {
+pub struct ExtractState<P: SystemParam<Infallible> + 'static> {
     state: SystemState<P>,
     main_world_state: ResState<MainWorld>,
 }
 
 // SAFETY: only accesses MainWorld resource with read only system params using ResState,
 // which is initialized in init()
-unsafe impl<P: SystemParam + 'static> SystemParamState for ExtractState<P>
+unsafe impl<P: SystemParam<Infallible> + 'static> SystemParamState<Infallible> for ExtractState<P>
 where
     P: ReadOnlySystemParam + 'static,
 {
@@ -74,7 +74,10 @@ where
         let mut main_world = world.resource_mut::<MainWorld>();
         Self {
             state: SystemState::new(&mut main_world),
-            main_world_state: ResState::init(world, system_meta),
+            main_world_state: <ResState<MainWorld> as SystemParamState<Infallible>>::init(
+                world,
+                system_meta,
+            ),
         }
     }
 
@@ -84,7 +87,7 @@ where
         world: &'w World,
         change_tick: u32,
     ) -> Self::Item<'w, 's> {
-        let main_world = ResState::<MainWorld>::get_param(
+        let main_world = <ResState<MainWorld> as SystemParamState<Infallible>>::get_param(
             &mut state.main_world_state,
             system_meta,
             world,
@@ -95,7 +98,7 @@ where
     }
 }
 
-impl<'w, 's, P: SystemParam> Deref for Extract<'w, 's, P>
+impl<'w, 's, P: SystemParam<Infallible>> Deref for Extract<'w, 's, P>
 where
     P: ReadOnlySystemParam,
 {
@@ -107,7 +110,7 @@ where
     }
 }
 
-impl<'w, 's, P: SystemParam> DerefMut for Extract<'w, 's, P>
+impl<'w, 's, P: SystemParam<Infallible>> DerefMut for Extract<'w, 's, P>
 where
     P: ReadOnlySystemParam,
 {
@@ -117,7 +120,7 @@ where
     }
 }
 
-impl<'a, 'w, 's, P: SystemParam> IntoIterator for &'a Extract<'w, 's, P>
+impl<'a, 'w, 's, P: SystemParam<Infallible>> IntoIterator for &'a Extract<'w, 's, P>
 where
     P: ReadOnlySystemParam,
     &'a SystemParamItem<'w, 's, P>: IntoIterator,
diff --git a/crates/bevy_render/src/render_asset.rs b/crates/bevy_render/src/render_asset.rs
index 9bdee8a4cd893..eab9d6648d1fb 100644
--- a/crates/bevy_render/src/render_asset.rs
+++ b/crates/bevy_render/src/render_asset.rs
@@ -4,7 +4,7 @@ use bevy_asset::{Asset, AssetEvent, Assets, Handle};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     prelude::*,
-    system::{StaticSystemParam, SystemParam, SystemParamItem},
+    system::{Infallible, StaticSystemParam, SystemParam, SystemParamItem},
 };
 use bevy_utils::{HashMap, HashSet};
 use std::marker::PhantomData;
@@ -29,7 +29,7 @@ pub trait RenderAsset: Asset {
     type PreparedAsset: Send + Sync + 'static;
     /// Specifies all ECS data required by [`RenderAsset::prepare_asset`].
     /// For convenience use the [`lifetimeless`](bevy_ecs::system::lifetimeless) [`SystemParam`].
-    type Param: SystemParam;
+    type Param: SystemParam<Infallible>;
     /// Converts the asset into a [`RenderAsset::ExtractedAsset`].
     fn extract_asset(&self) -> Self::ExtractedAsset;
     /// Prepares the `extracted asset` for the GPU by transforming it into
diff --git a/crates/bevy_render/src/render_phase/draw.rs b/crates/bevy_render/src/render_phase/draw.rs
index 67ff987b7972d..3a7f73e10ca07 100644
--- a/crates/bevy_render/src/render_phase/draw.rs
+++ b/crates/bevy_render/src/render_phase/draw.rs
@@ -7,8 +7,8 @@ use bevy_ecs::{
     all_tuples,
     entity::Entity,
     system::{
-        lifetimeless::SRes, ReadOnlySystemParam, Resource, SystemParam, SystemParamItem,
-        SystemState,
+        lifetimeless::SRes, Infallible, ReadOnlySystemParam, Resource, SystemParam,
+        SystemParamItem, SystemState,
     },
     world::World,
 };
@@ -167,7 +167,7 @@ impl<P: PhaseItem> DrawFunctions<P> {
 pub trait RenderCommand<P: PhaseItem> {
     /// Specifies all ECS data required by [`RenderCommand::render`].
     /// All parameters have to be read only.
-    type Param: SystemParam + 'static;
+    type Param: SystemParam<Infallible> + 'static;
 
     /// Renders the [`PhaseItem`] by issuing draw calls via the [`TrackedRenderPass`].
     fn render<'w>(
@@ -184,7 +184,7 @@ pub enum RenderCommandResult {
 }
 
 pub trait EntityRenderCommand {
-    type Param: SystemParam + 'static;
+    type Param: SystemParam<Infallible> + 'static;
     fn render<'w>(
         view: Entity,
         item: Entity,