diff --git a/doc/note/quirks.md b/doc/note/quirks.md
index 4606c52..1afa484 100644
--- a/doc/note/quirks.md
+++ b/doc/note/quirks.md
@@ -76,6 +76,7 @@
 Package-specific quirks:
 
 - [GIF image decoder quirks](/std/gif/decode_quirks.wuffs)
+- [JPEG decoder quirks](/std/jpeg/decode_quirks.wuffs)
 - [JSON decoder quirks](/std/json/decode_quirks.wuffs)
 - [LZMA decoder quirks](/std/lzma/decode_quirks.wuffs)
 - [LZW decoder quirks](/std/lzw/decode_quirks.wuffs)
diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c
index 8750fab..b3c4abb 100644
--- a/release/c/wuffs-unsupported-snapshot.c
+++ b/release/c/wuffs-unsupported-snapshot.c
@@ -9664,6 +9664,7 @@
 extern const char wuffs_jpeg__error__bad_scan_count[];
 extern const char wuffs_jpeg__error__missing_huffman_table[];
 extern const char wuffs_jpeg__error__missing_quantization_table[];
+extern const char wuffs_jpeg__error__rejected_progressive_jpeg[];
 extern const char wuffs_jpeg__error__truncated_input[];
 extern const char wuffs_jpeg__error__unsupported_arithmetic_coding[];
 extern const char wuffs_jpeg__error__unsupported_color_model[];
@@ -9681,6 +9682,8 @@
 
 #define WUFFS_JPEG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 51552191232u
 
+#define WUFFS_JPEG__QUIRK_REJECT_PROGRESSIVE_JPEGS 1220532224u
+
 // ---------------- Struct Declarations
 
 typedef struct wuffs_jpeg__decoder__struct wuffs_jpeg__decoder;
@@ -9908,6 +9911,7 @@
     bool f_bitstream_is_closed;
     bool f_expect_multiple_scans;
     bool f_use_lower_quality;
+    bool f_reject_progressive_jpegs;
     bool f_swizzle_immediately;
     wuffs_base__status f_swizzle_immediately_status;
     uint32_t f_swizzle_immediately_b_offsets[10];
@@ -44300,6 +44304,7 @@
 const char wuffs_jpeg__error__bad_scan_count[] = "#jpeg: bad scan count";
 const char wuffs_jpeg__error__missing_huffman_table[] = "#jpeg: missing Huffman table";
 const char wuffs_jpeg__error__missing_quantization_table[] = "#jpeg: missing Quantization table";
+const char wuffs_jpeg__error__rejected_progressive_jpeg[] = "#jpeg: rejected progressive JPEG";
 const char wuffs_jpeg__error__truncated_input[] = "#jpeg: truncated input";
 const char wuffs_jpeg__error__unsupported_arithmetic_coding[] = "#jpeg: unsupported arithmetic coding";
 const char wuffs_jpeg__error__unsupported_color_model[] = "#jpeg: unsupported color model";
@@ -44538,6 +44543,8 @@
   248u, 249u, 250u,
 };
 
+#define WUFFS_JPEG__QUIRKS_BASE 1220532224u
+
 // ---------------- Private Initializer Prototypes
 
 // ---------------- Private Function Prototypes
@@ -46455,6 +46462,10 @@
     if (self->private_impl.f_use_lower_quality) {
       return 18446744073709551615u;
     }
+  } else if (a_key == 1220532224u) {
+    if (self->private_impl.f_reject_progressive_jpegs) {
+      return 1u;
+    }
   }
   return 0u;
 }
@@ -46480,6 +46491,9 @@
   if (a_key == 2u) {
     self->private_impl.f_use_lower_quality = (a_value >= 9223372036854775808u);
     return wuffs_base__make_status(NULL);
+  } else if (a_key == 1220532224u) {
+    self->private_impl.f_reject_progressive_jpegs = (a_value != 0u);
+    return wuffs_base__make_status(NULL);
   }
   return wuffs_base__make_status(wuffs_base__error__unsupported_option);
 }
