diff --git a/src/gallium/drivers/zink/zink_compiler.c b/src/gallium/drivers/zink/zink_compiler.c
index c7f7cfcefeb..a8691d445e5 100644
--- a/src/gallium/drivers/zink/zink_compiler.c
+++ b/src/gallium/drivers/zink/zink_compiler.c
@@ -2852,7 +2852,7 @@ zink_shader_compile(struct zink_screen *screen, struct zink_shader *zs, nir_shad
             need_optimize = true;
          }
 
-         if (!zink_fs_key(key)->samples &&
+         if (!zink_fs_key_base(key)->samples &&
             nir->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK)) {
             /* VK will always use gl_SampleMask[] values even if sample count is 0,
             * so we need to skip this write here to mimic GL's behavior of ignoring it
@@ -2865,14 +2865,14 @@ zink_shader_compile(struct zink_screen *screen, struct zink_shader *zs, nir_shad
             NIR_PASS_V(nir, nir_remove_dead_variables, nir_var_shader_temp, NULL);
             need_optimize = true;
          }
-         if (zink_fs_key(key)->force_dual_color_blend && nir->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_DATA1)) {
+         if (zink_fs_key_base(key)->force_dual_color_blend && nir->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_DATA1)) {
             NIR_PASS_V(nir, lower_dual_blend);
          }
-         if (zink_fs_key(key)->coord_replace_bits) {
-            NIR_PASS_V(nir, nir_lower_texcoord_replace, zink_fs_key(key)->coord_replace_bits,
-                     false, zink_fs_key(key)->coord_replace_yinvert);
+         if (zink_fs_key_base(key)->coord_replace_bits) {
+            NIR_PASS_V(nir, nir_lower_texcoord_replace, zink_fs_key_base(key)->coord_replace_bits,
+                     false, zink_fs_key_base(key)->coord_replace_yinvert);
          }
-         if (zink_fs_key(key)->force_persample_interp || zink_fs_key(key)->fbfetch_ms) {
+         if (zink_fs_key_base(key)->force_persample_interp || zink_fs_key_base(key)->fbfetch_ms) {
             nir_foreach_shader_in_variable(var, nir)
                var->data.sample = true;
             nir->info.fs.uses_sample_qualifier = true;
@@ -2880,7 +2880,7 @@ zink_shader_compile(struct zink_screen *screen, struct zink_shader *zs, nir_shad
          }
          if (nir->info.fs.uses_fbfetch_output) {
             nir_variable *fbfetch = NULL;
-            NIR_PASS_V(nir, lower_fbfetch, &fbfetch, zink_fs_key(key)->fbfetch_ms);
+            NIR_PASS_V(nir, lower_fbfetch, &fbfetch, zink_fs_key_base(key)->fbfetch_ms);
             /* old variable must be deleted to avoid spirv errors */
             fbfetch->data.mode = nir_var_shader_temp;
             nir_fixup_deref_modes(nir);
diff --git a/src/gallium/drivers/zink/zink_context.c b/src/gallium/drivers/zink/zink_context.c
index 4a7b70c8658..1307acda6c8 100644
--- a/src/gallium/drivers/zink/zink_context.c
+++ b/src/gallium/drivers/zink/zink_context.c
@@ -2299,8 +2299,8 @@ zink_update_fbfetch(struct zink_context *ctx)
       ctx->di.fbfetch.imageView = zink_csurface(ctx->fb_state.cbufs[0])->image_view;
 
       bool fbfetch_ms = ctx->fb_state.cbufs[0]->texture->nr_samples > 1;
-      if (zink_get_fs_key(ctx)->fbfetch_ms != fbfetch_ms)
-         zink_set_fs_key(ctx)->fbfetch_ms = fbfetch_ms;
+      if (zink_get_fs_base_key(ctx)->fbfetch_ms != fbfetch_ms)
+         zink_set_fs_base_key(ctx)->fbfetch_ms = fbfetch_ms;
    }
    ctx->di.fbfetch.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
    if (changed) {
diff --git a/src/gallium/drivers/zink/zink_program.c b/src/gallium/drivers/zink/zink_program.c
index acbc720e141..05a5c0945bc 100644
--- a/src/gallium/drivers/zink/zink_program.c
+++ b/src/gallium/drivers/zink/zink_program.c
@@ -1425,9 +1425,9 @@ zink_update_fs_key_samples(struct zink_context *ctx)
       return;
    nir_shader *nir = ctx->gfx_stages[MESA_SHADER_FRAGMENT]->nir;
    if (nir->info.outputs_written & (1 << FRAG_RESULT_SAMPLE_MASK)) {
-      bool samples = zink_get_fs_key(ctx)->samples;
+      bool samples = zink_get_fs_base_key(ctx)->samples;
       if (samples != (ctx->fb_state.samples > 1))
-         zink_set_fs_key(ctx)->samples = ctx->fb_state.samples > 1;
+         zink_set_fs_base_key(ctx)->samples = ctx->fb_state.samples > 1;
    }
 }
 
