diff --git a/blackbox.c b/blackbox.c
index 1546d91..c0417ec 100644
--- a/blackbox.c
+++ b/blackbox.c
@@ -210,7 +210,7 @@ static char *validate_params(game_params *params, int full)
  * Then we obfuscate it.
  */
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int nballs = params->minballs, i;
@@ -251,7 +251,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int nballs, dlen = strlen(desc), i;
     unsigned char *bmp;
diff --git a/bridges.c b/bridges.c
index a5eef25..d60036b 100644
--- a/bridges.c
+++ b/bridges.c
@@ -1735,7 +1735,7 @@ static int solve_from_scratch(game_state *state, int difficulty)
 
 /* --- New game functions --- */
 
-static game_state *new_state(game_params *params)
+static game_state *new_state(const game_params *params)
 {
     game_state *ret = snew(game_state);
     int wh = params->w * params->h, i;
@@ -1845,7 +1845,7 @@ static void free_game(game_state *state)
 
 #define ORDER(a,b) do { if (a < b) { int tmp=a; int a=b; int b=tmp; } } while(0)
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     game_state *tobuild  = NULL;
@@ -2015,7 +2015,7 @@ generated:
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int i, wh = params->w * params->h;
 
diff --git a/cube.c b/cube.c
index 15c479b..380e330 100644
--- a/cube.c
+++ b/cube.c
@@ -315,7 +315,8 @@ static char *encode_params(game_params *params, int full)
 }
 typedef void (*egc_callback)(void *, struct grid_square *);
 
