diff --git a/module/ice-9/psyntax.scm b/module/ice-9/psyntax.scm
index d09415481..9c772e625 100644
--- a/module/ice-9/psyntax.scm
+++ b/module/ice-9/psyntax.scm
@@ -498,6 +498,7 @@
     ;;               (begin)                         begin
     ;;               (define)                        define
     ;;               (define-syntax)                 define-syntax
+    ;;               (define-syntax-parameter)       define-syntax-parameter
     ;;               (local-syntax . rec?)           let-syntax/letrec-syntax
     ;;               (eval-when)                     eval-when
     ;;               (syntax . (<var> . <level>))    pattern variables
@@ -507,11 +508,11 @@
     ;; <level>   ::= <nonnegative integer>
     ;; <var>     ::= variable returned by build-lexical-var
 
-    ;; a macro is a user-defined syntactic-form.  a core is a system-defined
-    ;; syntactic form.  begin, define, define-syntax, and eval-when are
-    ;; treated specially since they are sensitive to whether the form is
-    ;; at top-level and (except for eval-when) can denote valid internal
-    ;; definitions.
+    ;; a macro is a user-defined syntactic-form.  a core is a
+    ;; system-defined syntactic form.  begin, define, define-syntax,
+    ;; define-syntax-parameter, and eval-when are treated specially
+    ;; since they are sensitive to whether the form is at top-level and
+    ;; (except for eval-when) can denote valid internal definitions.
 
     ;; a pattern variable is a variable introduced by syntax-case and can
     ;; be referenced only within a syntax form.
@@ -982,7 +983,7 @@
                             (lambda () x))
                           (lambda ()
                             (build-global-definition s var (chi e r w mod)))))))
-                  ((define-syntax-form)
+                  ((define-syntax-form define-syntax-parameter-form)
                    (let* ((id (wrap value w mod))
                           (label (gen-label))
                           (var (syntax-object-expression id)))
@@ -1111,6 +1112,7 @@
     ;;    begin                  none          begin keyword
     ;;    define                 none          define keyword
     ;;    define-syntax          none          define-syntax keyword
+    ;;    define-syntax-parameter none         define-syntax-parameter keyword
     ;;    local-syntax           rec?          letrec-syntax/let-syntax keyword
     ;;    eval-when              none          eval-when keyword
     ;;    syntax                 level         pattern variable
@@ -1121,18 +1123,20 @@
     ;;    begin-form             none          begin expression
     ;;    define-form            id            variable definition
     ;;    define-syntax-form     id            syntax definition
+    ;;    define-syntax-parameter-form id      syntax parameter definition
     ;;    local-syntax-form      rec?          syntax definition
     ;;    eval-when-form         none          eval-when form
     ;;    constant               none          self-evaluating datum
     ;;    other                  none          anything else
     ;;
-    ;; For define-form and define-syntax-form, e is the rhs expression.
-    ;; For all others, e is the entire form.  w is the wrap for e.
-    ;; s is the source for the entire form. mod is the module for e.
+    ;; For definition forms (define-form, define-syntax-parameter-form,
+    ;; and define-syntax-form), e is the rhs expression.  For all
+    ;; others, e is the entire form.  w is the wrap for e.  s is the
+    ;; source for the entire form. mod is the module for e.
     ;;
-    ;; syntax-type expands macros and unwraps as necessary to get to
-    ;; one of the forms above.  It also parses define and define-syntax
-    ;; forms, although perhaps this should be done by the consumer.
+    ;; syntax-type expands macros and unwraps as necessary to get to one
+    ;; of the forms above.  It also parses definition forms, although
+    ;; perhaps this should be done by the consumer.
 
     (define syntax-type
       (lambda (e r w s rib mod for-car?)
@@ -1203,8 +1207,12 @@
                    (syntax-case e ()
                      ((_ name val)
                       (id? #'name)
-                      (values 'define-syntax-form #'name
-                              #'val w s mod))))
+                      (values 'define-syntax-form #'name #'val w s mod))))
+                  ((define-syntax-parameter)
+                   (syntax-case e ()
+                     ((_ name val)
+                      (id? #'name)
+                      (values 'define-syntax-parameter-form #'name #'val w s mod))))
                   (else
                    (values 'call #f e w s mod)))))))
          ((syntax-object? e)
@@ -1269,7 +1277,7 @@
                 (if (memq 'eval when-list)
                     (chi-sequence #'(e1 e2 ...) r w s mod)
                     (chi-void))))))
-          ((define-form define-syntax-form)
+          ((define-form define-syntax-form define-syntax-parameter-form)
            (syntax-violation #f "definition in expression context"
                              e (wrap value w mod)))
           ((syntax)
@@ -1424,7 +1432,7 @@
                                     (cons id var-ids)
                                     (cons var vars) (cons (cons er (wrap e w mod)) vals)
                                     (cons (make-binding 'lexical var) bindings)))))
-                        ((define-syntax-form)
+                        ((define-syntax-form define-syntax-parameter-form)
                          (let ((id (wrap value w mod)) (label (gen-label)))
                            (extend-ribcage! ribcage id label)
                            (parse (cdr body)
@@ -2252,6 +2260,7 @@
     (global-extend 'define 'define '())
 
     (global-extend 'define-syntax 'define-syntax '())
+    (global-extend 'define-syntax-parameter 'define-syntax-parameter '())
 
     (global-extend 'eval-when 'eval-when '())