diff --git a/askama_derive/src/generator/expr.rs b/askama_derive/src/generator/expr.rs
index 34acdb41..f4f374d8 100644
--- a/askama_derive/src/generator/expr.rs
+++ b/askama_derive/src/generator/expr.rs
@@ -363,16 +363,16 @@ impl<'a> Generator<'a, '_> {
         if let Expr::Var(name) = **obj {
             if name == "loop" {
                 if attr.name == "index" {
-                    buf.write("(_loop_item.index + 1)");
+                    buf.write("(__askama_item.index + 1)");
                     return Ok(DisplayWrap::Unwrapped);
                 } else if attr.name == "index0" {
-                    buf.write("_loop_item.index");
+                    buf.write("__askama_item.index");
                     return Ok(DisplayWrap::Unwrapped);
                 } else if attr.name == "first" {
-                    buf.write("(_loop_item.index == 0)");
+                    buf.write("(__askama_item.index == 0)");
                     return Ok(DisplayWrap::Unwrapped);
                 } else if attr.name == "last" {
-                    buf.write("_loop_item.last");
+                    buf.write("__askama_item.last");
                     return Ok(DisplayWrap::Unwrapped);
                 } else {
                     return Err(ctx.generate_error("unknown loop variable", obj.span()));
@@ -476,7 +476,7 @@ impl<'a> Generator<'a, '_> {
                                     if _len == 0 {\
                                         return askama::helpers::core::result::Result::Err(askama::Error::Fmt);\
                                     }\
-                                    _cycle[_loop_item.index % _len]\
+                                    _cycle[__askama_item.index % _len]\
                                 })",
                             );
                             }
diff --git a/askama_derive/src/generator/node.rs b/askama_derive/src/generator/node.rs
index 36af5838..cf5d49d1 100644
--- a/askama_derive/src/generator/node.rs
+++ b/askama_derive/src/generator/node.rs
@@ -518,35 +518,45 @@ impl<'a> Generator<'a, '_> {
             let flushed = this.write_buf_writable(ctx, buf)?;
             buf.write('{');
             if has_else_nodes {
-                buf.write("let mut _did_loop = false;");
+                buf.write("let mut __askama_did_loop = false;");
             }
             match &*loop_block.iter {
-                Expr::Range(_, _, _) => buf.write(format_args!("let _iter = {expr_code};")),
-                Expr::Array(..) => buf.write(format_args!("let _iter = {expr_code}.iter();")),
+                Expr::Range(_, _, _) => buf.write(format_args!("let __askama_iter = {expr_code};")),
+                Expr::Array(..) => {
+                    buf.write(format_args!("let __askama_iter = {expr_code}.iter();"));
+                }
                 // If `iter` is a call then we assume it's something that returns
                 // an iterator. If not then the user can explicitly add the needed
                 // call without issues.
                 Expr::Call { .. } | Expr::Index(..) => {
-                    buf.write(format_args!("let _iter = ({expr_code}).into_iter();"));
+                    buf.write(format_args!(
+                        "let __askama_iter = ({expr_code}).into_iter();"
+                    ));
                 }
                 // If accessing `self` then it most likely needs to be
                 // borrowed, to prevent an attempt of moving.
                 _ if expr_code.starts_with("self.") => {
-                    buf.write(format_args!("let _iter = (&{expr_code}).into_iter();"));
+                    buf.write(format_args!(
+                        "let __askama_iter = (&{expr_code}).into_iter();"
+                    ));
                 }
                 // If accessing a field then it most likely needs to be
                 // borrowed, to prevent an attempt of moving.
                 Expr::Attr(..) => {
-                    buf.write(format_args!("let _iter = (&{expr_code}).into_iter();"));
+                    buf.write(format_args!(
+                        "let __askama_iter = (&{expr_code}).into_iter();"
+                    ));
                 }
                 // Otherwise, we borrow `iter` assuming that it implements `IntoIterator`.
-                _ => buf.write(format_args!("let _iter = ({expr_code}).into_iter();")),
+                _ => buf.write(format_args!(
+                    "let __askama_iter = ({expr_code}).into_iter();"
+                )),
             }
             if let Some(cond) = &loop_block.cond {
                 this.push_locals(|this| {
-                    buf.write("let _iter = _iter.filter(|");
+                    buf.write("let __askama_iter = __askama_iter.filter(|");
                     this.visit_target(buf, true, true, &loop_block.var);
-                    buf.write("| -> bool {");
+                    buf.write("| -> askama::helpers::core::primitive::bool {");
                     this.visit_expr(ctx, buf, cond)?;
                     buf.write("});");
                     Ok(0)
@@ -556,10 +566,12 @@ impl<'a> Generator<'a, '_> {
             let size_hint1 = this.push_locals(|this| {
                 buf.write("for (");
                 this.visit_target(buf, true, true, &loop_block.var);
-                buf.write(", _loop_item) in askama::helpers::TemplateLoop::new(_iter) {");
+                buf.write(
+                    ", __askama_item) in askama::helpers::TemplateLoop::new(__askama_iter) {",
+                );
 
                 if has_else_nodes {
-                    buf.write("_did_loop = true;");
+                    buf.write("__askama_did_loop = true;");
                 }
                 let mut size_hint1 = this.handle(ctx, &loop_block.body, buf, AstLevel::Nested)?;
                 this.handle_ws(loop_block.ws2);
@@ -570,7 +582,7 @@ impl<'a> Generator<'a, '_> {
 
             let size_hint2;
             if has_else_nodes {
-                buf.write("if !_did_loop {");
+                buf.write("if !__askama_did_loop {");
                 size_hint2 = this.push_locals(|this| {
                     let mut size_hint =
                         this.handle(ctx, &loop_block.else_nodes, buf, AstLevel::Nested)?;