diff --git a/rogueviz/dynamic-wfc.cpp b/rogueviz/dynamic-wfc.cpp
new file mode 100644
index 00000000..7256d389
--- /dev/null
+++ b/rogueviz/dynamic-wfc.cpp
@@ -0,0 +1,438 @@
+#include "../hyper.h"
+
+// an implementation of WFC-like constraint satisfaction problem using polytime dynamic programming
+// see: https://arxiv.org/abs/2002.09534
+
+// usage: hyper -canvas 0 -dynamic-wfc [constraint] [cutoff] [radius]
+
+// where constraint is one of:
+// 0: every cell has 2 yellow neighbors
+// 1: every cell's neighborhood has two consistent regions
+// 2: every cell's neighborhood has four consistent regions
+// 3: landscape: every cell has 1 consistent region of next type and 1 region of prev type
+
+// cutoff is cut off from the disk
+// radius is the radius of the disk to generate
+
+-geo Cryst3 -crf4
+
+namespace hr {
+
+namespace dynamic_wfc {
+
+vector<cell*> generate_pd_list(celllister& cl) {
+  cell *croot = cl.lst.back();
+  
+  cellwalker cw(croot, 0);
+  while(cl.listed(cw.peek())) cw++;
+  while(!cl.listed(cw.peek())) cw++;
+  
+  vector<cell*> currpath = {};
+  cellwalker cw1 = cw;
+
+  vector<cell*> result;
+  
+  // int steps = 0;
+  
+  auto push = [&] (cell *c) {
+    // println(hlog, "push ", c, " at ", isize(currpath));
+    currpath.push_back(c);
+    result.push_back(c);
+    };
+
+  auto pop = [&] () {
+    // println(hlog, "pop ", currpath.back(), " at ", isize(currpath)-1);
+    currpath.pop_back();
+    };
+  
+  auto replace = [&] (int pos, cell *c) {
+    // println(hlog, "replace ", currpath[pos], " to ", c, " at ", pos, "/", isize(currpath));
+    currpath[pos] = c;
+    result.push_back(c);
+    };
+  
+  push(croot);
+  
+  while(true) {
+    cw += wstep;
+    cw++;
+    while(!cl.listed(cw.peek())) cw++;
+    cell *cn = cw.at;
+    // cn->item = itGold;
+    // println(hlog, "at ", cn, " [", steps++, "]");
+    int cd = celldistance(cn, croot) + 1;
+    if(cd > isize(currpath)) 
+      push(cn);
+    else {
+      if(cd < isize(currpath))
+        pop();
+      
+      if(currpath.back() != cn) {
+        int moves = 1;
+    
+        while(celldistance(currpath[cd-1-moves], cn) > moves) {
+          moves++;
+          continue;
+          }
+        
+        while(moves > 0) {
+          moves--;        
+          forCellEx(cx, currpath[cd-2-moves])
+            if(celldistance(cx, cn) == moves)
+              replace(cd-1-moves, cx);
+          }
+        }
+      }
+
+    /*
+    cell *last = nullptr;
+    
+    for(cell *c: currpath) {
+      if(last) print(hlog, " ", celldistance(c, last), " ");
+      last = c;
+      print(hlog, c);
+      }
+    println(hlog); */
+    
+    for(int i=1; i<isize(currpath); i++)
+      if(celldistance(currpath[i-1], currpath[i]) != 1)
+        println(hlog, "PD error");
+    
+    if(cw == cw1) break;
+    }
+  
+  return result;
+  }
+
+struct ttrans {
+  int news;
+  int olds;
+  float proportion;
+  char id;
+  };
+
+vector<ttrans> trans;
+
+vector<cell*> ctf;
+
+vector<cell*> global_list;
+
+int wfctype, wfcrad, cutoff;
+
+void wfc_build() {  
+  int code_at = trans.back().news;
+  int cpos = isize(ctf);
+  for(int i=isize(trans)-1; i>=0; i--) {
+    auto& tri = trans[i];
+    if(tri.news == code_at) {
+      // println(hlog, tie(tri.news, tri.olds, tri.proportion, tri.where, tri.id));
+      if(hrandf() < tri.proportion) {
+        cell *c = ctf[--cpos];
+        int id = tri.id;
+        
+        switch(wfctype) {
+          case 0:          
+            if(id == 0) c->wall = waNone, c->landparam = 0xFF4040;
+            else c->wall = waNone, c->landparam = 0xFFFF40;
+            break;
+          case 1:
+            if(id == 0) c->wall = waNone, c->landparam = 0x4040FF;
+            else c->wall = waNone, c->landparam = 0x40FF40;
+            break;
+          case 2:
+            if(id == 0) c->wall = waNone, c->landparam = 0x8080FF;
+            else c->wall = waNone, c->landparam = 0x202020;
+            break;
+          case 3:
+            if(id == 0) c->wall = waNone, c->landparam = 0xC08080;
+            else if(id == 1) c->wall = waNone, c->landparam = 0x80C080;
+            else c->wall = waNone, c->landparam = 0x8080C0;
+            break;
+          }
+
+        // println(hlog, code_at, " -> ", tri.olds, " [", tri.where, "=", tri.id, "]");
+        code_at = tri.olds;
+        }
+      }
+    }
+  }
+
+void wfc() {
+  int rad = wfcrad;
+  vector< vector< vector<cell*> > > new_neighborhoods;
+  map<cell*, int> lorder;
+  map<cell*, int> multiplicity;
+  
+  set<cell*> consider;
+  
+  celllister cl(cwt.at, rad, 999999, nullptr);
+  for(cell *c: cl.lst) setdist(c, 7, nullptr);
+  auto l = generate_pd_list(cl);
+  int ls = isize(l);
+  for(int i=0; i<ls; i++) lorder[l[i]] = i;
+  println(hlog, "lorder[0] = ", l[0]);
+
+  for(int i=0; i<ls; i++) {
+    // int dctr = celldistance(l[i], cwt.at);
+    int dfirst = celldistance(l[i], l[0]);
+    // int dtotal = celldistance(l[0], cwt.at);
+    //if(dtotal == dfirst + dctr && dfirst < cutoff) ;
+    //else
+    if(dfirst >= cutoff)
+      consider.insert(l[i]); 
+    }
+  
+  new_neighborhoods.resize(ls);
+
+  for(cell *c: cl.lst) {
+    bool ok = true;
+    forCellEx(c1, c) if(!consider.count(c1)) ok = false;
+    if(!ok) continue;
+    vector<cell*> nn = {c};
+    forCellEx(c1, c) nn.push_back(c1);
+    for(auto cx: nn) multiplicity[cx]++;
+    int max_order = -1;
+    for(auto cx: nn) max_order = max(max_order, lorder[cx]);
+    
+    new_neighborhoods[max_order].push_back(nn);
+    }
+  
+  int typecount = 2;
+  if(wfctype == 3) typecount++;
+  vector<cell*> inpath;
+  
+  typedef unsigned long long code_t;
+  const int cpo = 2;
+  const code_t mask = (1<<cpo)-1;
+  
+  struct freqdata {
+    code_t code;
+    int id;
+    double prob;
+    };
+  
+  vector<freqdata> freq = { freqdata{0, 0, 1} };
+  vector<freqdata> nfreq;
+  
+  trans.clear();
+  
+  int nextcode = 1;
+  
+  int all = 2 << (cpo * 8);
+  
+  vector<double> mul(all, 0);
+  
+  for(int a=0; a<all; a++) {
+    vector<int> v;
+    int a0 = a;
+    while(a0) { v.push_back(a0 & mask); a0 >>= cpo; }
+    if(isize(v) < 2) continue;
+    v.pop_back();
+    int cur = v.back();
+    v.pop_back();
+    int changes = 0;
+    for(int i=1; i<isize(v); i++) if(v[i] == 1 && v[i-1] == 0) changes++;
+    if(v[0] == 1 && v.back() == 0) changes++;
+    int nes = 0;
+    for(int vv: v) nes += vv;
+    
+    switch(wfctype) {
+      case 0:
+        mul[a] = nes == 2;
+        break;
+      case 1:
+        mul[a] = changes == 1;
+        break;
+      case 2:
+        mul[a] = changes == 2;
+        break;
+      case 3: {
+        int ca=0, cb=0, cc=0, cd=0, ce=0;
+        int cur1 = (cur+1) % 3;
+        int cur2 = (cur+2) % 3;
+        int same = 0;
+        int in1 = 0;
+        int in2 = 0;
+        for(int i=0; i<isize(v); i++) {
+          auto va = v[i], vb = v[(i+1)%isize(v)];
+          if(va == cur && vb == cur1) ca++;
+          if(va == cur && vb == cur2) cb++;
+          if(va == cur1 && vb == cur) cc++;
+          if(va == cur2 && vb == cur) cd++;
+          if(va == cur1 && vb == cur2) ce++;
+          if(va == cur2 && vb == cur1) ce++;
+          if(va == cur) same++;
+          if(va == cur1) in1++;
+          if(va == cur2) in2++;
+          }
+        mul[a] = ca==1 && cb==1 && cc==1 && cd==1 && ce==0; // && in1 >= 2; // && in2 >= 2;
+        if(mul[a]) println(hlog, v, cur, " => ", mul[a]);
+        break;
+        }
+      }
+    
+    // println(hlog, a, ": ", v, " -> ", mul[a]);
+    }
+  
+  /*
+  mul[0] = 0;
+  for(int a=0; a<8; a++)
+    mul[1<<a] = 1;
+  */
+
+  long long tfreq = 0;
+  
+  for(int i=0; i<ls; i++) if(consider.count(l[i])) {
+    tfreq += isize(freq);
+    println(hlog, i, "/", ls, ": freqs = ", isize(freq), " inpath ", isize(inpath));
+    inpath.push_back(l[i]);
+  
+    int sh = cpo * (isize(inpath)-1);
+
+    for(auto& p: freq) if(p.prob) for(char c=0; c<typecount; c++) {
+      nfreq.emplace_back(p);
+      nfreq.back().code |= (code_t(c) << sh);
+      }
+    freq = move(nfreq);
+    nfreq = {};
+    // println(hlog, "inpath = ", inpath);
+    // println(hlog, "freqs = ", isize(freq));
+    if(isize(freq) > 500000000) {
+      println(hlog, "freq overflow");
+      exit(3);
+      }
+    fflush(stdout);
+    
+    global_list = cl.lst;
+
+    for(auto& nns: new_neighborhoods[i]) {
+      // println(hlog, "acknowledge ", nns);
+      fflush(stdout);
+            
+      vector<int> sids;
+      for(auto cz: nns) {
+        for(int id=0; id<isize(inpath); id++) if(inpath[id] == cz) sids.push_back(id);
+        }
+      
+      for(auto& p: freq) {
+        unsigned code = 1;
+        for(int v: sids) code = (code << cpo) | ((p.code >> (cpo*v)) & mask);
+        p.prob *= mul[code];
+        }
+
+      for(auto cz: nns) {
+        multiplicity[cz]--;
+        if(multiplicity[cz] == 0) {
+          ctf.push_back(cz);
+          // println(hlog, "remove ", cz, " (#", lorder[cz], ") from ", inpath);
+          fflush(stdout);
+          int is = isize(inpath)-1;
+          int id = 0;
+          while(id <= is && inpath[id] != cz) id++;
+          if(id > is) { 
+            println(hlog, "error");
+            exit(4);
+            }
+          inpath[id] = inpath[is];
+          inpath.resize(is);
+          for(auto& p: freq) if(p.prob) {
+            nfreq.push_back(p);
+            int tid = (p.code >> (cpo*id)) & mask;
+            code_t& s = nfreq.back().code;
+            s &=~ (mask << (cpo*id));
+            if(id < is) s |= ((s >> (cpo*is)) & mask) << (cpo*id);
+            s &=~ (mask << (cpo*is));
+            // s.resize(is);
+            // if(id < is) s[id] = p.code[is];
+            nfreq.back().id = (nfreq.back().id << cpo) | tid;
+            }
+          
+          freq.clear();
+          sort(nfreq.begin(), nfreq.end(), [] (const freqdata& a, const freqdata& b) { return a.code < b.code; });
+          for(int i=0; i<isize(nfreq); i++) {
+            auto &next = nfreq[i];
+            if(i == 0 || nfreq[i].code != nfreq[i-1].code) {
+              freq.push_back(nfreq[i]);
+              freq.back().id = nextcode++;
+              freq.back().prob = 0;
+              }
+            
+            auto& group = freq.back();
+            
+            group.prob += next.prob;
+
+            ttrans nt;
+            nt.news = group.id;
+            nt.olds = next.id >> cpo;
+            nt.proportion = next.prob / group.prob;
+            nt.id = next.id & mask;
+            trans.push_back(nt);
+            }
+          
+          nfreq.clear();            
+          }
+        }
+      }
+    }
+  
+  if(isize(freq)) println(hlog, "last freq = ", freq[0].prob);
+  println(hlog, "freq size = ", isize(freq));
+  println(hlog, "tfreq = ", format("%lld", tfreq));
+  println(hlog, "trans size = ", isize(trans));
+  println(hlog, "next code = ", nextcode);
+  
+  wfc_build();
+  }
+
+bool wfc_handleKey(int sym, int uni) {  
+  if(sym == '5') {
+    wfc_build();
+    return true;
+    }
+  return false;
+  }
+
+void hwrite(hstream& f, const ttrans& t) {
+  hwrite(f, t.news);
+  hwrite(f, t.olds);
+  hwrite(f, t.proportion);
+  hwrite(f, t.id);
+  }
+
+void save(string s) {
+  fhstream f(s, "wb");
+  vector<int> indices;
+  for(auto cf: ctf)
+    for(int i=0; i<isize(global_list); i++)
+      if(global_list[i] == cf) indices.push_back(i);
+  
+  hwrite(f, wfctype);
+  hwrite(f, cutoff);
+  hwrite(f, wfcrad);
+  hwrite(f, indices);
+  hwrite(f, trans);
+  }
+
+auto wfc_hook = 
+  addHook(hooks_handleKey, 100, wfc_handleKey) +
+  addHook(hooks_args, 100, [] {
+    using namespace arg;
+
+    if(0) ;
+    else if(argis("-dynamic-wfc")) {
+      start_game();
+      shift(); wfctype = argi();
+      shift(); cutoff = argi();
+      shift(); wfcrad = argi();
+      wfc();
+      }
+    else if(argis("-dynamic-wfc-save")) {
+      shift(); save(args());
+      }
+      
+    else return 1;
+    return 0;
+    });
+
+}
+}