-static void enum_grid_squares(game_params *params, egc_callback callback, void *ctx)
+static void enum_grid_squares(const game_params *params, egc_callback callback,
+                              void *ctx)
 {
     const struct solid *solid = solids[params->solid];
 
@@ -597,7 +598,7 @@ static void classify_grid_square_callback(void *ctx, struct grid_square *sq)
 	data->squareindex++;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     struct grid_data data;
@@ -845,7 +846,7 @@ static struct solid *transform_poly(const struct solid *solid, int flip,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int area = grid_area(params->d1, params->d2, solids[params->solid]->order);
     int i, j;
diff --git a/devel.but b/devel.but
index c218cd1..e95e1d2 100644
--- a/devel.but
+++ b/devel.but
@@ -655,7 +655,7 @@ a descriptive-format game ID.
 
 \S{backend-new-desc} \cw{new_desc()}
 
-\c char *(*new_desc)(game_params *params, random_state *rs,
+\c char *(*new_desc)(const game_params *params, random_state *rs,
 \c                   char **aux, int interactive);
 
 This function is where all the really hard work gets done. This is
@@ -696,7 +696,7 @@ again in the game description.
 
 \S{backend-validate-desc} \cw{validate_desc()}
 
-\c char *(*validate_desc)(game_params *params, char *desc);
+\c char *(*validate_desc)(const game_params *params, char *desc);
 
 This function is given a game description, and its job is to
 validate that it describes a puzzle which makes sense.
diff --git a/dominosa.c b/dominosa.c
index 2662410..d80425c 100644
--- a/dominosa.c
+++ b/dominosa.c
@@ -545,7 +545,7 @@ static int solver(int w, int h, int n, int *grid, int *output)
  * End of solver code.
  */
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int n = params->n, w = n+2, h = n+1, wh = w*h;
@@ -746,7 +746,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int n = params->n, w = n+2, h = n+1, wh = w*h;
     int *occurrences;
diff --git a/fifteen.c b/fifteen.c
index 1a106e8..06e738b 100644
--- a/fifteen.c
+++ b/fifteen.c
@@ -155,7 +155,7 @@ static int perm_parity(int *perm, int n)
     return ret;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int gap, n, i, x;
@@ -271,7 +271,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     char *p, *err;
     int i, area;
diff --git a/filling.c b/filling.c
index a0c9fc4..4cd4318 100644
--- a/filling.c
+++ b/filling.c
@@ -867,7 +867,7 @@ static void minimize_clue_set(int *board, int w, int h, int *randomize) {
     sfree(board_cp);
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
                            char **aux, int interactive)
 {
     const int w = params->w;
@@ -906,7 +906,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return game_description;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int i;
     const int sz = params->w * params->h;
diff --git a/flip.c b/flip.c
index c30e484..e42e8c0 100644
--- a/flip.c
+++ b/flip.c
@@ -347,7 +347,7 @@ static void addneighbours(tree234 *t, int w, int h, int cx, int cy,
     addsq(t, w, h, cx, cy, x, y+1, matrix);
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int w = params->w, h = params->h, wh = w * h;
@@ -596,7 +596,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->w, h = params->h, wh = w * h;
     int mlen = (wh*wh+3)/4, glen = (wh+3)/4;
diff --git a/galaxies.c b/galaxies.c
index db89700..bd0e982 100644
--- a/galaxies.c
+++ b/galaxies.c
@@ -1233,7 +1233,7 @@ static void generate_pass(game_state *state, random_state *rs, int *scratch,
 static int check_complete(game_state *state, int *dsf, int *colours);
 static int solver_state(game_state *state, int maxdiff);
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     game_state *state = blank_game(params->w, params->h), *copy;
@@ -1480,7 +1480,7 @@ static int dots_too_close(game_state *state)
     return (ret == -1) ? 1 : 0;
 }
 
-static game_state *load_game(game_params *params, char *desc,
+static game_state *load_game(const game_params *params, char *desc,
                              char **why_r)
 {
     game_state *state = blank_game(params->w, params->h);
@@ -1528,7 +1528,7 @@ fail:
     return NULL;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     char *why = NULL;
     game_state *dummy = load_game(params, desc, &why);
diff --git a/guess.c b/guess.c
index 15cf0d9..b4374ba 100644
--- a/guess.c
+++ b/guess.c
@@ -264,7 +264,7 @@ static void free_pegrow(pegrow pegs)
     sfree(pegs);
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     unsigned char *bmp = snewn(params->npegs, unsigned char);
@@ -287,7 +287,7 @@ newcol:
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     unsigned char *bmp;
     int i;
diff --git a/inertia.c b/inertia.c
index eb850ac..590be69 100644
--- a/inertia.c
+++ b/inertia.c
@@ -583,13 +583,13 @@ static char *gengrid(int w, int h, random_state *rs)
     return grid;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     return gengrid(params->w, params->h, rs);
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->w, h = params->h, wh = w*h;
     int starts = 0, gems = 0, i;
diff --git a/keen.c b/keen.c
index e951dba..ccda002 100644
--- a/keen.c
+++ b/keen.c
@@ -740,7 +740,7 @@ static char *parse_block_structure(const char **p, int w, int *dsf)
     return NULL;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int w = params->w, a = w*w;
@@ -1145,7 +1145,7 @@ done
  * Gameplay.
  */
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->w, a = w*w;
     int *dsf;
diff --git a/lightup.c b/lightup.c
index 9131428..97ccc2a 100644
--- a/lightup.c
+++ b/lightup.c
@@ -367,7 +367,7 @@ static char *validate_params(game_params *params, int full)
 
 /* --- Game state construction/freeing helper functions --- */
 
-static game_state *new_state(game_params *params)
+static game_state *new_state(const game_params *params)
 {
     game_state *ret = snew(game_state);
 
@@ -568,7 +568,8 @@ static void clean_board(game_state *state, int leave_blacks)
     state->nlights = 0;
 }
 
-static void set_blacks(game_state *state, game_params *params, random_state *rs)
+static void set_blacks(game_state *state, const game_params *params,
+                       random_state *rs)
 {
     int x, y, degree = 0, rotate = 0, nblack;
     int rh, rw, i;
@@ -1516,9 +1517,11 @@ static int puzzle_is_good(game_state *state, int difficulty)
 
 #define MAX_GRIDGEN_TRIES 20
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params_in, random_state *rs,
 			   char **aux, int interactive)
 {
+    game_params params_copy = *params_in; /* structure copy */
+    game_params *params = &params_copy;
     game_state *news = new_state(params), *copys;
     int i, j, run, x, y, wh = params->w*params->h, num;
     char *ret, *p;
@@ -1625,7 +1628,7 @@ goodpuzzle:
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int i;
     for (i = 0; i < params->w*params->h; i++) {
diff --git a/loopy.c b/loopy.c
index 6b3d53e..68cf646 100644
--- a/loopy.c
+++ b/loopy.c
@@ -231,7 +231,7 @@ struct game_drawstate {
     char *clue_satisfied;
 };
 
-static char *validate_desc(game_params *params, char *desc);
+static char *validate_desc(const game_params *params, char *desc);
 static int dot_order(const game_state* state, int i, char line_type);
 static int face_order(const game_state* state, int i, char line_type);
 static solver_state *solve_game_rec(const solver_state *sstate);
@@ -277,7 +277,7 @@ static const struct {
 /* Generates a (dynamically allocated) new grid, according to the
  * type and size requested in params.  Does nothing if the grid is already
  * generated. */
-static grid *loopy_generate_grid(game_params *params, char *grid_desc)
+static grid *loopy_generate_grid(const game_params *params, char *grid_desc)
 {
     return grid_new(grid_types[params->type], params->w, params->h, grid_desc);
 }
@@ -713,7 +713,7 @@ static char *extract_grid_desc(char **desc)
 
 /* We require that the params pass the test in validate_params and that the
  * description fills the entire game area */
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int count = 0;
     grid *g;
@@ -1364,7 +1364,7 @@ static game_state *remove_clues(game_state *state, random_state *rs,
 }
 
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
                            char **aux, int interactive)
 {
     /* solution and description both use run-length encoding in obvious ways */
diff --git a/magnets.c b/magnets.c
index e9b8c7d..2f56c7c 100644
--- a/magnets.c
+++ b/magnets.c
@@ -422,7 +422,8 @@ badchar:
     return NULL;
 }
 
-static game_state *new_game_int(game_params *params, char *desc, const char **prob)
+static game_state *new_game_int(const game_params *params, char *desc,
+                                const char **prob)
 {
     game_state *state = new_state(params->w, params->h);
     int x, y, idx, *count;
@@ -529,7 +530,7 @@ done:
     return state;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     const char *prob;
     game_state *st = new_game_int(params, desc, &prob);
@@ -1603,7 +1604,7 @@ static void generate_aux(game_state *new, char *aux)
     aux[new->wh] = '\0';
 }
 
-static int check_difficulty(game_params *params, game_state *new,
+static int check_difficulty(const game_params *params, game_state *new,
                             random_state *rs)
 {
     int *scratch, *grid_correct, slen, i;
@@ -1675,7 +1676,7 @@ static int check_difficulty(game_params *params, game_state *new,
     return 0;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux_r, int interactive)
 {
     game_state *new = new_state(params->w, params->h);
diff --git a/map.c b/map.c
index af7c0af..34a9536 100644
--- a/map.c
+++ b/map.c
@@ -1393,7 +1393,7 @@ static int map_solver(struct solver_scratch *sc,
  * Game generation main function.
  */
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     struct solver_scratch *sc = NULL;
@@ -1704,7 +1704,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *parse_edge_list(game_params *params, char **desc, int *map)
+static char *parse_edge_list(const game_params *params, char **desc, int *map)
 {
     int w = params->w, h = params->h, wh = w*h, n = params->n;
     int i, k, pos, state;
@@ -1780,7 +1780,7 @@ static char *parse_edge_list(game_params *params, char **desc, int *map)
     return NULL;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->w, h = params->h, wh = w*h, n = params->n;
     int area;
diff --git a/mines.c b/mines.c
index abd1ad8..f8adcd3 100644
--- a/mines.c
+++ b/mines.c
@@ -1955,7 +1955,7 @@ static char *new_mine_layout(int w, int h, int n, int x, int y, int unique,
     return grid;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     /*
@@ -1994,7 +1994,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     }
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int wh = params->w * params->h;
     int x, y;
diff --git a/net.c b/net.c
index 2e19f1f..13aa191 100644
--- a/net.c
+++ b/net.c
@@ -1126,7 +1126,7 @@ static void perturb(int w, int h, unsigned char *tiles, int wrapping,
     sfree(perimeter);
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     tree234 *possibilities, *barriertree;
@@ -1545,7 +1545,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return desc;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->width, h = params->height;
     int i;
diff --git a/netslide.c b/netslide.c
index 8d18652..e3fc901 100644
--- a/netslide.c
+++ b/netslide.c
@@ -324,7 +324,7 @@ static char *validate_params(game_params *params, int full)
  * Randomly select a new game description.
  */
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     tree234 *possibilities, *barriertree;
@@ -696,7 +696,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return desc;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->width, h = params->height;
     int i;
diff --git a/nullgame.c b/nullgame.c
index 4e68bf2..e315d00 100644
--- a/nullgame.c
+++ b/nullgame.c
@@ -83,13 +83,13 @@ static char *validate_params(game_params *params, int full)
     return NULL;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     return dupstr("FIXME");
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     return NULL;
 }
diff --git a/pattern.c b/pattern.c
index 300a1b3..a10d8a3 100644
--- a/pattern.c
+++ b/pattern.c
@@ -662,7 +662,7 @@ static unsigned char *generate_soluble(random_state *rs, int w, int h)
     return grid;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     unsigned char *grid;
@@ -749,7 +749,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return desc;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int i, n, rowspace;
     char *p;
diff --git a/pearl.c b/pearl.c
index ed1ee16..1159c04 100644
--- a/pearl.c
+++ b/pearl.c
@@ -1158,7 +1158,7 @@ void pearl_loopgen(int w, int h, char *lines, random_state *rs)
 #endif
 }
 
-static int new_clues(game_params *params, random_state *rs,
+static int new_clues(const game_params *params, random_state *rs,
                      char *clues, char *grid)
 {
     int w = params->w, h = params->h, diff = params->difficulty;
@@ -1356,7 +1356,7 @@ static int new_clues(game_params *params, random_state *rs,
     return ngen;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     char *grid, *clues;
@@ -1393,7 +1393,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return desc;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int i, sizesofar;
     const int totalsize = params->w * params->h;
diff --git a/pegs.c b/pegs.c
index 3dac5fc..066ab09 100644
--- a/pegs.c
+++ b/pegs.c
@@ -503,7 +503,7 @@ static void pegs_generate(unsigned char *grid, int w, int h, random_state *rs)
  * it as part of the puzzle.
  */
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int w = params->w, h = params->h;
@@ -660,7 +660,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int len = params->w * params->h;
 
diff --git a/puzzles.h b/puzzles.h
index 8232692..421d030 100644
--- a/puzzles.h
+++ b/puzzles.h
@@ -487,9 +487,9 @@ struct game {
     config_item *(*configure)(game_params *params);
     game_params *(*custom_params)(config_item *cfg);
     char *(*validate_params)(game_params *params, int full);
-    char *(*new_desc)(game_params *params, random_state *rs,
+    char *(*new_desc)(const game_params *params, random_state *rs,
 		      char **aux, int interactive);
-    char *(*validate_desc)(game_params *params, char *desc);
+    char *(*validate_desc)(const game_params *params, char *desc);
     game_state *(*new_game)(midend *me, game_params *params, char *desc);
     game_state *(*dup_game)(game_state *state);
     void (*free_game)(game_state *state);
diff --git a/range.c b/range.c
index 43231d9..7e71814 100644
--- a/range.c
+++ b/range.c
@@ -672,7 +672,7 @@ static void newdesc_compute_clues(game_state *state);
 static int newdesc_strip_clues(game_state *state, int *shuffle_1toN);
 static char *newdesc_encode_game_description(int n, puzzle_size *grid);
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
                            char **aux, int interactive)
 {
     int const w = params->w, h = params->h, n = w * h;
@@ -1060,7 +1060,7 @@ static char *newdesc_encode_game_description(int area, puzzle_size *grid)
     return desc;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int const n = params->w * params->h;
     int squares = 0;
diff --git a/rect.c b/rect.c
index 25b2132..53d389a 100644
--- a/rect.c
+++ b/rect.c
@@ -1146,9 +1146,11 @@ static void display_grid(game_params *params, int *grid, int *numbers, int all)
 }
 #endif
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params_in, random_state *rs,
 			   char **aux, int interactive)
 {
+    game_params params_copy = *params_in; /* structure copy */
+    game_params *params = &params_copy;
     int *grid, *numbers = NULL;
     int x, y, y2, y2last, yx, run, i, nsquares;
     char *desc, *p;
@@ -1776,7 +1778,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return desc;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int area = params->w * params->h;
     int squares = 0;
diff --git a/samegame.c b/samegame.c
index 65ebef7..a271dee 100644
--- a/samegame.c
+++ b/samegame.c
@@ -917,7 +917,7 @@ static void gen_grid_random(int w, int h, int nc, int *grid, random_state *rs)
     }
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     char *ret;
@@ -948,7 +948,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int area = params->w * params->h, i;
     char *p = desc;
diff --git a/signpost.c b/signpost.c
index b5e22ed..972bf82 100644
--- a/signpost.c
+++ b/signpost.c
@@ -499,7 +499,7 @@ static void free_game(game_state *state)
     sfree(state);
 }
 
-static void unpick_desc(game_params *params, char *desc,
+static void unpick_desc(const game_params *params, char *desc,
                         game_state **sout, char **mout)
 {
     game_state *state = blank_game(params->w, params->h);
@@ -793,7 +793,7 @@ done:
     return ret;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     game_state *state = blank_game(params->w, params->h);
@@ -840,7 +840,7 @@ generate:
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     char *ret = NULL;
 
diff --git a/singles.c b/singles.c
index 32449b6..319ab11 100644
--- a/singles.c
+++ b/singles.c
@@ -333,7 +333,7 @@ static int c2n(char c) {
     return -1;
 }
 
-static void unpick_desc(game_params *params, char *desc,
+static void unpick_desc(const game_params *params, char *desc,
                         game_state **sout, char **mout)
 {
     game_state *state = blank_game(params->w, params->h);
@@ -1207,7 +1207,7 @@ solved:
       the solver gets a headstart working out where they are.
  */
 
-static int new_game_is_good(game_params *params,
+static int new_game_is_good(const game_params *params,
                             game_state *state, game_state *tosolve)
 {
     int sret, sret_easy = 0;
@@ -1289,7 +1289,7 @@ found:
     return j;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     game_state *state = blank_game(params->w, params->h);
@@ -1401,7 +1401,7 @@ randomise:
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     char *ret = NULL;
 
diff --git a/sixteen.c b/sixteen.c
index 88c7ef4..d5a2789 100644
--- a/sixteen.c
+++ b/sixteen.c
@@ -193,7 +193,7 @@ static int perm_parity(int *perm, int n)
     return ret;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int stop, n, i, x;
@@ -398,7 +398,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
 }
 
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     char *p, *err;
     int i, area;
diff --git a/slant.c b/slant.c
index 2f9de52..251cc4a 100644
--- a/slant.c
+++ b/slant.c
@@ -1063,7 +1063,7 @@ static void slant_generate(int w, int h, signed char *soln, random_state *rs)
     sfree(connected);
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int w = params->w, h = params->h, W = w+1, H = h+1;
@@ -1216,7 +1216,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return desc;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->w, h = params->h, W = w+1, H = h+1;
     int area = W*H;
diff --git a/solo.c b/solo.c
index d9bf18d..50acfc1 100644
--- a/solo.c
+++ b/solo.c
@@ -3063,7 +3063,8 @@ static int check_valid(int cr, struct block_structure *blocks,
     return TRUE;
 }
 
-static int symmetries(game_params *params, int x, int y, int *output, int s)
+static int symmetries(const game_params *params, int x, int y,
+                      int *output, int s)
 {
     int c = params->c, r = params->r, cr = c*r;
     int i = 0;
@@ -3305,7 +3306,7 @@ static int blocks_encode_space(struct block_structure *blocks)
     return grid_encode_space(area);
 }
 
-static char *encode_puzzle_desc(game_params *params, digit *grid,
+static char *encode_puzzle_desc(const game_params *params, digit *grid,
 				struct block_structure *blocks,
 				digit *kgrid,
 				struct block_structure *kblocks)
@@ -3548,7 +3549,7 @@ static struct block_structure *gen_killer_cages(int cr, random_state *rs,
     return b;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int c = params->c, r = params->r, cr = c*r;
@@ -3989,7 +3990,7 @@ static char *validate_block_desc(char **pdesc, int cr, int area,
     return NULL;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int cr = params->c * params->r, area = cr*cr;
     char *err;
diff --git a/tents.c b/tents.c
index ef5debc..a4b1b6e 100644
--- a/tents.c
+++ b/tents.c
@@ -900,9 +900,11 @@ static int tents_solve(int w, int h, const char *grid, int *numbers,
     return 1;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params_in, random_state *rs,
 			   char **aux, int interactive)
 {
+    game_params params_copy = *params_in; /* structure copy */
+    game_params *params = &params_copy;
     int w = params->w, h = params->h;
     int ntrees = w * h / 5;
     char *grid = snewn(w*h, char);
@@ -1188,7 +1190,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->w, h = params->h;
     int area, i;
diff --git a/towers.c b/towers.c
index bd39554..39ab651 100644
--- a/towers.c
+++ b/towers.c
@@ -608,7 +608,7 @@ static int solver(int w, int *clues, digit *soln, int maxdiff)
  * Grid generation.
  */
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int w = params->w, a = w*w;
@@ -803,7 +803,7 @@ done
  * Gameplay.
  */
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->w, a = w*w;
     const char *p = desc;
diff --git a/twiddle.c b/twiddle.c
index b5b276f..08ef792 100644
--- a/twiddle.c
+++ b/twiddle.c
@@ -306,7 +306,7 @@ static int grid_complete(int *grid, int wh, int orientable)
     return ok;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int *grid;
@@ -430,7 +430,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     char *p;
     int w = params->w, h = params->h, wh = w*h;
diff --git a/undead.c b/undead.c
index e38c968..fe2cd83 100644
--- a/undead.c
+++ b/undead.c
@@ -237,7 +237,7 @@ struct game_state {
     int cheated;
 };
 
-static game_state *new_state(game_params *params) {
+static game_state *new_state(const game_params *params) {
     int i;
     game_state *state = snew(game_state);
     state->common = snew(struct game_common);
@@ -956,7 +956,7 @@ int path_cmp(const void *a, const void *b) {
     return pa->num_monsters - pb->num_monsters;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
                            char **aux, int interactive) {
     int i,count,c,w,h,r,p,g;
     game_state *new;
@@ -1419,7 +1419,7 @@ static game_state *new_game(midend *me, game_params *params, char *desc) {
     return state;
 }
 
-static char *validate_desc(game_params *params, char *desc) {
+static char *validate_desc(const game_params *params, char *desc) {
     int i;
     int w = params->w, h = params->h;
     int wh = w*h;
diff --git a/unequal.c b/unequal.c
index d16a572..a35d7a8 100644
--- a/unequal.c
+++ b/unequal.c
@@ -1094,9 +1094,11 @@ static void add_adjacent_flags(game_state *state, digit *latin)
     }
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params_in, random_state *rs,
 			   char **aux, int interactive)
 {
+    game_params params_copy = *params_in; /* structure copy */
+    game_params *params = &params_copy;
     digit *sq = NULL;
     int i, x, y, retlen, k, nsol;
     int o2 = params->order * params->order, ntries = 1;
@@ -1188,7 +1190,7 @@ generate:
     return ret;
 }
 
-static game_state *load_game(game_params *params, char *desc,
+static game_state *load_game(const game_params *params, char *desc,
                              char **why_r)
 {
     game_state *state = blank_game(params->order, params->adjacent);
@@ -1284,7 +1286,7 @@ static game_state *new_game(midend *me, game_params *params, char *desc)
     return state;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     char *why = NULL;
     game_state *dummy = load_game(params, desc, &why);
diff --git a/unfinished/group.c b/unfinished/group.c
index 1c2c02e..28066e6 100644
--- a/unfinished/group.c
+++ b/unfinished/group.c
@@ -361,7 +361,7 @@ static int solver_normal(struct latin_solver *solver, void *vctx)
 #define SOLVER(upper,title,func,lower) func,
 static usersolver_t const group_solvers[] = { DIFFLIST(SOLVER) };
 
-static int solver(game_params *params, digit *grid, int maxdiff)
+static int solver(const game_params *params, digit *grid, int maxdiff)
 {
     int w = params->w;
     int ret;
@@ -595,7 +595,7 @@ static const struct groups groups[] = {
 
 /* ----- data generated by group.gap ends ----- */
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int w = params->w, a = w*w;
@@ -810,7 +810,7 @@ static char *validate_grid_desc(const char **pdesc, int range, int area)
     return NULL;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->w, a = w*w;
     const char *p = desc;
diff --git a/unfinished/separate.c b/unfinished/separate.c
index ee9c830..c5f25a5 100644
--- a/unfinished/separate.c
+++ b/unfinished/separate.c
@@ -626,7 +626,7 @@ unsigned char *generate(int w, int h, int k, random_state *rs)
  * End of solver/generator code.
  */
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int w = params->w, h = params->h, wh = w*h, k = params->k;
@@ -646,7 +646,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return desc;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     return NULL;
 }
diff --git a/unfinished/slide.c b/unfinished/slide.c
index 38ef4d0..f87699d 100644
--- a/unfinished/slide.c
+++ b/unfinished/slide.c
@@ -837,7 +837,7 @@ static void generate_board(int w, int h, int *rtx, int *rty, int *minmoves,
  * End of solver/generator code.
  */
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int w = params->w, h = params->h, wh = w*h;
@@ -891,7 +891,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->w, h = params->h, wh = w*h;
     int *active, *link;
diff --git a/unfinished/sokoban.c b/unfinished/sokoban.c
index 4b0780c..09f4ee8 100644
--- a/unfinished/sokoban.c
+++ b/unfinished/sokoban.c
@@ -731,7 +731,7 @@ static void sokoban_generate(int w, int h, unsigned char *grid, int moves,
 	grid[py*w+px] = PLAYER;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int w = params->w, h = params->h;
@@ -806,7 +806,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return desc;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w = params->w, h = params->h;
     int area = 0;
diff --git a/unruly.c b/unruly.c
index d2ea9aa..28477f0 100644
--- a/unruly.c
+++ b/unruly.c
@@ -269,7 +269,7 @@ static char *validate_params(game_params *params, int full)
     return NULL;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int w2 = params->w2, h2 = params->h2;
     int s = w2 * h2;
@@ -1077,7 +1077,7 @@ static int unruly_fill_game(game_state *state, struct unruly_scratch *scratch,
     return TRUE;
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
                            char **aux, int interactive)
 {
 #ifdef STANDALONE_SOLVER
diff --git a/untangle.c b/untangle.c
index 59d48c4..3180f95 100644
--- a/untangle.c
+++ b/untangle.c
@@ -491,7 +491,7 @@ static void make_circle(point *pts, int n, int w)
     }
 }
 
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
 			   char **aux, int interactive)
 {
     int n = params->n, i;
@@ -734,7 +734,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return ret;
 }
 
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, char *desc)
 {
     int a, b;