Hi, I have been working on a roguelike game in scheme. Due to being unable to find an implementation of scheme with support for ncurses, and after a somewhat disappointing (but informative) attempt using chicken scheme, I eventually decided that extending mzscheme was the way forward. The extension has gone fairly well and provides most of the functionality I desire (including much of the number crunching for line of sight). However the following problems are unresolved. I am using mzscheme v370, and emacs. 1. the scheme_malloc_* family of functions segfault if the requested memory is unavailable. 2. Is it possible to register a function which is called when a object is garbage collected? 3. I have found it desirable to create scheme objects which act as a wrapper for the actual game data. It is undesirable to have to use (map-width * map-height * sizeof(Scheme_Object)) bytes when only a few map elements are accessed at any one time. Secondly when handling map elements it is often desirable to know its coordinates, which can be stored in the wrapper. This would be simple, except that i would prefer for there to never be two objects which are a wrapper for the same map element. Not only is this unintuitive, but it prevents the possibility of testing for equality using the  eqv?. The best idea I have had is to use a hash map to keep a record of currently available wrapper objects and return the appropriate wrapper. However, question 2 would have to be possible in order to keep the table updated. Also there is the issue of how long to keep unreferenced wrappers around (a round robbin system similar to that used in the caching of some operating systems could be profitable). As the source is around 2000 lines, I will not post it all here. However the functions involving memory allocation follow. Please note that I have not yet started altering the code to use a wrapper for the scheme type map-element. /* A structure representing indevidual tiles (map elements) of a dungeon.    Notice the data field. This allows game specific data to be stored on the tile    while keeping all the engine relevent data visible to the engine.*/ typedef struct {   Scheme_Object so ;   unsigned char seen : 1 ;              /* has this map element ever been seen? */   unsigned char visible : 1 ;           /* can this map element be seen right now? */   unsigned char opaque_to_visible : 1 ; /* is this map element opaque to normal light? */   unsigned char opaque_to_uv : 1 ;      /* is this map element opaque to uv light? */   unsigned char opaque_to_ir : 1 ;      /* is this map element opaque to ir light? */   unsigned char solid : 1 ;   unsigned char changed : 1 ;           /* Not really shure about the advisibility of this, however it avoids                        repeatedly inserting the same coordinates into the changed list. */   unsigned char residual_heat ;   unsigned char lit_visible ;           /* is this map element lit by normal light?*/   unsigned char lit_uv ;                /* is this map element lit by uv light? */   char print_char ;   char display_print_char ;   Scheme_Object *data ; }  Map_element ; /* The structure representing the actual dungeon. */ typedef struct {   Scheme_Object so ;   unsigned int w ;   unsigned int h ;   unsigned int l ;   unsigned char ambient_visible_light ;   unsigned char ambient_uv_light ;   unsigned char ambient_heat ;   Map_element *map;   struct changed *changed_list ; } Dungeon ; Scheme_Object *make_dungeon(int argc, Scheme_Object **argv) {   unsigned long w, h, l, i ;   Map_element *map ;   Dungeon *dn ;   if (!SCHEME_INTP(argv[0]) || negative(argv[0]))     scheme_wrong_type("make-dungeon", "positive integer", 0, argc, argv);   if (!SCHEME_INTP(argv[1]) || (negative(argv[1])))     scheme_wrong_type("make-dungeon", "positive integer", 1, argc, argv);   w = SCHEME_INT_VAL(argv[0]);   h = SCHEME_INT_VAL(argv[1]);   l = w * h ;   /* Malloc the dungeon */   dn = (Dungeon *)scheme_malloc_tagged(sizeof(Dungeon)) ;   dn->so.type = dungeon_type;   /*map = (Map_element *)scheme_malloc_fail_ok(scheme_malloc, sizeof(Map_element) * l);*/   map = (Map_element *)scheme_malloc_tagged(sizeof(Map_element) * l) ;   if (!map) {     scheme_raise_exn(MZEXN_FAIL, "make-dungeon: out of memory") ;   }   dn->w            = w ;   dn->h            = h ;   dn->l            = l ;   dn->map          = map ;   dn->changed_list = NULL ;   /* Init dungeon to safe vals : */   for (i = 0 ; i < l ; i++) {     dn->map[i].so.type = map_element_type ;     dn->map[i].seen = 0 ;     dn->map[i].visible = 0 ;     dn->map[i].changed = 0 ;     dn->map[i].residual_heat = 0 ;     dn->map[i].lit_visible = 0 ;     dn->map[i].lit_uv = 0 ;     dn->map[i].opaque_to_visible = 0 ;     dn->map[i].opaque_to_uv = 0 ;     dn->map[i].opaque_to_ir = 0 ;     dn->map[i].print_char = ' ' ;     dn->map[i].display_print_char = ' ' ;     dn->map[i].data = scheme_false ;   }   return (Scheme_Object *)dn ; } Thanks Dragal