diff --git a/goof-impl.scm b/goof-impl.scm
index f358d01..91a6365 100644
--- a/goof-impl.scm
+++ b/goof-impl.scm
@@ -34,12 +34,14 @@
   :gen
   ;; auxiliary auxiliary syntax
   ;; for vectoring
-  :length :fill 
+  :length :fill
+  ;;for up-from and down-to
+  :to :by
   ;; Internal syntax. %acc is turned into :acc by the forify macro
   ;; it is used make it possible to report an error if :acc is used in
   ;; one of the simple macros.
-  %acc
-  )
+  %acc)
+
 
 
 (include "goof/iterators.scm")
diff --git a/goof.scm b/goof.scm
index dc2b660..a2c0127 100644
--- a/goof.scm
+++ b/goof.scm
@@ -50,6 +50,7 @@
             
             :when :unless :break :final :let :let* :subloop :for :acc
             :length :fill
+            :to :by
 
             in
             in-list
@@ -178,11 +179,14 @@
   (syntax-rules ()
     ((_ loop-name final-fun () ((v s) ...))
      (loop-name s ...))
+    ;; This is somewhat of an ugly thing. We want to test (or user-finals ...)
+    ;; before updating the loop variables, but we want to update the loop variables
+    ;; before running the final-fun.
     ((_ loop-name final-fun (user-finals ...) ((v s) ...))
-     (let ((v s) ...)
-       (if (or user-finals ...)
-           final-fun
-           (loop-name v ...))))))
+     (if (or user-finals ...)
+         (let ((v s) ...)
+           final-fun)
+         (loop-name s ...)))))
 
      
 (define (syntax->list stx)
diff --git a/goof/iterators.scm b/goof/iterators.scm
index fda6815..dc7f48c 100644
--- a/goof/iterators.scm
+++ b/goof/iterators.scm
@@ -1,6 +1,6 @@
 ;; iterators.scm - iterators for goof-loop. 
 ;;
-;; Copyright 2020 Linus Björnstam
+;; Copyright 2020-2021 Linus Björnstam
 ;; Copyright 2000-2015 Alex Shinn (original author of chibi-loop)
 ;; All rights reserved.
 ;;
@@ -258,18 +258,18 @@
          (g))))))
 
 (define-syntax up-from
-  (syntax-rules (to by)
+  (syntax-rules (:to :by)
     ((up-from :for (() . args) next . rest)
      (up-from :for ((var) . args) next . rest))
-    ((up-from :for ((var) (start (to limit) (by step))) next . rest)
+    ((up-from :for ((var) (start (:to limit) (:by step))) next . rest)
      (next ((s start) (l limit) (e step))
            ((var s (+ var e)))
            ((>= var l))
            () () . rest))
-    ((up-from :for ((var) (start (to limit))) next . rest)
+    ((up-from :for ((var) (start (:to limit))) next . rest)
      (next ((s start) (l limit)) ((var s (+ var 1)))
            ((>= var l)) () () . rest))
-    ((up-from :for ((var) (start (by step))) next . rest)
+    ((up-from :for ((var) (start (:by step))) next . rest)
      (next ((s start) (e step))
            ((var s (+ var e))) () () () . rest))
     ((up-from :for ((var) (start)) next . rest)
@@ -282,18 +282,18 @@
      (up-from :for ((var) (start limit 1)) next . rest))))
 
 (define-syntax down-from
-  (syntax-rules (to by)
+  (syntax-rules (:to :by)
     ((down-from :for (() . args) next . rest)
      (down-from :for ((var) . args) next . rest))
-    ((down-from :for ((var) (start (to limit) (by step))) next . rest)
+    ((down-from :for ((var) (start (:to limit) (:by step))) next . rest)
      (next ((s start) (l limit) (e step))
            ((var (- s e) (- var e)))
            ((< var l))
            () () . rest))
-    ((down-from :for ((var) (start (to limit))) next . rest)
+    ((down-from :for ((var) (start (:to limit))) next . rest)
      (next ((s start) (l limit)) ((var (- s 1) (- var 1)))
            ((< var l)) () () . rest))
-    ((down-from :for ((var) (start (by step))) next . rest)
+    ((down-from :for ((var) (start (:by step))) next . rest)
      (next ((s start) (e step)) ((var (- s e) (- var e)))
            () () () . rest))
     ((down-from :for ((var) (start)) next . rest)