diff --git a/src/gallium/drivers/zink/zink_program.h b/src/gallium/drivers/zink/zink_program.h
index 73ad3453c95..806d722d014 100644
--- a/src/gallium/drivers/zink/zink_program.h
+++ b/src/gallium/drivers/zink/zink_program.h
@@ -240,21 +240,36 @@ zink_program_has_descriptors(const struct zink_program *pg)
    return pg->num_dsl > 0;
 }
 
-static inline struct zink_fs_key *
-zink_set_fs_key(struct zink_context *ctx)
+static inline struct zink_fs_key_base *
+zink_set_fs_base_key(struct zink_context *ctx)
 {
    ctx->dirty_gfx_stages |= BITFIELD_BIT(MESA_SHADER_FRAGMENT);
    return zink_screen(ctx->base.screen)->optimal_keys ?
           &ctx->gfx_pipeline_state.shader_keys_optimal.key.fs :
-          &ctx->gfx_pipeline_state.shader_keys.key[MESA_SHADER_FRAGMENT].key.fs;
+          &ctx->gfx_pipeline_state.shader_keys.key[MESA_SHADER_FRAGMENT].key.fs.base;
+}
+
+static inline const struct zink_fs_key_base *
+zink_get_fs_base_key(struct zink_context *ctx)
+{
+   return zink_screen(ctx->base.screen)->optimal_keys ?
+          &ctx->gfx_pipeline_state.shader_keys_optimal.key.fs :
+          &ctx->gfx_pipeline_state.shader_keys.key[MESA_SHADER_FRAGMENT].key.fs.base;
+}
+
+static inline struct zink_fs_key *
+zink_set_fs_key(struct zink_context *ctx)
+{
+   assert(!zink_screen(ctx->base.screen)->optimal_keys);
+   ctx->dirty_gfx_stages |= BITFIELD_BIT(MESA_SHADER_FRAGMENT);
+   return &ctx->gfx_pipeline_state.shader_keys.key[MESA_SHADER_FRAGMENT].key.fs;
 }
 
 static inline const struct zink_fs_key *
 zink_get_fs_key(struct zink_context *ctx)
 {
-   return zink_screen(ctx->base.screen)->optimal_keys ?
-          &ctx->gfx_pipeline_state.shader_keys_optimal.key.fs :
-          &ctx->gfx_pipeline_state.shader_keys.key[MESA_SHADER_FRAGMENT].key.fs;
+   assert(!zink_screen(ctx->base.screen)->optimal_keys);
+   return &ctx->gfx_pipeline_state.shader_keys.key[MESA_SHADER_FRAGMENT].key.fs;
 }
 
 static inline struct zink_gs_key *
@@ -330,13 +345,13 @@ zink_get_last_vertex_key(struct zink_context *ctx)
 static inline void
 zink_set_fs_point_coord_key(struct zink_context *ctx)
 {
-   const struct zink_fs_key *fs = zink_get_fs_key(ctx);
+   const struct zink_fs_key_base *fs = zink_get_fs_base_key(ctx);
    bool disable = ctx->gfx_pipeline_state.rast_prim != PIPE_PRIM_POINTS || !ctx->rast_state->base.sprite_coord_enable;
    uint8_t coord_replace_bits = disable ? 0 : ctx->rast_state->base.sprite_coord_enable;
    bool coord_replace_yinvert = disable ? false : !!ctx->rast_state->base.sprite_coord_mode;
    if (fs->coord_replace_bits != coord_replace_bits || fs->coord_replace_yinvert != coord_replace_yinvert) {
-      zink_set_fs_key(ctx)->coord_replace_bits = coord_replace_bits;
-      zink_set_fs_key(ctx)->coord_replace_yinvert = coord_replace_yinvert;
+      zink_set_fs_base_key(ctx)->coord_replace_bits = coord_replace_bits;
+      zink_set_fs_base_key(ctx)->coord_replace_yinvert = coord_replace_yinvert;
    }
 }
 
