diff --git a/tera-contrib/src/rand.rs b/tera-contrib/src/rand.rs
index 2ba29ed6..be7d9952 100644
--- a/tera-contrib/src/rand.rs
+++ b/tera-contrib/src/rand.rs
@@ -13,6 +13,12 @@ pub fn get_random(kwargs: Kwargs, _: &State) -> TeraResult<i64> {
     let start = kwargs.must_get::<i64>("start")?;
     let end = kwargs.must_get::<i64>("end")?;
 
+    if start >= end {
+        return Err(tera::Error::message(format!(
+            "get_random: `start` ({start}) must be less than `end` ({end})."
+        )));
+    }
+
     match kwargs.get::<String>("seed")? {
         Some(seed) => {
             let mut h = DefaultHasher::new();
diff --git a/tera/src/args.rs b/tera/src/args.rs
index dbff5e70..3b0dd488 100644
--- a/tera/src/args.rs
+++ b/tera/src/args.rs
@@ -183,7 +183,7 @@ impl Kwargs {
         T::deserialize(&Value {
             inner: ValueInner::Map(self.values.clone()),
         })
-        .map_err(|_| Error::message("Failed to deserialize"))
+        .map_err(Error::message)
     }
 
     /// Try to get the given key value and convert it to the given type
diff --git a/tera/src/errors.rs b/tera/src/errors.rs
index 6c117320..75a62e87 100644
--- a/tera/src/errors.rs
+++ b/tera/src/errors.rs
@@ -81,6 +81,13 @@ pub enum ErrorKind {
         /// All the parents templates we found so far
         inheritance_chain: Vec<String>,
     },
+    /// A loop was found while following `{% include %}` calls between templates
+    CircularInclude {
+        /// Name of the template where the cycle was detected
+        tpl: String,
+        /// Ordered chain of templates from `tpl` back to `tpl`
+        include_chain: Vec<String>,
+    },
     /// A template is extending a template that wasn't found in the Tera instance
     MissingParent {
         /// The template we are currently looking at
@@ -138,6 +145,10 @@ impl fmt::Display for ErrorKind {
                 f,
                 "Circular extend detected for template '{tpl}'. Inheritance chain: `{inheritance_chain:?}`",
             ),
+            ErrorKind::CircularInclude { tpl, include_chain } => write!(
+                f,
+                "Circular include detected for template '{tpl}'. Include chain: `{include_chain:?}`",
+            ),
             ErrorKind::MissingParent { current, parent } => write!(
                 f,
                 "Template '{current}' is inheriting from '{parent}', which doesn't exist or isn't loaded.",
@@ -230,6 +241,16 @@ impl Error {
         }
     }
 
+    pub(crate) fn circular_include(tpl: impl ToString, include_chain: Vec<String>) -> Self {
+        Self {
+            kind: ErrorKind::CircularInclude {
+                tpl: tpl.to_string(),
+                include_chain,
+            },
+            source: None,
+        }
+    }
+
     pub(crate) fn missing_parent(current: impl ToString, parent: impl ToString) -> Self {
         Self {
             kind: ErrorKind::MissingParent {
diff --git a/tera/src/filters.rs b/tera/src/filters.rs
index 97a0c2d0..0dfd5074 100644
--- a/tera/src/filters.rs
+++ b/tera/src/filters.rs
@@ -220,6 +220,7 @@ pub(crate) fn title(val: &str, _: Kwargs, _: &State) -> String {
     res
 }
 
+/// Works on char/graphemes, not bytes.
 pub(crate) fn truncate(val: &str, kwargs: Kwargs, _: &State) -> TeraResult<String> {
     let length = kwargs.must_get::<usize>("length")?;
     let end = kwargs.get::<&str>("end")?.unwrap_or("…");
@@ -236,17 +237,18 @@ pub(crate) fn truncate(val: &str, kwargs: Kwargs, _: &State) -> TeraResult<Strin
 
     #[cfg(not(feature = "unicode"))]
     {
-        if length >= val.len() {
-            return Ok(val.to_string());
+        match val.char_indices().nth(length) {
+            Some((byte_idx, _)) => Ok(val[..byte_idx].to_string() + end),
+            None => Ok(val.to_string()),
         }
-        Ok(val[..length].to_string() + end)
     }
 }
 
 /// Return a copy of the string with each line indented by 4 spaces.
 /// The first line and blank lines are not indented by default.
+/// Max width of 1000 to avoid DOS
 pub(crate) fn indent(val: &str, kwargs: Kwargs, _: &State) -> TeraResult<String> {
-    let width = kwargs.get::<usize>("width")?.unwrap_or(4);
+    let width = kwargs.get::<usize>("width")?.unwrap_or(4).min(1000);
     let indent_first_line = kwargs.get::<bool>("first")?.unwrap_or(false);
     let indent_blank_line = kwargs.get::<bool>("blank")?.unwrap_or(false);
 
@@ -595,7 +597,7 @@ pub(crate) fn get(val: Map, kwargs: Kwargs, _: &State) -> TeraResult<Value> {
         Ok(d)
     } else {
         Err(Error::message(format!(
-            "Map does not a key {key} and no default values were defined"
+            "Map does not have a key {key} and no default values were defined"
         )))
     }
 }
@@ -612,7 +614,7 @@ pub(crate) fn filter(val: Vec<Value>, kwargs: Kwargs, _: &State) -> TeraResult<V
         match v.get_from_path(attribute) {
             x if x.is_undefined() => {
                 return Err(Error::message(format!(
-                    "Value {v} does not an attribute after following path: {attribute}"
+                    "Value {v} does not have an attribute after following path: {attribute}"
                 )));
             }
             x => {
@@ -637,7 +639,7 @@ pub(crate) fn group_by(val: Vec<Value>, kwargs: Kwargs, _: &State) -> TeraResult
         match v.get_from_path(attribute) {
             x if x.is_undefined() => {
                 return Err(Error::message(format!(
-                    "Value {v} does not an attribute after following path; {attribute}"
+                    "Value {v} does not have an attribute after following path; {attribute}"
                 )));
             }
             x if x.is_none() => (),
@@ -659,8 +661,6 @@ pub(crate) fn group_by(val: Vec<Value>, kwargs: Kwargs, _: &State) -> TeraResult
 mod tests {
     use super::*;
     use crate::Context;
-    #[cfg(feature = "unicode")]
-    use crate::Tera;
     use crate::value::Map;
 
     #[test]
@@ -823,13 +823,25 @@ mod tests {
     #[cfg(feature = "unicode")]
     #[test]
     fn can_truncate_graphemes() {
+        let ctx = Context::new();
+        let state = State::new(&ctx);
         let inputs = vec![("日本語", 2, "日本…"), ("👨‍👩‍👧‍👦 family", 5, "👨‍👩‍👧‍👦 fam…")];
 
-        for (s, len, expected) in inputs {
-            let tpl = format!("{{{{ '{}' | truncate(length={}) }}}}", s, len);
-            let mut tera = Tera::default();
-            tera.add_raw_template("tpl", &tpl).unwrap();
-            let out = tera.render("tpl", &Context::default()).unwrap();
+        for (input, length, expected) in inputs {
+            let out = truncate(input, Kwargs::from([("length", length.into())]), &state).unwrap();
+            assert_eq!(out, expected);
+        }
+    }
+
+    #[cfg(not(feature = "unicode"))]
+    #[test]
+    fn truncate_splits_on_char_boundary() {
+        let ctx = Context::new();
+        let state = State::new(&ctx);
+        let inputs = [("😀test", 1, "😀…"), ("日本語hello", 3, "日本語…")];
+
+        for (input, length, expected) in inputs {
+            let out = truncate(input, Kwargs::from([("length", length.into())]), &state).unwrap();
             assert_eq!(out, expected);
         }
     }
diff --git a/tera/src/functions.rs b/tera/src/functions.rs
index 617a4b3f..b604d4cd 100644
--- a/tera/src/functions.rs
+++ b/tera/src/functions.rs
@@ -61,6 +61,9 @@ impl StoredFunction {
     }
 }
 
+/// Upper bound on the number of elements `range()` will produce to avoid OOM.
+const MAX_RANGE_LEN: usize = 100_000;
+
 pub(crate) fn range(kwargs: Kwargs, _: &State) -> TeraResult<Vec<isize>> {
     let start = kwargs.get::<isize>("start")?.unwrap_or_default();
     let end = kwargs.must_get::<isize>("end")?;
@@ -70,6 +73,20 @@ pub(crate) fn range(kwargs: Kwargs, _: &State) -> TeraResult<Vec<isize>> {
             "Function `range` was called with a `start` argument greater than the `end` one",
         ));
     }
+    if step_by == 0 {
+        return Err(Error::message(
+            "Function `range` was called with a `step_by` argument of 0",
+        ));
+    }
+
+    let span = (end as i128) - (start as i128);
+    let step = step_by as i128;
+    let len = (span + step - 1) / step;
+    if len > MAX_RANGE_LEN as i128 {
+        return Err(Error::message(format!(
+            "Function `range` would produce {len} elements, which exceeds the limit of {MAX_RANGE_LEN}"
+        )));
+    }
 
     Ok((start..end).step_by(step_by).collect())
 }
diff --git a/tera/src/parsing/compiler.rs b/tera/src/parsing/compiler.rs
index d901e8c0..0969e66f 100644
--- a/tera/src/parsing/compiler.rs
+++ b/tera/src/parsing/compiler.rs
@@ -200,7 +200,7 @@ impl Compiler {
                 if let Some(start) = slice.start {
                     self.compile_expr(start);
                 } else {
-                    self.chunk.add(Instruction::LoadConst(0.into()), None);
+                    self.chunk.add(Instruction::LoadConst(Value::none()), None);
                 }
 
                 if let Some(end) = slice.end {
diff --git a/tera/src/parsing/lexer.rs b/tera/src/parsing/lexer.rs
index f366ca2f..64221676 100644
--- a/tera/src/parsing/lexer.rs
+++ b/tera/src/parsing/lexer.rs
@@ -265,7 +265,7 @@ fn basic_tokenize(
         ($num_bytes:expr) => {{
             let (skipped, new_rest) = rest.split_at($num_bytes);
             for c in skipped.chars() {
-                current_byte += 1;
+                current_byte += c.len_utf8();
                 match c {
                     '\n' => {
                         current_line += 1;
diff --git a/tera/src/snapshot_tests/build_errors/circular_include.txt b/tera/src/snapshot_tests/build_errors/circular_include.txt
new file mode 100644
index 00000000..c27a1e37
--- /dev/null
+++ b/tera/src/snapshot_tests/build_errors/circular_include.txt
@@ -0,0 +1,4 @@
+$$ a
+{% include "b" %}
+$$ b
+{% include "a" %}
diff --git a/tera/src/snapshot_tests/build_errors/circular_include_intermediate.txt b/tera/src/snapshot_tests/build_errors/circular_include_intermediate.txt
new file mode 100644
index 00000000..4a6faf31
--- /dev/null
+++ b/tera/src/snapshot_tests/build_errors/circular_include_intermediate.txt
@@ -0,0 +1,6 @@
+$$ a
+{% include "b" %}
+$$ b
+{% include "c" %}
+$$ c
+{% include "b" %}
diff --git a/tera/src/snapshot_tests/build_errors/including_itself.txt b/tera/src/snapshot_tests/build_errors/including_itself.txt
new file mode 100644
index 00000000..16decb7f
--- /dev/null
+++ b/tera/src/snapshot_tests/build_errors/including_itself.txt
@@ -0,0 +1,2 @@
+$$ a
+{% include "a" %}
diff --git a/tera/src/snapshot_tests/rendering_inputs/errors/slice_step_zero.txt b/tera/src/snapshot_tests/rendering_inputs/errors/slice_step_zero.txt
new file mode 100644
index 00000000..6cf46fa1
--- /dev/null
+++ b/tera/src/snapshot_tests/rendering_inputs/errors/slice_step_zero.txt
@@ -0,0 +1 @@
+{{ numbers[0:2:0] }}
diff --git a/tera/src/snapshot_tests/rendering_inputs/success/indexing.txt b/tera/src/snapshot_tests/rendering_inputs/success/indexing.txt
index b56f3932..6559e1bb 100644
--- a/tera/src/snapshot_tests/rendering_inputs/success/indexing.txt
+++ b/tera/src/snapshot_tests/rendering_inputs/success/indexing.txt
@@ -5,11 +5,20 @@
 {{ numbers[:2] }}
 {{ numbers[1:2] }}
 {{ numbers[0:2:2] }}
+{{ numbers[::2] }}
+{{ numbers[::-2] }}
+{{ numbers[10:20] }}
 {{ numbers[::-1] }}
+{{ product.name[::2] }}
 {{ product.name[-1] }}
 {{ product.name[::-1] }}
 {{ product.name[1:] }}
 {{ product.name[:-1] }}
 {{ (numbers | reverse)[0] }}
 {{ range(end=5)[2] }}
-{{ (numbers | reverse)[:-1] | first }}
\ No newline at end of file
+{{ (numbers | reverse)[:-1] | first }}
+{{ [1,2,3][10::-1] }}
+{{ [1,2,3][1000:] }}
+{{ [1,2,3][:1000] }}
+{{ [1,2,3][-100:] }}
+{{ [1,2,3][:-100:-1] }}
\ No newline at end of file
diff --git a/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__build_errors__build_errors@circular_include.txt.snap b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__build_errors__build_errors@circular_include.txt.snap
new file mode 100644
index 00000000..ba1e96b0
--- /dev/null
+++ b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__build_errors__build_errors@circular_include.txt.snap
@@ -0,0 +1,6 @@
+---
+source: tera/src/snapshot_tests/build_errors.rs
+expression: "&err"
+input_file: tera/src/snapshot_tests/build_errors/circular_include.txt
+---
+Circular include detected for template 'a'. Include chain: `["a", "b", "a"]`
diff --git a/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__build_errors__build_errors@circular_include_intermediate.txt.snap b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__build_errors__build_errors@circular_include_intermediate.txt.snap
new file mode 100644
index 00000000..b8bc04b2
--- /dev/null
+++ b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__build_errors__build_errors@circular_include_intermediate.txt.snap
@@ -0,0 +1,6 @@
+---
+source: tera/src/snapshot_tests/build_errors.rs
+expression: "&err"
+input_file: tera/src/snapshot_tests/build_errors/circular_include_intermediate.txt
+---
+Circular include detected for template 'b'. Include chain: `["a", "b", "c", "b"]`
diff --git a/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__build_errors__build_errors@including_itself.txt.snap b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__build_errors__build_errors@including_itself.txt.snap
new file mode 100644
index 00000000..8f0496b9
--- /dev/null
+++ b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__build_errors__build_errors@including_itself.txt.snap
@@ -0,0 +1,6 @@
+---
+source: tera/src/snapshot_tests/build_errors.rs
+expression: "&err"
+input_file: tera/src/snapshot_tests/build_errors/including_itself.txt
+---
+Circular include detected for template 'a'. Include chain: `["a", "a"]`
diff --git a/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__parser__parser_templates_success@tpl_simple.txt.snap b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__parser__parser_templates_success@tpl_simple.txt.snap
index 4e01e9d3..553e52fe 100644
--- a/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__parser__parser_templates_success@tpl_simple.txt.snap
+++ b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__parser__parser_templates_success@tpl_simple.txt.snap
@@ -47,15 +47,15 @@ input_file: tera/src/snapshot_tests/parser_inputs/success/tpl/tpl_simple.txt
         left: GetAttr {
             expr: Var {
                 name: "product",
-            } @ 9:11-9:18 (207..214),
+            } @ 9:11-9:18 (208..215),
             name: "price",
             optional: false,
-        } @ 9:19-9:24 (215..220),
-        right: 1.2 @ 9:27-9:31 (223..227),
-    } @ 9:11-9:31 (207..227),
+        } @ 9:19-9:24 (216..221),
+        right: 1.2 @ 9:27-9:31 (224..228),
+    } @ 9:11-9:31 (208..228),
     " (VAT inc.)</p>\n    <p>Look at reviews from your friends ",
     Var {
         name: "username",
-    } @ 10:44-10:52 (290..298),
+    } @ 10:44-10:52 (291..299),
     "</p>\n    <button>Buy!</button>\n  </body>\n</html>",
 ]
diff --git a/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__rendering__rendering_errors@slice_step_zero.txt.snap b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__rendering__rendering_errors@slice_step_zero.txt.snap
new file mode 100644
index 00000000..1027feb2
--- /dev/null
+++ b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__rendering__rendering_errors@slice_step_zero.txt.snap
@@ -0,0 +1,10 @@
+---
+source: tera/src/snapshot_tests/rendering.rs
+expression: "&err"
+input_file: tera/src/snapshot_tests/rendering_inputs/errors/slice_step_zero.txt
+---
+error: Slicing step cannot be 0
+ --> slice_step_zero.txt:1:3
+  |
+1 | {{ numbers[0:2:0] }}
+  |    ^^^^^^^
diff --git a/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__rendering__rendering_ok@indexing.txt.snap b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__rendering__rendering_ok@indexing.txt.snap
index c05ed9f5..9be6e119 100644
--- a/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__rendering__rendering_ok@indexing.txt.snap
+++ b/tera/src/snapshot_tests/snapshots/tera__snapshot_tests__rendering__rendering_ok@indexing.txt.snap
@@ -9,8 +9,12 @@ input_file: tera/src/snapshot_tests/rendering_inputs/success/indexing.txt
 [1, 2]
 [1, 2]
 [2]
-[1, 2]
+[1]
+[1, 3]
+[3, 1]
+[]
 [3, 2, 1]
+Mt 
 G
 G otoM
 oto G
@@ -18,3 +22,8 @@ Moto
 3
 2
 3
+[3, 2, 1]
+[]
+[1, 2, 3]
+[1, 2, 3]
+[3, 2, 1]
diff --git a/tera/src/template.rs b/tera/src/template.rs
index 86699308..e40c9e4e 100644
--- a/tera/src/template.rs
+++ b/tera/src/template.rs
@@ -141,6 +141,30 @@ impl Template {
     }
 }
 
+/// Recursive fn that finds all the includes to detect if there are some cycles
+pub(crate) fn check_include_cycles(tera: &Tera, start: &Template) -> Result<(), Error> {
+    let mut stack: Vec<String> = vec![start.name.clone()];
+    fn walk(tera: &Tera, current: &Template, stack: &mut Vec<String>) -> Result<(), Error> {
+        let mut names: Vec<&String> = current.include_calls.keys().collect();
+        names.sort();
+        for include_name in names {
+            let Some(resolved) = tera.resolve_template_name(include_name) else {
+                continue;
+            };
+            if stack.iter().any(|s| s == resolved) {
+                let mut chain = stack.clone();
+                chain.push(resolved.to_string());
+                return Err(Error::circular_include(resolved, chain));
+            }
+            stack.push(resolved.to_string());
+            walk(tera, &tera.templates[resolved], stack)?;
+            stack.pop();
+        }
+        Ok(())
+    }
+    walk(tera, start, &mut stack)
+}
+
 /// Recursive fn that finds all the parents and put them in an ordered Vec from closest to first parent
 /// parent template
 pub(crate) fn find_parents(
diff --git a/tera/src/tera.rs b/tera/src/tera.rs
index 9260a083..1ea5573a 100644
--- a/tera/src/tera.rs
+++ b/tera/src/tera.rs
@@ -8,7 +8,7 @@ use crate::args::ArgFromValue;
 use crate::errors::{Error, ReportError, TeraResult};
 use crate::filters::{Filter, StoredFilter};
 use crate::functions::{Function, StoredFunction};
-use crate::template::{Template, find_parents};
+use crate::template::{Template, check_include_cycles, find_parents};
 use crate::tests::{StoredTest, Test, TestResult};
 use crate::value::FunctionResult;
 use crate::value::Value;
@@ -505,8 +505,13 @@ impl Tera {
         let mut component_sources: HashMap<&str, (&str, usize)> = HashMap::new();
 
         // 1st loop: find parents of each template and check for duplicate components
-        for (name, tpl) in &self.templates {
+        // Sort so error messages (circular include chains, etc.) are deterministic
+        let mut ordered_names: Vec<&String> = self.templates.keys().collect();
+        ordered_names.sort();
+        for name in ordered_names {
+            let tpl = &self.templates[name];
             let parents = find_parents(self, tpl, tpl, vec![])?;
+            check_include_cycles(self, tpl)?;
             for component_name in tpl.components.keys() {
                 let current_priority = self.get_template_priority(&tpl.name);
 
@@ -626,7 +631,7 @@ impl Tera {
 
         // 3rd loop: we actually set everything we've done on the templates objects
         for (name, tpl) in self.templates.iter_mut() {
-            tpl.raw_content_num_bytes += tpl_size_hint.remove(name.as_str()).unwrap();
+            tpl.raw_content_num_bytes = tpl_size_hint.remove(name.as_str()).unwrap();
             tpl.parents = tpl_parents.remove(name.as_str()).unwrap();
             tpl.block_lineage = tpl_blocks.remove(name.as_str()).unwrap();
         }
@@ -656,10 +661,7 @@ impl Tera {
     /// tera.add_raw_template("new.html", "Blabla").unwrap();
     /// ```
     pub fn add_raw_template(&mut self, name: &str, content: &str) -> TeraResult<()> {
-        let template = Template::new(name, content, None, self.delimiters)?;
-        self.templates.insert(name.to_string(), template);
-        self.finalize_templates()?;
-        Ok(())
+        self.add_raw_templates(std::iter::once((name, content)))
     }
 
     /// Add all the templates given to the Tera instance
@@ -681,22 +683,47 @@ impl Tera {
         N: AsRef<str>,
         C: AsRef<str>,
     {
-        for (name, content) in templates {
-            let template = Template::new(name.as_ref(), content.as_ref(), None, self.delimiters)?;
-            self.templates.insert(name.as_ref().to_string(), template);
+        let mut inserted: Vec<(String, Option<Template>)> = Vec::new();
+        let result = (|| -> TeraResult<()> {
+            for (name, content) in templates {
+                let template =
+                    Template::new(name.as_ref(), content.as_ref(), None, self.delimiters)?;
+                let key = name.as_ref().to_string();
+                let previous = self.templates.insert(key.clone(), template);
+                inserted.push((key, previous));
+            }
+            self.finalize_templates()
+        })();
+
+        if result.is_err() {
+            // Undo in reverse so duplicate names within the batch restore correctly.
+            for (key, previous) in inserted.into_iter().rev() {
+                match previous {
+                    Some(old) => {
+                        self.templates.insert(key, old);
+                    }
+                    None => {
+                        self.templates.remove(&key);
+                    }
+                }
+            }
         }
-
-        self.finalize_templates()?;
-
-        Ok(())
+        result
     }
 
     /// Add a template from a path: reads the file and parses it.
     /// This will return an error if the template is invalid and doesn't check the validity of
     /// the new set of templates.
-    fn add_file<P: AsRef<Path>>(&mut self, path: P, name: Option<&str>) -> TeraResult<()> {
+    fn add_file<P: AsRef<Path>>(
+        &mut self,
+        path: P,
+        name: Option<&str>,
+    ) -> TeraResult<(String, Option<Template>)> {
         let path = path.as_ref();
-        let tpl_name = name.unwrap_or_else(|| path.to_str().unwrap());
+        let path_str = path.to_str().ok_or_else(|| {
+            Error::message(format!("Template path is not valid UTF-8: {:?}", path))
+        })?;
+        let tpl_name = name.unwrap_or(path_str);
 
         let mut f = File::open(path)
             .map_err(|e| Error::chain(format!("Couldn't open template '{:?}'", path), e))?;
@@ -708,12 +735,13 @@ impl Tera {
         let template = Template::new(
             tpl_name,
             &content,
-            Some(path.to_str().unwrap().to_string()),
+            Some(path_str.to_string()),
             self.delimiters,
         )?;
 
-        self.templates.insert(tpl_name.to_string(), template);
-        Ok(())
+        let key = tpl_name.to_string();
+        let previous = self.templates.insert(key.clone(), template);
+        Ok((key, previous))
     }
 
     /// Add a single template from a path to the Tera instance. The default name for the template is
@@ -736,8 +764,7 @@ impl Tera {
         path: P,
         name: Option<&str>,
     ) -> TeraResult<()> {
-        self.add_file(path, name)?;
-        self.finalize_templates()
+        self.add_template_files(std::iter::once((path, name)))
     }
 
     /// Add several templates from paths to the Tera instance.
@@ -762,13 +789,32 @@ impl Tera {
         P: AsRef<Path>,
         N: AsRef<str>,
     {
-        for (path, name) in files {
-            self.add_file(path, name.as_ref().map(AsRef::as_ref))?;
+        let mut inserted: Vec<(String, Option<Template>)> = Vec::new();
+        let result = (|| -> TeraResult<()> {
+            for (path, name) in files {
+                let (key, previous) = self.add_file(path, name.as_ref().map(AsRef::as_ref))?;
+                inserted.push((key, previous));
+            }
+            self.finalize_templates()
+        })();
+
+        if result.is_err() {
+            for (key, previous) in inserted.into_iter().rev() {
+                match previous {
+                    Some(old) => {
+                        self.templates.insert(key, old);
+                    }
+                    None => {
+                        self.templates.remove(&key);
+                    }
+                }
+            }
         }
-        self.finalize_templates()
+        result
     }
 
-    /// Set fallback prefixes to try when a template is not found by exact name.
+    /// Set fallback prefixes to try when a template is not found by exact name. This needs to be
+    /// called before adding templates, it will error otherwise.
     ///
     /// When a template is requested (via render, extends, or include) and the exact name
     /// is not found, these prefixes are tried in order. The first prefix that produces
@@ -782,10 +828,16 @@ impl Tera {
     /// # use tera::Tera;
     /// let mut tera = Tera::default();
     /// // Templates in "themes/cool/" can be referenced without the prefix
-    /// tera.set_fallback_prefixes(vec!["themes/cool/".to_string()]);
+    /// tera.set_fallback_prefixes(vec!["themes/cool/".to_string()]).unwrap();
     /// ```
-    pub fn set_fallback_prefixes(&mut self, prefixes: Vec<String>) {
+    pub fn set_fallback_prefixes(&mut self, prefixes: Vec<String>) -> TeraResult<()> {
+        if !self.templates.is_empty() {
+            return Err(Error::message(
+                "set_fallback_prefixes must be called before adding templates",
+            ));
+        }
         self.fallback_prefixes = prefixes;
+        Ok(())
     }
 
     /// Returns the priority level for a template based on fallback_prefixes.
@@ -1015,8 +1067,6 @@ impl Tera {
     /// Renders a component by name with the given context and optional body content.
     ///
     /// The context should contain the component's arguments as key-value pairs.
-    /// Autoescape is determined by the source template's filename (e.g., components defined
-    /// in `.html` files will have autoescape enabled) with the default Tera settings.
     ///
     /// # Examples
     ///
@@ -1034,6 +1084,7 @@ impl Tera {
     ///     "Button",
     ///     &context! { label => "Click me" },
     ///     None,
+    ///     true,
     /// ).unwrap();
     /// assert_eq!(html, "<button>Click me</button>");
     ///
@@ -1042,6 +1093,7 @@ impl Tera {
     ///     "Card",
     ///     &context! { title => "My Card" },
     ///     Some("<p>Card content here</p>"),
+    ///     true,
     /// ).unwrap();
     /// assert_eq!(html, "<div><h1>My Card</h1><p>Card content here</p></div>");
     /// ```
@@ -1050,9 +1102,10 @@ impl Tera {
         component_name: &str,
         context: &Context,
         body: Option<&str>,
+        autoescape: bool,
     ) -> TeraResult<String> {
         let mut output = Vec::new();
-        self.render_component_to(component_name, context, body, &mut output)?;
+        self.render_component_to(component_name, context, body, autoescape, &mut output)?;
         Ok(String::from_utf8(output)?)
     }
 
@@ -1076,6 +1129,7 @@ impl Tera {
     ///     "Button",
     ///     &context! { label => "Click me" },
     ///     None,
+    ///     true,
     ///     &mut buffer,
     /// ).unwrap();
     /// assert_eq!(buffer, b"<button>Click me</button>");
@@ -1085,6 +1139,7 @@ impl Tera {
         component_name: &str,
         context: &Context,
         body: Option<&str>,
+        autoescape: bool,
         mut write: impl Write,
     ) -> TeraResult<()> {
         let (component_def, chunk) = self
@@ -1108,7 +1163,7 @@ impl Tera {
             )
             .map_err(Error::message)?;
 
-        let vm = VirtualMachine::new(self, template);
+        let vm = VirtualMachine::new_with_autoescape(self, template, autoescape);
         let mut state = State::new_with_chunk(&component_context, chunk);
         state.filters = Some(&self.filters);
         vm.interpret(&mut state, &mut write)?;
@@ -1202,6 +1257,20 @@ mod tests {
         assert!(result.is_err());
     }
 
+    #[test]
+    fn add_raw_template_failure_preserves_existing() {
+        let mut tera = Tera::default();
+        tera.add_raw_template("good.html", "Hello {{ name }}")
+            .unwrap();
+
+        // Parses fine but finalize rejects (unknown filter).
+        let err = tera.add_raw_template("bad.html", "{{ name | no_such_filter }}");
+        assert!(err.is_err());
+
+        assert!(tera.get_template("good.html").is_some());
+        assert!(tera.get_template("bad.html").is_none());
+    }
+
     #[test]
     fn test_render_component() {
         let mut tera = Tera::default();
@@ -1220,50 +1289,69 @@ mod tests {
 
         // Basic + defaults
         insta::assert_snapshot!(
-            tera.render_component("Button", &context! { label => "Click" }, None).unwrap(),
+            tera.render_component("Button", &context! { label => "Click" }, None, true).unwrap(),
             @r#"<button class="primary">Click</button>"#
         );
         // Override default
         insta::assert_snapshot!(
-            tera.render_component("Button", &context! { label => "X", variant => "secondary" }, None).unwrap(),
+            tera.render_component("Button", &context! { label => "X", variant => "secondary" }, None, true).unwrap(),
             @r#"<button class="secondary">X</button>"#
         );
         // With body
         insta::assert_snapshot!(
-            tera.render_component("Card", &context! { title => "T" }, Some("<p>body</p>")).unwrap(),
+            tera.render_component("Card", &context! { title => "T" }, Some("<p>body</p>"), true).unwrap(),
             @"<div><h1>T</h1><p>body</p></div>"
         );
-        // Autoescape (.html)
+        // Autoescape on
         insta::assert_snapshot!(
-            tera.render_component("Display", &context! { content => "<script>" }, None).unwrap(),
+            tera.render_component("Display", &context! { content => "<script>" }, None, true).unwrap(),
             @"&lt;script&gt;"
         );
-        // No autoescape (.txt)
+        // Autoescape off
         insta::assert_snapshot!(
-            tera.render_component("Raw", &context! { content => "<script>" }, None).unwrap(),
+            tera.render_component("Raw", &context! { content => "<script>" }, None, false).unwrap(),
             @"<script>"
         );
         // render_component_to variant
         let mut buffer = Vec::new();
-        tera.render_component_to("Button", &context! { label => "Y" }, None, &mut buffer)
-            .unwrap();
+        tera.render_component_to(
+            "Button",
+            &context! { label => "Y" },
+            None,
+            true,
+            &mut buffer,
+        )
+        .unwrap();
         insta::assert_snapshot!(String::from_utf8(buffer).unwrap(), @r#"<button class="primary">Y</button>"#);
 
         // Errors
         assert!(
-            tera.render_component("Nope", &Context::new(), None)
+            tera.render_component("Nope", &Context::new(), None, true)
                 .is_err()
         );
         assert!(
-            tera.render_component("Button", &Context::new(), None)
+            tera.render_component("Button", &Context::new(), None, true)
                 .is_err()
         );
         assert!(
-            tera.render_component("Button", &context! { label => "x", bad => "y" }, None)
+            tera.render_component("Button", &context! { label => "x", bad => "y" }, None, true)
                 .is_err()
         );
     }
 
+    #[cfg(unix)]
+    #[test]
+    fn add_template_file_errors_on_non_utf8_path() {
+        use std::ffi::OsStr;
+        use std::os::unix::ffi::OsStrExt;
+        use std::path::PathBuf;
+
+        let bad = PathBuf::from(OsStr::from_bytes(b"/tmp/\xff\xfe.html"));
+        let mut tera = Tera::default();
+        let err = tera.add_template_file(&bad, None).unwrap_err();
+        assert!(format!("{err}").contains("not valid UTF-8"));
+    }
+
     #[test]
     fn custom_delimiters() {
         let mut tera = Tera::new();
@@ -1291,7 +1379,8 @@ mod tests {
     #[test]
     fn fallback_prefixes_resolve_templates() {
         let mut tera = Tera::default();
-        tera.set_fallback_prefixes(vec!["themes/cool/".to_string()]);
+        tera.set_fallback_prefixes(vec!["themes/cool/".to_string()])
+            .unwrap();
         tera.add_raw_templates(vec![
             (
                 "themes/cool/base.html",
@@ -1312,7 +1401,8 @@ mod tests {
     #[test]
     fn fallback_prefix_exact_match_takes_priority() {
         let mut tera = Tera::default();
-        tera.set_fallback_prefixes(vec!["themes/cool/".to_string()]);
+        tera.set_fallback_prefixes(vec!["themes/cool/".to_string()])
+            .unwrap();
         tera.add_raw_templates(vec![
             ("base.html", "exact"),
             ("themes/cool/base.html", "fallback"),
@@ -1329,7 +1419,8 @@ mod tests {
         tera.set_fallback_prefixes(vec![
             "themes/child/".to_string(),
             "themes/parent/".to_string(),
-        ]);
+        ])
+        .unwrap();
 
         assert_eq!(tera.get_template_priority("index.html"), 0);
         assert_eq!(tera.get_template_priority("themes/child/base.html"), 1);
@@ -1339,7 +1430,8 @@ mod tests {
     #[test]
     fn test_component_duplicate_error_same_priority() {
         let mut tera = Tera::default();
-        tera.set_fallback_prefixes(vec!["themes/".to_string()]);
+        tera.set_fallback_prefixes(vec!["themes/".to_string()])
+            .unwrap();
 
         tera.add_raw_template("a.html", "{% component Foo() %}A{% endcomponent Foo %}")
             .unwrap();
@@ -1358,7 +1450,8 @@ mod tests {
     #[test]
     fn test_component_override_chain() {
         let mut tera = Tera::default();
-        tera.set_fallback_prefixes(vec!["child/".to_string(), "parent/".to_string()]);
+        tera.set_fallback_prefixes(vec!["child/".to_string(), "parent/".to_string()])
+            .unwrap();
 
         tera.add_raw_template(
             "parent/c.html",
@@ -1381,7 +1474,8 @@ mod tests {
     #[test]
     fn test_fallback_template_resolution() {
         let mut tera = Tera::default();
-        tera.set_fallback_prefixes(vec!["themes/cool/".to_string()]);
+        tera.set_fallback_prefixes(vec!["themes/cool/".to_string()])
+            .unwrap();
 
         tera.add_raw_template("themes/cool/base.html", "theme base")
             .unwrap();
diff --git a/tera/src/value/mod.rs b/tera/src/value/mod.rs
index 186624f3..fd95fafc 100644
--- a/tera/src/value/mod.rs
+++ b/tera/src/value/mod.rs
@@ -366,12 +366,24 @@ impl Value {
     pub fn is_u128(&self) -> bool {
         matches!(self.kind(), ValueKind::U128)
     }
+    pub fn is_i64(&self) -> bool {
+        matches!(self.kind(), ValueKind::I64)
+    }
+    pub fn is_u64(&self) -> bool {
+        matches!(self.kind(), ValueKind::U64)
+    }
+    pub fn is_f64(&self) -> bool {
+        matches!(self.kind(), ValueKind::F64)
+    }
     pub fn is_array(&self) -> bool {
         matches!(self.kind(), ValueKind::Array)
     }
     pub fn is_map(&self) -> bool {
         matches!(self.kind(), ValueKind::Map)
     }
+    pub fn is_bytes(&self) -> bool {
+        matches!(self.kind(), ValueKind::Bytes)
+    }
 
     pub(crate) fn format(&self, f: &mut impl std::io::Write) -> std::io::Result<()> {
         match &self.inner {
@@ -713,14 +725,23 @@ impl Value {
     }
 
     /// When doing hello.name, name is the attr
-    pub(crate) fn get_attr(&self, attr: &str) -> Value {
+    pub(crate) fn get_attr<'a>(&'a self, attr: &'a str) -> Option<&'a Value> {
+        // We do either a linear scan or a hashmap lookup depending on the size of the map.
+        // Linear scans can be _much_ faster for small maps
+        #[cfg(not(feature = "preserve_order"))]
+        const ATTR_SCAN_CUTOFF: usize = 6;
+        #[cfg(feature = "preserve_order")]
+        const ATTR_SCAN_CUTOFF: usize = 12;
+
         match &self.inner {
-            ValueInner::Map(m) => m.get(&Key::Str(attr)).cloned().unwrap_or(Value {
-                inner: ValueInner::Undefined,
-            }),
-            _ => Value {
-                inner: ValueInner::Undefined,
-            },
+            ValueInner::Map(m) if m.len() <= ATTR_SCAN_CUTOFF => {
+                m.iter().find_map(|(k, v)| match k.as_str() {
+                    Some(s) if s == attr => Some(v),
+                    _ => None,
+                })
+            }
+            ValueInner::Map(m) => m.get(&Key::Str(attr)),
+            _ => None,
         }
     }
 
@@ -758,6 +779,7 @@ impl Value {
         }
     }
 
+    /// This uses python semantics for slicing
     pub(crate) fn slice(
         &self,
         start: Option<i128>,
@@ -765,74 +787,60 @@ impl Value {
         step: Option<i128>,
     ) -> TeraResult<Value> {
         let step = step.unwrap_or(1);
-        let reverse = step == -1;
-
-        let get_actual_idx = |size: i128, param: Option<i128>| -> i128 {
-            if let Some(p) = param {
-                if p < 0 { size + p } else { p }
-            } else {
-                size
-            }
-        };
-
-        match &self.inner {
-            ValueInner::Array(arr) => {
-                let mut input = Vec::with_capacity(arr.len());
-                let mut out = Vec::with_capacity(arr.len());
-                let start = get_actual_idx(arr.len() as i128, start);
-                let end = get_actual_idx(arr.len() as i128, end);
-
-                for item in arr.iter() {
-                    input.push(item.clone());
-                }
-
-                if reverse {
-                    input.reverse();
-                }
-
-                for (idx, item) in input.into_iter().enumerate() {
-                    if (idx as i128) >= start && (idx as i128) < end {
-                        out.push(item);
+        if step == 0 {
+            return Err(Error::message("Slicing step cannot be 0".to_string()));
+        }
+
+        fn slice_items<T: Clone>(
+            items: &[T],
+            start: Option<i128>,
+            end: Option<i128>,
+            step: i128,
+        ) -> Vec<T> {
+            let len = items.len() as i128;
+
+            // We will need to clamp depending on the step. If step is > 0, then it's just [0, len]
+            // but if it's negative it's [-1, len - 1]. It's -1 because we need to go past idx 0
+            let (lo, hi) = if step > 0 { (0, len) } else { (-1, len - 1) };
+            let resolve = |param: Option<i128>, default: i128| -> i128 {
+                match param {
+                    None => default,
+                    Some(p) => {
+                        let p = if p < 0 { p.saturating_add(len) } else { p };
+                        p.clamp(lo, hi)
                     }
                 }
-
-                Ok(out.into())
+            };
+            let s = resolve(start, if step > 0 { lo } else { hi });
+            let e = resolve(end, if step > 0 { hi } else { lo });
+            let mut out = Vec::new();
+            let mut i = s;
+            while if step > 0 { i < e } else { i > e } {
+                out.push(items[i as usize].clone());
+                i = i.saturating_add(step);
             }
+            out
+        }
+
+        match &self.inner {
+            ValueInner::Array(arr) => Ok(slice_items(arr, start, end, step).into()),
             ValueInner::String(s) => {
                 let kind = s.kind();
-                let mut out = Vec::with_capacity(s.len());
-
                 #[cfg(feature = "unicode")]
-                let mut input: Vec<&str> = s.as_str().graphemes(true).collect();
+                let input: Vec<&str> = s.as_str().graphemes(true).collect();
                 #[cfg(not(feature = "unicode"))]
-                let mut input: Vec<char> = s.as_str().chars().collect();
+                let input: Vec<char> = s.as_str().chars().collect();
 
-                let start = get_actual_idx(input.len() as i128, start);
-                let end = get_actual_idx(input.len() as i128, end);
-
-                if reverse {
-                    input.reverse();
-                }
-
-                for (idx, item) in input.iter().enumerate() {
-                    if (idx as i128) >= start && (idx as i128) < end {
-                        out.push(*item);
-                    }
-                }
+                let parts = slice_items(&input, start, end, step);
 
                 #[cfg(feature = "unicode")]
-                {
-                    Ok(Value {
-                        inner: ValueInner::String(SmartString::new(&out.join(""), kind)),
-                    })
-                }
-
+                let out_str = parts.join("");
                 #[cfg(not(feature = "unicode"))]
-                {
-                    Ok(Value {
-                        inner: ValueInner::String(SmartString::new(&String::from_iter(out), kind)),
-                    })
-                }
+                let out_str: String = parts.into_iter().collect();
+
+                Ok(Value {
+                    inner: ValueInner::String(SmartString::new(&out_str, kind)),
+                })
             }
             _ => Err(Error::message(format!(
                 "Slicing can only be used on arrays or strings, not on `{}`.",
diff --git a/tera/src/value/number.rs b/tera/src/value/number.rs
index 26b0e0dc..2ad1e0de 100644
--- a/tera/src/value/number.rs
+++ b/tera/src/value/number.rs
@@ -149,19 +149,29 @@ pub(crate) fn floor_div(lhs: &Value, rhs: &Value) -> TeraResult<Value> {
 pub(crate) fn pow(lhs: &Value, rhs: &Value) -> TeraResult<Value> {
     match (lhs.as_number(), rhs.as_number()) {
         (Some(mut left), Some(mut right)) => {
-            if left.is_float() || right.is_float() {
+            // Convert to float is one of them is or if exponent is < 0
+            let negative_int_exp = matches!(right, Number::Integer(b) if b < 0);
+            if left.is_float() || right.is_float() || negative_int_exp {
                 left = left.into_float();
                 right = right.into_float();
             }
 
             let val = match (left, right) {
-                // TODO: check that the exponent can fit in a u32 and error otherwise?
-                (Number::Integer(a), Number::Integer(b)) => match a.checked_pow(b as u32) {
-                    Some(val) => Value::from(val),
-                    None => {
-                        return Err(Error::message(format!("Unable to perform {lhs} ** {rhs}")));
+                (Number::Integer(a), Number::Integer(b)) => {
+                    let exp = u32::try_from(b).map_err(|_| {
+                        Error::message(format!(
+                            "Exponent {b} is out of range for integer ** (must fit in u32)"
+                        ))
+                    })?;
+                    match a.checked_pow(exp) {
+                        Some(val) => Value::from(val),
+                        None => {
+                            return Err(Error::message(format!(
+                                "Unable to perform {lhs} ** {rhs}"
+                            )));
+                        }
                     }
-                },
+                }
                 (Number::Float(a), Number::Float(b)) => Value::from(a.powf(b)),
                 _ => unreachable!(),
             };
@@ -175,7 +185,14 @@ pub(crate) fn negate(val: &Value) -> TeraResult<Value> {
     if let Some(num) = val.as_number() {
         let val = match num {
             Number::Float(f) => Value::from(-f),
-            Number::Integer(f) => Value::from(-f),
+            Number::Integer(f) => match f.checked_neg() {
+                Some(n) => Value::from(n),
+                None => {
+                    return Err(Error::message(format!(
+                        "Cannot negate {f}: result would overflow i128"
+                    )));
+                }
+            },
         };
         Ok(val)
     } else {
@@ -185,3 +202,20 @@ pub(crate) fn negate(val: &Value) -> TeraResult<Value> {
         )))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn can_negate() {
+        let err = negate(&Value::from(i128::MIN)).unwrap_err();
+        assert!(err.to_string().contains("overflow"));
+        assert_eq!(negate(&Value::from(5i64)).unwrap(), Value::from(-5i64));
+        assert_eq!(negate(&Value::from(-5i64)).unwrap(), Value::from(5i64));
+        assert_eq!(
+            negate(&Value::from(i128::MAX)).unwrap(),
+            Value::from(-i128::MAX)
+        );
+    }
+}
diff --git a/tera/src/vm/for_loop.rs b/tera/src/vm/for_loop.rs
index 3a11da0e..26d5f814 100644
--- a/tera/src/vm/for_loop.rs
+++ b/tera/src/vm/for_loop.rs
@@ -248,7 +248,9 @@ impl ForLoop {
             self.current_values = (key, value);
             if self.end_ip != 0 {
                 self.loop_data.advance();
-                self.context.clear();
+                if !self.context.is_empty() {
+                    self.context.clear();
+                }
             }
         }
     }
diff --git a/tera/src/vm/interpreter.rs b/tera/src/vm/interpreter.rs
index ceadd4cf..5f681f10 100644
--- a/tera/src/vm/interpreter.rs
+++ b/tera/src/vm/interpreter.rs
@@ -4,6 +4,7 @@ use std::sync::Arc;
 use crate::errors::{Error, ErrorKind, ReportError, TeraResult};
 use crate::parsing::{Chunk, Instruction};
 use crate::template::Template;
+use crate::utils::Span;
 use crate::value::{Key, Value, ValueInner};
 use crate::vm::for_loop::ForLoop;
 use crate::vm::stack::{SpanRange, combine_spans};
@@ -15,11 +16,34 @@ use crate::{Context, Tera};
 pub(crate) struct VirtualMachine<'tera> {
     tera: &'tera Tera,
     template: &'tera Template,
+    /// Only used when rendering a single component, to decide whether to auto-escape it or not
+    autoescape_override: Option<bool>,
 }
 
 impl<'tera> VirtualMachine<'tera> {
     pub fn new(tera: &'tera Tera, template: &'tera Template) -> Self {
-        Self { tera, template }
+        Self {
+            tera,
+            template,
+            autoescape_override: None,
+        }
+    }
+
+    pub fn new_with_autoescape(
+        tera: &'tera Tera,
+        template: &'tera Template,
+        autoescape: bool,
+    ) -> Self {
+        Self {
+            tera,
+            template,
+            autoescape_override: Some(autoescape),
+        }
+    }
+
+    fn autoescape_enabled(&self) -> bool {
+        self.autoescape_override
+            .unwrap_or(self.template.autoescape_enabled)
     }
 
     pub(crate) fn interpret(
@@ -169,9 +193,8 @@ impl<'tera> VirtualMachine<'tera> {
                         if a.is_undefined() {
                             rendering_error!(format!("Field `{}` is not defined", attr), a_span);
                         }
-                        state
-                            .stack
-                            .push(a.get_attr(attr), Some(current_ip..=current_ip));
+                        let next = a.get_attr(attr).cloned().unwrap_or_else(Value::undefined);
+                        state.stack.push(next, Some(current_ip..=current_ip));
                     }
                 }
                 Instruction::BinarySubscript | Instruction::BinarySubscriptOpt => {
@@ -253,7 +276,7 @@ impl<'tera> VirtualMachine<'tera> {
                         );
                     }
 
-                    if !self.template.autoescape_enabled || top.is_safe() {
+                    if !self.autoescape_enabled() || top.is_safe() {
                         if let Some(captured) = state.capture_buffers.last_mut() {
                             top.format(captured)?;
                         } else {
@@ -640,86 +663,73 @@ impl<'tera> VirtualMachine<'tera> {
                         state.get_value(&path[0])
                     };
                     let num_attrs = path.len() - 1;
-                    for (k, attr) in path[1..].iter().enumerate() {
+                    if num_attrs > 0 {
                         if val.is_undefined() {
-                            let available_vars = state.available_variables();
-                            let available_msg = if available_vars.is_empty() {
-                                String::new()
-                            } else {
-                                format!(" Available variables: {}", available_vars.join(", "))
-                            };
-                            rendering_error!(
-                                format!(
-                                    "Variable `{}` is not defined.{available_msg}",
-                                    path[0],
-                                ),
-                                span: chunk.get_span_at(current_ip, k)
-                            );
+                            let span = chunk
+                                .get_span_at(current_ip, 0)
+                                .expect("to have a span for error");
+                            return Err(self.undefined_var_error(state, chunk, &path[0], span));
                         }
-                        let new_val = val.get_attr(attr);
-                        // Only error on intermediate undefined, not the final result
-                        if new_val.is_undefined() && k + 1 < num_attrs {
-                            let available_fields = val.available_fields();
-                            let available_msg = if available_fields.is_empty() {
-                                String::new()
-                            } else {
-                                format!(" Available fields: {}", available_fields.join(", "))
-                            };
-                            rendering_error!(
-                                format!(
-                                    "Field `{attr}` is not defined.{available_msg}",
-                                ),
-                                span: chunk.get_span_at(current_ip, k + 1)
-                            );
+                        let mut cur: &Value = &val;
+                        let mut undefined_tail = false;
+                        for (k, attr) in path[1..].iter().enumerate() {
+                            match cur.get_attr(attr) {
+                                Some(next) => cur = next,
+                                None => {
+                                    if k + 1 < num_attrs {
+                                        let span = chunk
+                                            .get_span_at(current_ip, k + 1)
+                                            .expect("to have a span for error");
+                                        return Err(
+                                            self.undefined_field_error(cur, attr, span, chunk)
+                                        );
+                                    }
+                                    undefined_tail = true;
+                                    break;
+                                }
+                            }
                         }
-                        val = new_val;
+                        val = if undefined_tail {
+                            Value::undefined()
+                        } else {
+                            cur.clone()
+                        };
                     }
                     state.stack.push(val, Some(current_ip..=current_ip));
                 }
                 Instruction::WritePath(path) => {
-                    let mut val = if path.len() == 1 && path[0] == MAGICAL_DUMP_VAR {
+                    let chunk = state.chunk.expect("to have a chunk");
+                    let root = if path.len() == 1 && path[0] == MAGICAL_DUMP_VAR {
                         state.dump_context()
                     } else {
                         state.get_value(&path[0])
                     };
-                    if val.is_undefined() {
-                        let chunk = state.chunk.expect("to have a chunk");
-                        let available_vars = state.available_variables();
-                        let available_msg = if available_vars.is_empty() {
-                            String::new()
-                        } else {
-                            format!(" Available variables: {}", available_vars.join(", "))
-                        };
-                        rendering_error!(
-                            format!(
-                                "Variable `{}` is not defined.{available_msg}",
-                                path[0],
-                            ),
-                            span: chunk.get_span_at(current_ip, 0)
-                        );
+                    if root.is_undefined() {
+                        let span = chunk
+                            .get_span_at(current_ip, 0)
+                            .expect("to have a span for error");
+                        return Err(self.undefined_var_error(state, chunk, &path[0], span));
                     }
-                    for (k, attr) in path[1..].iter().enumerate() {
-                        let new_val = val.get_attr(attr);
-                        // Check if attribute access failed (returned undefined)
-                        if new_val.is_undefined() {
-                            let chunk = state.chunk.expect("to have a chunk");
-                            let available_fields = val.available_fields();
-                            let available_msg = if available_fields.is_empty() {
-                                String::new()
-                            } else {
-                                format!(" Available fields: {}", available_fields.join(", "))
-                            };
-                            rendering_error!(
-                                format!(
-                                    "Field `{attr}` is not defined.{available_msg}",
-                                ),
-                                span: chunk.get_span_at(current_ip, k + 1)
-                            );
+                    let num_attrs = path.len() - 1;
+                    let val: &Value = if num_attrs > 0 {
+                        let mut cur: &Value = &root;
+                        for (k, attr) in path[1..].iter().enumerate() {
+                            match cur.get_attr(attr) {
+                                Some(next) => cur = next,
+                                None => {
+                                    let span = chunk
+                                        .get_span_at(current_ip, k + 1)
+                                        .expect("to have a span for error");
+                                    return Err(self.undefined_field_error(cur, attr, span, chunk));
+                                }
+                            }
                         }
-                        val = new_val;
-                    }
+                        cur
+                    } else {
+                        &root
+                    };
 
-                    if !self.template.autoescape_enabled || val.is_safe() {
+                    if !self.autoescape_enabled() || val.is_safe() {
                         if let Some(captured) = state.capture_buffers.last_mut() {
                             val.format(captured)?;
                         } else {
@@ -743,10 +753,62 @@ impl<'tera> VirtualMachine<'tera> {
         Ok(())
     }
 
+    fn undefined_var_error(
+        &self,
+        state: &State<'tera>,
+        chunk: &Chunk,
+        name: &str,
+        span: &Span,
+    ) -> Error {
+        let available_vars = state.available_variables();
+        let available_msg = if available_vars.is_empty() {
+            String::new()
+        } else {
+            format!(" Available variables: {}", available_vars.join(", "))
+        };
+        self.rendering_error(
+            format!("Variable `{name}` is not defined.{available_msg}"),
+            chunk,
+            span,
+        )
+    }
+
+    fn undefined_field_error(
+        &self,
+        parent: &Value,
+        attr: &str,
+        span: &Span,
+        chunk: &Chunk,
+    ) -> Error {
+        let available_fields = parent.available_fields();
+        let available_msg = if available_fields.is_empty() {
+            String::new()
+        } else {
+            format!(" Available fields: {}", available_fields.join(", "))
+        };
+        self.rendering_error(
+            format!("Field `{attr}` is not defined.{available_msg}"),
+            chunk,
+            span,
+        )
+    }
+
+    fn rendering_error(&self, msg: String, chunk: &Chunk, span: &Span) -> Error {
+        let (name, source) = if self.template.name != chunk.name {
+            let tpl = &self.tera.templates[&chunk.name];
+            (&tpl.name, &tpl.source)
+        } else {
+            (&self.template.name, &self.template.source)
+        };
+        let err = ReportError::new(msg, name, source, span);
+        Error::new(ErrorKind::RenderingError(Box::new(err)))
+    }
+
     fn render_component(&self, chunk: &Chunk, context: Context) -> TeraResult<String> {
         let vm = Self {
             tera: self.tera,
             template: self.template,
+            autoescape_override: self.autoescape_override,
         };
 
         let mut state = State::new_with_chunk(&context, chunk);
@@ -767,6 +829,7 @@ impl<'tera> VirtualMachine<'tera> {
         let vm = Self {
             tera: self.tera,
             template: tpl,
+            autoescape_override: self.autoescape_override,
         };
 
         // We create a dummy state for variables to be written to, but we don't keep it around