@@ -46689,7 +46703,10 @@
         goto exit;
       } else if (v_marker < 208u) {
         if (v_marker <= 194u) {
-          if (self->private_impl.f_sof_marker != 0u) {
+          if ((v_marker == 194u) && self->private_impl.f_reject_progressive_jpegs) {
+            status = wuffs_base__make_status(wuffs_jpeg__error__rejected_progressive_jpeg);
+            goto exit;
+          } else if (self->private_impl.f_sof_marker != 0u) {
             status = wuffs_base__make_status(wuffs_jpeg__error__bad_sof_marker);
             goto exit;
           }
diff --git a/std/jpeg/decode_jpeg.wuffs b/std/jpeg/decode_jpeg.wuffs
index 5616ec1..12e7a8d 100644
--- a/std/jpeg/decode_jpeg.wuffs
+++ b/std/jpeg/decode_jpeg.wuffs
@@ -18,6 +18,7 @@
 pub status "#bad scan count"
 pub status "#missing Huffman table"
 pub status "#missing Quantization table"
+pub status "#rejected progressive JPEG"
 pub status "#truncated input"
 pub status "#unsupported arithmetic coding"
 pub status "#unsupported color model"
@@ -281,7 +282,8 @@
 
         expect_multiple_scans : base.bool,
 
-        use_lower_quality : base.bool,
+        use_lower_quality        : base.bool,
+        reject_progressive_jpegs : base.bool,
 
         swizzle_immediately           : base.bool,
         swizzle_immediately_status    : base.status,
@@ -342,40 +344,21 @@
         if this.use_lower_quality {
             return 0xFFFF_FFFF_FFFF_FFFF
         }
+    } else if args.key == QUIRK_REJECT_PROGRESSIVE_JPEGS {
+        if this.reject_progressive_jpegs {
+            return 1
+        }
     }
     return 0
 }
 
-// If key is base.QUIRK_QUALITY then, when re-interpreting the value as a
-// signed i64 value, a negative quirk value opts the decoder in to a slightly
-// worse quality but leaner (less memory required) chroma upsampling algorithm.
-//
-// Negative (in i64 space) means >= 0x8000_0000_0000_0000 (in u64 space).
-//
-// Specifically, a negative quirk value uses a box filter. A non-negative quirk
-// value (including the default value, zero) uses the same triangle filter that
-// libjpeg-turbo also uses by default, which requires chroma upsampling on the
-// edges of a MCU (Minimum Coded Unit) to remember adjacent MCU's values.
-//
-// Leaner means that for common (sequential) JPEG images, the range returned by
-// decoder.workbuf_len can have a minimum value of zero, meaning that no work
-// buffer memory needs to be allocated. Decoding rarer (progressive) JPEGs will
-// still require a positive amount of work buffer memory. The exact amount
-// required depends on factors like the JPEG image's width, height, component
-// count and subsampling ratios.
-//
-// Regardless of the quirk value, as always, the workbuf_len method returns a
-// range, whose min and max can be different. The caller is able to choose
-// between providing the minimal amount of work buffer memory (for slightly
-// slower decoding) or the maximal amount (for slightly faster decoding).
-//
-// Callers that never wish to allocate work buffer memory can simply reject
-// progressive JPEGs (where workbuf_len().min_incl > 0 despite setting the
-// base.QUIRK_QUALITY key to a negative quirk value) as unsupported.
 pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status {
     if args.key == base.QUIRK_QUALITY {
         this.use_lower_quality = args.value >= 0x8000_0000_0000_0000
         return ok
+    } else if args.key == QUIRK_REJECT_PROGRESSIVE_JPEGS {
+        this.reject_progressive_jpegs = args.value <> 0
+        return ok
     }
     return base."#unsupported option"
 }
@@ -454,7 +437,9 @@
 
         } else if marker < 0xD0 {  // SOFn (Start of Frame) and friends.
             if marker <= 0xC2 {
-                if this.sof_marker <> 0 {
+                if (marker == 0xC2) and this.reject_progressive_jpegs {
+                    return "#rejected progressive JPEG"
+                } else if this.sof_marker <> 0 {
                     return "#bad SOF marker"
                 }
                 this.sof_marker = marker
diff --git a/std/jpeg/decode_quirks.wuffs b/std/jpeg/decode_quirks.wuffs
new file mode 100644
index 0000000..1676947
--- /dev/null
+++ b/std/jpeg/decode_quirks.wuffs
@@ -0,0 +1,77 @@
+// Copyright 2024 The Wuffs Authors.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+// --------
+
+// Quirks are discussed in (/doc/note/quirks.md).
+//
+// The base38 encoding of "jpeg" is 0x122FF6. Left shifting by 10 gives
+// 0x48BF_D800.
+pri const QUIRKS_BASE : base.u32 = 0x48BF_D800
+
+// --------
+
+// When this quirk value is non-zero, the decoder will not support progressive
+// JPEG images. When combined with setting base.QUIRK_QUALITY to "lower
+// quality", this means that decoding will never require any temporary "work
+// buffer" memory: decoder.workbuf_len will always return a range (a min and
+// max pair) whose minimum value is zero.
+//
+// The maximum value can still be positive, as using more memory might lead to
+// faster decoding, but a zero minimum means that it's valid for the caller to
+// not allocate any memory for a work buffer.
+//
+// When opted into lower quality decoding, the workbuf_len minimum will be zero
+// and positive for sequential and progressive JPEGs respectively, regardless
+// of this QUIRK_REJECT_PROGRESSIVE_JPEGS key's value. But setting this quirk
+// explicitly will produce a "#rejected progressive JPEG" error when
+// encountering a progressive JPEG. This results in more readable calling code,
+// instead of commenting about "positive work buffer minimum length implies a
+// progressive JPEG".
+pub const QUIRK_REJECT_PROGRESSIVE_JPEGS : base.u32 = 0x48BF_D800 | 0x00
+
+// --------
+
+// The base.QUIRK_QUALITY key is defined in the base package, not this package.
+// Still, here's some documentation on how this package responds to that (key,
+// value) quirk pair.
+//
+// If decoder.set_quirk is passed a base.QUIRK_QUALITY as the key argument
+// then, when re-interpreting the u64 value argument as a signed i64 number, a
+// negative number opts the decoder in to a slightly worse quality but leaner
+// (less memory required) chroma upsampling algorithm.
+//
+// Negative (in i64 space) means >= 0x8000_0000_0000_0000 (in u64 space).
+// base.QUIRK_QUALITY__VALUE__LOWER_QUALITY is one such value.
+//
+// Specifically, a negative quirk value uses a box filter. A non-negative quirk
+// value (including the default value, zero) uses the same triangle filter that
+// libjpeg-turbo also uses by default, which requires chroma upsampling on the
+// edges of a MCU (Minimum Coded Unit) to remember adjacent MCU's values.
+//
+// Leaner means that for common (sequential) JPEG images, the range returned by
+// decoder.workbuf_len will have a minimum value of zero, meaning that no work
+// buffer memory needs to be allocated. Decoding rarer (progressive) JPEGs will
+// still always require a positive amount of work buffer memory, for reasons
+// unrelated to chroma upsampling. The exact amount required depends on factors
+// like the JPEG image's width, height, component count and subsampling ratios.
+//
+// Regardless of the quirk value, as always, the workbuf_len method returns a
+// range, whose min and max can be different. The caller is able to choose
+// between providing the minimal amount of work buffer memory (for slightly
+// slower decoding) or the maximal amount (for slightly faster decoding).
+//
+// Callers that never wish to allocate work buffer memory can simply reject
+// progressive JPEGs (where "workbuf_len().min_incl > 0" despite setting the
+// base.QUIRK_QUALITY key to a negative quirk value) as unsupported. See also
+// QUIRK_REJECT_PROGRESSIVE_JPEGS.
+//
+// For some pictures comparing box and triangle filter decodings, see
+// https://nigeltao.github.io/blog/2024/jpeg-chroma-upsampling.html