diff --git a/src/gallium/drivers/zink/zink_program_state.hpp b/src/gallium/drivers/zink/zink_program_state.hpp
index 4711047b04f..3111a7a277a 100644
--- a/src/gallium/drivers/zink/zink_program_state.hpp
+++ b/src/gallium/drivers/zink/zink_program_state.hpp
@@ -253,7 +253,7 @@ zink_get_gfx_pipeline(struct zink_context *ctx,
           !ctx->gfx_pipeline_state.render_pass &&
           /* TODO: is sample shading even possible to handle with GPL? */
           !ctx->gfx_stages[MESA_SHADER_FRAGMENT]->nir->info.fs.uses_sample_shading &&
-          !zink_get_fs_key(ctx)->fbfetch_ms &&
+          !zink_get_fs_base_key(ctx)->fbfetch_ms &&
           !ctx->gfx_pipeline_state.force_persample_interp &&
           !ctx->gfx_pipeline_state.min_samples) {
          /* this is the graphics pipeline library path: find/construct all partial pipelines */
diff --git a/src/gallium/drivers/zink/zink_shader_keys.h b/src/gallium/drivers/zink/zink_shader_keys.h
index 01e6e23af81..7cc7cc2dcf9 100644
--- a/src/gallium/drivers/zink/zink_shader_keys.h
+++ b/src/gallium/drivers/zink/zink_shader_keys.h
@@ -66,16 +66,22 @@ struct zink_gs_key {
    unsigned size;
 };
 
-struct zink_fs_key {
+struct zink_fs_key_base {
    bool coord_replace_yinvert : 1;
    bool samples : 1;
    bool force_dual_color_blend : 1;
    bool force_persample_interp : 1;
    bool fbfetch_ms : 1;
+   uint8_t pad : 3;
+   uint8_t coord_replace_bits;
+};
+
+struct zink_fs_key {
+   struct zink_fs_key_base base;
+   /* non-optimal bits after this point */
    bool lower_line_stipple : 1;
    bool lower_line_smooth : 1;
-   uint8_t pad : 1;
-   uint8_t coord_replace_bits;
+   uint16_t pad2 : 14;
 };
 
 struct zink_tcs_key {
@@ -100,6 +106,7 @@ struct zink_shader_key {
       struct zink_tcs_key tcs;
       struct zink_gs_key gs;
       struct zink_fs_key fs;
+      struct zink_fs_key_base fs_base;
    } key;
    struct zink_shader_key_base base;
    unsigned inline_uniforms:1;
@@ -110,7 +117,7 @@ union zink_shader_key_optimal {
    struct {
       struct zink_vs_key_base vs_base;
       struct zink_tcs_key tcs;
-      struct zink_fs_key fs;
+      struct zink_fs_key_base fs;
    };
    struct {
       uint8_t vs_bits;
@@ -120,6 +127,13 @@ union zink_shader_key_optimal {
    uint32_t val;
 };
 
+static inline const struct zink_fs_key_base *
+zink_fs_key_base(const struct zink_shader_key *key)
+{
+   assert(key);
+   return &key->key.fs.base;
+}
+
 static inline const struct zink_fs_key *
 zink_fs_key(const struct zink_shader_key *key)
 {
diff --git a/src/gallium/drivers/zink/zink_state.c b/src/gallium/drivers/zink/zink_state.c
index f3aa4bfb9a7..82987877236 100644
--- a/src/gallium/drivers/zink/zink_state.c
+++ b/src/gallium/drivers/zink/zink_state.c
@@ -434,8 +434,8 @@ zink_bind_blend_state(struct pipe_context *pctx, void *cso)
       state->dirty |= !zink_screen(pctx->screen)->have_full_ds3;
       bool force_dual_color_blend = zink_screen(pctx->screen)->driconf.dual_color_blend_by_location &&
                                     blend && blend->dual_src_blend && state->blend_state->attachments[0].blendEnable;
-      if (force_dual_color_blend != zink_get_fs_key(ctx)->force_dual_color_blend)
-         zink_set_fs_key(ctx)->force_dual_color_blend = force_dual_color_blend;
+      if (force_dual_color_blend != zink_get_fs_base_key(ctx)->force_dual_color_blend)
+         zink_set_fs_base_key(ctx)->force_dual_color_blend = force_dual_color_blend;
       ctx->blend_state_changed = true;
    }
 }
@@ -702,7 +702,7 @@ zink_bind_rasterizer_state(struct pipe_context *pctx, void *cso)
          ctx->scissor_changed = true;
 
       if (ctx->rast_state->base.force_persample_interp != force_persample_interp) {
-         zink_set_fs_key(ctx)->force_persample_interp = ctx->rast_state->base.force_persample_interp;
+         zink_set_fs_base_key(ctx)->force_persample_interp = ctx->rast_state->base.force_persample_interp;
          ctx->gfx_pipeline_state.dirty = true;
       }
       ctx->gfx_pipeline_state.force_persample_interp = ctx->rast_state->base.force_persample_interp;