diff --git a/src/db/db/db.pro b/src/db/db/db.pro
index d0fa394b3..299f029e3 100644
--- a/src/db/db/db.pro
+++ b/src/db/db/db.pro
@@ -37,6 +37,7 @@ SOURCES = \
   dbGenericShapeIterator.cc \
   dbGlyphs.cc \
   dbHershey.cc \
+  dbHierProcessor2.cc \
   dbInstances.cc \
   dbInstElement.cc \
   dbLayerMapping.cc \
@@ -264,6 +265,7 @@ HEADERS = \
   dbHash.h \
   dbHersheyFont.h \
   dbHershey.h \
+  dbHierProcessorUtils.h \
   dbInstances.h \
   dbInstElement.h \
   dbLayer.h \
diff --git a/src/db/db/dbHierProcessor.cc b/src/db/db/dbHierProcessor.cc
index a6d42449b..328fffbdd 100644
--- a/src/db/db/dbHierProcessor.cc
+++ b/src/db/db/dbHierProcessor.cc
@@ -31,6 +31,7 @@
 #include "dbLocalOperationUtils.h"
 #include "dbShapeFlags.h"
 #include "dbCellVariants.h"
+#include "dbHierProcessorUtils.h"
 #include "tlLog.h"
 #include "tlTimer.h"
 #include "tlInternational.h"
@@ -70,261 +71,6 @@ namespace db
 //  than the overlap box times this factor.
 const double area_ratio_for_recursion = 3.0;
 
-// ---------------------------------------------------------------------------------------------
-//  Shape reference translator
-
-template <class Ref> class shape_reference_translator;
-template <class Ref, class Trans> class shape_reference_translator_with_trans;
-
-template <class Ref>
-class shape_reference_translator
-{
-public:
-  typedef typename Ref::shape_type shape_type;
-  typedef typename Ref::trans_type ref_trans_type;
-
-  shape_reference_translator (db::Layout *target_layout)
-    : mp_layout (target_layout)
-  {
-    //  .. nothing yet ..
-  }
-
-  Ref operator() (const Ref &ref) const
-  {
-    typename std::unordered_map<const shape_type *, const shape_type *>::const_iterator m = m_cache.find (ref.ptr ());
-    if (m != m_cache.end ()) {
-
-      return Ref (m->second, ref.trans ());
-
-    } else {
-
-      const shape_type *ptr;
-      {
-        tl::MutexLocker locker (&mp_layout->lock ());
-        ptr = mp_layout->shape_repository ().repository (typename shape_type::tag ()).insert (ref.obj ());
-      }
-
-      m_cache[ref.ptr ()] = ptr;
-      return Ref (ptr, ref.trans ());
-
-    }
-  }
-
-  template <class Trans>
-  Ref operator() (const Ref &ref, const Trans &tr) const
-  {
-    shape_type sh = ref.obj ().transformed (tr * Trans (ref.trans ()));
-    ref_trans_type red_trans;
-    sh.reduce (red_trans);
-
-    typename std::unordered_map<shape_type, const shape_type *>::const_iterator m = m_cache_by_shape.find (sh);
-    if (m != m_cache_by_shape.end ()) {
-
-      return Ref (m->second, red_trans);
-
-    } else {
-
-      const shape_type *ptr;
-      {
-        tl::MutexLocker locker (&mp_layout->lock ());
-        ptr = mp_layout->shape_repository ().repository (typename shape_type::tag ()).insert (sh);
-      }
-
-      m_cache_by_shape[sh] = ptr;
-      return Ref (ptr, red_trans);
-
-    }
-  }
-
-private:
-  db::Layout *mp_layout;
-  mutable std::unordered_map<const shape_type *, const shape_type *> m_cache;
-  mutable std::unordered_map<shape_type, const shape_type *> m_cache_by_shape;
-};
-
-template <class Shape>
-class simple_shape_reference_translator
-{
-public:
-  typedef Shape shape_type;
-
-  simple_shape_reference_translator ()
-  {
-    //  .. nothing yet ..
-  }
-
-  const shape_type &operator() (const shape_type &s) const
-  {
-    return s;
-  }
-
-  template <class Trans>
-  shape_type operator() (const shape_type &s, const Trans &tr) const
-  {
-    return s.transformed (tr);
-  }
-};
-
-template <>
-class shape_reference_translator<db::Edge>
-  : public simple_shape_reference_translator<db::Edge>
-{
-public:
-  shape_reference_translator (db::Layout * /*target_layout*/) { }
-};
-
-template <>
-class shape_reference_translator<db::Polygon>
-  : public simple_shape_reference_translator<db::Polygon>
-{
-public:
-  shape_reference_translator (db::Layout * /*target_layout*/) { }
-};
-
-template <>
-class shape_reference_translator<db::Text>
-  : public simple_shape_reference_translator<db::Text>
-{
-public:
-  shape_reference_translator (db::Layout * /*target_layout*/) { }
-};
-
-template<class Basic>
-class shape_reference_translator<db::object_with_properties<Basic> >
-  : public shape_reference_translator<Basic>
-{
-public:
-  typedef db::object_with_properties<Basic> shape_type;
-
-  shape_reference_translator (db::Layout *target_layout)
-    : shape_reference_translator<Basic> (target_layout)
-  {
-    //  .. nothing yet ..
-  }
-
-  shape_type operator() (const shape_type &s) const
-  {
-    return shape_type (shape_reference_translator<Basic>::operator () (s), s.properties_id ());
-  }
-
-  template <class Trans>
-  shape_type operator() (const shape_type &s, const Trans &tr) const
-  {
-    return shape_type (shape_reference_translator<Basic>::operator () (s, tr), s.properties_id ());
-  }
-};
-
-template <class Ref, class Trans>
-class shape_reference_translator_with_trans_from_shape_ref
-{
-public:
-  typedef typename Ref::shape_type shape_type;
-  typedef typename Ref::trans_type ref_trans_type;
-
-  shape_reference_translator_with_trans_from_shape_ref (db::Layout *target_layout)
-    : mp_layout (target_layout)
-  {
-    //  .. nothing yet ..
-  }
-
-  void set_trans (const Trans &trans)
-  {
-    m_trans = trans;
-    m_ref_trans = ref_trans_type (trans);
-    m_bare_trans = Trans (m_ref_trans.inverted ()) * trans;
-  }
-
-  Ref operator() (const Ref &ref) const
-  {
-    auto m = m_cache.find (std::make_pair (ref.ptr (), m_bare_trans));
-    if (m != m_cache.end ()) {
-
-      return Ref (m->second.first, ref_trans_type (m_trans * Trans (ref.trans ())) * m->second.second);
-
-    } else {
-
-      shape_type sh = ref.obj ().transformed (m_bare_trans);
-      ref_trans_type red_trans;
-      sh.reduce (red_trans);
-
-      const shape_type *ptr;
-      {
-        tl::MutexLocker locker (&mp_layout->lock ());
-        ptr = mp_layout->shape_repository ().repository (typename shape_type::tag ()).insert (sh);
-      }
-
-      m_cache[std::make_pair (ref.ptr (), m_bare_trans)] = std::make_pair (ptr, red_trans);
-
-      return Ref (ptr, ref_trans_type (m_trans * Trans (ref.trans ())) * red_trans);
-
-    }
-  }
-
-private:
-  db::Layout *mp_layout;
-  Trans m_trans;
-  ref_trans_type m_ref_trans;
-  Trans m_bare_trans;
-  mutable std::unordered_map<std::pair<const shape_type *, Trans>, std::pair<const shape_type *, ref_trans_type> > m_cache;
-};
-
-template <class Trans>
-class shape_reference_translator_with_trans<db::PolygonRef, Trans>
-  : public shape_reference_translator_with_trans_from_shape_ref<db::PolygonRef, Trans>
-{
-public:
-  shape_reference_translator_with_trans (db::Layout *target_layout)
-    : shape_reference_translator_with_trans_from_shape_ref<db::PolygonRef, Trans> (target_layout)
-  {
-    //  .. nothing yet ..
-  }
-};
-
-template <class Sh, class Trans>
-class shape_reference_translator_with_trans
-{
-public:
-  typedef Sh shape_type;
-
-  shape_reference_translator_with_trans (db::Layout * /*target_layout*/)
-  {
-    //  .. nothing yet ..
-  }
-
-  void set_trans (const Trans &trans)
-  {
-    m_trans = trans;
-  }
-
-  shape_type operator() (const shape_type &s) const
-  {
-    return s.transformed (m_trans);
-  }
-
-private:
-  Trans m_trans;
-};
-
-template <class Basic, class Trans>
-class shape_reference_translator_with_trans<db::object_with_properties<Basic>, Trans>
-  : public shape_reference_translator_with_trans<Basic, Trans>
-{
-public:
-  typedef db::object_with_properties<Basic> shape_type;
-
-  shape_reference_translator_with_trans (db::Layout *target_layout)
-    : shape_reference_translator_with_trans<Basic, Trans> (target_layout)
-  {
-    //  .. nothing yet ..
-  }
-
-  shape_type operator() (const shape_type &s) const
-  {
-    //  CAUTION: no property ID translation happens here (reasoning: the main use case is fake ID for net tagging)
-    return shape_type (shape_reference_translator_with_trans<Basic, Trans>::operator () (s), s.properties_id ());
-  }
-};
-
 // ---------------------------------------------------------------------------------------------
 
 /**
@@ -402,484 +148,6 @@ static void dump_cell_contexts (local_processor_contexts<TS, TI, TR> &contexts,
   }
 }
 
-// ---------------------------------------------------------------------------------------------
-//  LocalProcessorCellContext implementation
-
-template <class TS, class TI, class TR>
-local_processor_cell_context<TS, TI, TR>::local_processor_cell_context ()
-{
-  //  .. nothing yet ..
-}
-
-template <class TS, class TI, class TR>
-local_processor_cell_context<TS, TI, TR>::local_processor_cell_context (const local_processor_cell_context &other)
-  : m_propagated (other.m_propagated), m_drops (other.m_drops)
-{
-  //  .. nothing yet ..
-}
-
-template <class TS, class TI, class TR>
-local_processor_cell_context<TS, TI, TR> &
-local_processor_cell_context<TS, TI, TR>::operator= (const local_processor_cell_context &other)
-{
-  if (this != &other) {
-    m_propagated = other.m_propagated;
-    m_drops = other.m_drops;
-  }
-  return *this;
-}
-
-template <class TS, class TI, class TR>
-void
-local_processor_cell_context<TS, TI, TR>::add (db::local_processor_cell_context<TS, TI, TR> *parent_context, db::Cell *parent, const db::ICplxTrans &cell_inst)
-{
-  m_drops.push_back (local_processor_cell_drop<TS, TI, TR> (parent_context, parent, cell_inst));
-}
-
-template <class TS, class TI, class TR>
-void
-local_processor_cell_context<TS, TI, TR>::propagate (unsigned int output_layer, const std::unordered_set<TR> &res)
-{
-  if (res.empty ()) {
-    return;
-  }
-
-  db::Layout *subject_layout = 0;
-  shape_reference_translator_with_trans<TR, db::ICplxTrans> rt (subject_layout);
-
-  for (typename std::vector<local_processor_cell_drop<TS, TI, TR> >::const_iterator d = m_drops.begin (); d != m_drops.end (); ++d) {
-
-    tl_assert (d->parent_context != 0);
-    tl_assert (d->parent != 0);
-
-    if (subject_layout != d->parent->layout ()) {
-      subject_layout = d->parent->layout ();
-      rt = shape_reference_translator_with_trans<TR, db::ICplxTrans> (subject_layout);
-    }
-
-    rt.set_trans (d->cell_inst);
-    std::vector<TR> new_refs;
-    new_refs.reserve (res.size ());
-    for (typename std::unordered_set<TR>::const_iterator r = res.begin (); r != res.end (); ++r) {
-      new_refs.push_back (rt (*r));
-    }
-
-    {
-      tl::MutexLocker locker (&d->parent_context->lock ());
-      d->parent_context->propagated (output_layer).insert (new_refs.begin (), new_refs.end ());
-    }
-
-  }
-}
-
-// ---------------------------------------------------------------------------------------------
-//  LocalProcessorCellContexts implementation
-
-template <class TS, class TI, class TR>
-local_processor_cell_contexts<TS, TI, TR>::local_processor_cell_contexts ()
-  : mp_intruder_cell (0)
-{
-  //  .. nothing yet ..
-}
-
-template <class TS, class TI, class TR>
-local_processor_cell_contexts<TS, TI, TR>::local_processor_cell_contexts (const db::Cell *intruder_cell)
-  : mp_intruder_cell (intruder_cell)
-{
-  //  .. nothing yet ..
-}
-
-template <class TS, class TI, class TR>
-db::local_processor_cell_context<TS, TI, TR> *
-local_processor_cell_contexts<TS, TI, TR>::find_context (const context_key_type &intruders)
-{
-  typename std::unordered_map<context_key_type, db::local_processor_cell_context<TS, TI, TR> >::iterator c = m_contexts.find (intruders);
-  return c != m_contexts.end () ? &c->second : 0;
-}
-
-template <class TS, class TI, class TR>
-db::local_processor_cell_context<TS, TI, TR> *
-local_processor_cell_contexts<TS, TI, TR>::create (const context_key_type &intruders)
-{
-  return &m_contexts[intruders];
-}
-
-template <class TR>
-static void
-subtract_set (std::unordered_set<TR> &res, const std::unordered_set<TR> &other)
-{
-  //  for everything else, we don't use a boolean core but just set intersection
-  for (typename std::unordered_set<TR>::const_iterator o = other.begin (); o != other.end (); ++o) {
-    res.erase (*o);
-  }
-}
-
-template <class TS, class TI>
-static void
-subtract (std::unordered_set<db::PolygonRef> &res, const std::unordered_set<db::PolygonRef> &other, db::Layout *layout, const db::local_processor<TS, TI, db::PolygonRef> *proc)
-{
-  if (other.empty ()) {
-    return;
-  }
-
-  if (! proc->boolean_core ()) {
-    subtract_set (res, other);
-    return;
-  }
-
-  size_t max_vertex_count = proc->max_vertex_count ();
-  double area_ratio = proc->area_ratio ();
-
-  db::EdgeProcessor ep;
-  ep.set_base_verbosity (proc->base_verbosity () + 30);
-
-  size_t p1 = 0, p2 = 1;
-
-  for (std::unordered_set<db::PolygonRef>::const_iterator i = res.begin (); i != res.end (); ++i) {
-    const db::PolygonRef &subject = *i;
-    for (db::PolygonRef::polygon_edge_iterator e = subject.begin_edge (); ! e.at_end(); ++e) {
-      ep.insert (*e, p1);
-    }
-    p1 += 2;
-  }
-
-  for (std::unordered_set<db::PolygonRef>::const_iterator i = other.begin (); i != other.end (); ++i) {
-    const db::PolygonRef &subject = *i;
-    for (db::PolygonRef::polygon_edge_iterator e = subject.begin_edge (); ! e.at_end(); ++e) {
-      ep.insert (*e, p2);
-    }
-    p2 += 2;
-  }
-
-  res.clear ();
-  db::BooleanOp op (db::BooleanOp::ANotB);
-  db::PolygonRefGenerator pr (layout, res);
-  db::PolygonSplitter splitter (pr, area_ratio, max_vertex_count);
-  db::PolygonGenerator pg (splitter, true, true);
-  ep.process (pg, op);
-}
-
-template <class TS, class TI>
-static void
-subtract (std::unordered_set<db::PolygonRefWithProperties> &res, const std::unordered_set<db::PolygonRefWithProperties> &other, db::Layout *layout, const db::local_processor<TS, TI, db::PolygonRefWithProperties> *proc)
-{
-  if (other.empty ()) {
-    return;
-  }
-
-  if (! proc->boolean_core ()) {
-    subtract_set (res, other);
-    return;
-  }
-
-  size_t max_vertex_count = proc->max_vertex_count ();
-  double area_ratio = proc->area_ratio ();
-
-  std::unordered_set<db::PolygonRefWithProperties> first;
-  first.swap (res);
-
-  std::map<db::properties_id_type, std::pair<std::vector<const db::PolygonRefWithProperties *>, std::vector<const db::PolygonRefWithProperties *> > > by_prop_id;
-  for (auto i = first.begin (); i != first.end (); ++i)   {
-    by_prop_id [i->properties_id ()].first.push_back (i.operator-> ());
-  }
-  for (auto i = other.begin (); i != other.end (); ++i)   {
-    by_prop_id [i->properties_id ()].second.push_back (i.operator-> ());
-  }
-
-  db::EdgeProcessor ep;
-  ep.set_base_verbosity (proc->base_verbosity () + 30);
-
-  for (auto s2p = by_prop_id.begin (); s2p != by_prop_id.end (); ++s2p) {
-
-    db::properties_id_type prop_id = s2p->first;
-    size_t p1 = 0, p2 = 1;
-
-    ep.clear ();
-
-    for (auto i = s2p->second.first.begin (); i != s2p->second.first.end (); ++i) {
-      ep.insert (**i, p1);
-      p1 += 2;
-    }
-
-    for (auto i = s2p->second.second.begin (); i != s2p->second.second.end (); ++i) {
-      ep.insert (**i, p2);
-      p2 += 2;
-    }
-
-    db::BooleanOp op (db::BooleanOp::ANotB);
-    db::polygon_ref_generator_with_properties<db::PolygonRefWithProperties> pr (layout, res, prop_id);
-    db::PolygonSplitter splitter (pr, area_ratio, max_vertex_count);
-    db::PolygonGenerator pg (splitter, true, true);
-    ep.process (pg, op);
-
-  }
-}
-
-template <class TS, class TI>
-static void
-subtract (std::unordered_set<db::Edge> &res, const std::unordered_set<db::Edge> &other, db::Layout * /*layout*/, const db::local_processor<TS, TI, db::Edge> *proc)
-{
-  if (other.empty ()) {
-    return;
-  }
-
-  if (! proc->boolean_core ()) {
-    subtract_set (res, other);
-    return;
-  }
-
-  db::box_scanner<db::Edge, size_t> scanner;
-  scanner.reserve (res.size () + other.size ());
-
-  for (std::unordered_set<Edge>::const_iterator i = res.begin (); i != res.end (); ++i) {
-    scanner.insert (i.operator-> (), 0);
-  }
-  for (std::unordered_set<Edge>::const_iterator i = other.begin (); i != other.end (); ++i) {
-    scanner.insert (i.operator-> (), 1);
-  }
-
-  std::unordered_set<db::Edge> result;
-  EdgeBooleanClusterCollector<std::unordered_set<db::Edge> > cluster_collector (&result, EdgeNot);
-  scanner.process (cluster_collector, 1, db::box_convert<db::Edge> ());
-
-  res.swap (result);
-}
-
-template <class TS, class TI>
-static void
-subtract (std::unordered_set<db::EdgeWithProperties> &res, const std::unordered_set<db::EdgeWithProperties> &other, db::Layout * /*layout*/, const db::local_processor<TS, TI, db::EdgeWithProperties> *proc)
-{
-  if (other.empty ()) {
-    return;
-  }
-
-  if (! proc->boolean_core ()) {
-    subtract_set (res, other);
-    return;
-  }
-
-  std::unordered_set<db::EdgeWithProperties> first;
-  first.swap (res);
-
-  std::map<db::properties_id_type, std::pair<std::vector<const db::EdgeWithProperties *>, std::vector<const db::EdgeWithProperties *> > > by_prop_id;
-  for (auto i = first.begin (); i != first.end (); ++i)   {
-    by_prop_id [i->properties_id ()].first.push_back (i.operator-> ());
-  }
-  for (auto i = other.begin (); i != other.end (); ++i)   {
-    by_prop_id [i->properties_id ()].second.push_back (i.operator-> ());
-  }
-
-  for (auto s2p = by_prop_id.begin (); s2p != by_prop_id.end (); ++s2p) {
-
-    if (s2p->second.second.empty ()) {
-
-      for (auto i = s2p->second.first.begin (); i != s2p->second.first.end (); ++i) {
-        res.insert (**i);
-      }
-
-    } else {
-
-      db::box_scanner<db::Edge, size_t> scanner;
-      scanner.reserve (s2p->second.first.size () + s2p->second.second.size ());
-
-      for (auto i = s2p->second.first.begin (); i != s2p->second.first.end (); ++i) {
-        scanner.insert (*i, 0);
-      }
-      for (auto i = s2p->second.second.begin (); i != s2p->second.second.end (); ++i) {
-        scanner.insert (*i, 1);
-      }
-
-      db::property_injector<db::Edge, std::unordered_set<db::EdgeWithProperties> > prop_inject (&res, s2p->first);
-      EdgeBooleanClusterCollector<db::property_injector<db::Edge, std::unordered_set<db::EdgeWithProperties> > > cluster_collector (&prop_inject, EdgeNot);
-      scanner.process (cluster_collector, 1, db::box_convert<db::Edge> ());
-
-    }
-
-  }
-}
-
-template <class TS, class TI, class TR>
-static void
-subtract (std::unordered_set<TR> &res, const std::unordered_set<TR> &other, db::Layout * /*layout*/, const db::local_processor<TS, TI, TR> * /*proc*/)
-{
-  subtract_set (res, other);
-}
-
-//  determines the default boolean core flag per result type
-
-namespace
-{
-
-template <class TR>
-struct default_boolean_core
-{
-  bool operator() () const { return false; }
-};
-
-template <>
-struct default_boolean_core<db::PolygonRef>
-{
-  bool operator() () const { return true; }
-};
-
-}
-
-namespace {
-
-template <class TS, class TI, class TR>
-struct context_sorter
-{
-  bool operator () (const std::pair<const typename local_processor_cell_contexts<TS, TI, TR>::context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> &a,
-                    const std::pair<const typename local_processor_cell_contexts<TS, TI, TR>::context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> &b)
-  {
-    return *a.first < *b.first;
-  }
-};
-
-}
-
-template <class TS, class TI, class TR>
-void
-local_processor_cell_contexts<TS, TI, TR>::compute_results (const local_processor_contexts<TS, TI, TR> &contexts, db::Cell *cell, const local_operation<TS, TI, TR> *op, const std::vector<unsigned int> &output_layers, const local_processor<TS, TI, TR> *proc)
-{
-  CRONOLOGY_COMPUTE_BRACKET(event_compute_results)
-
-  bool first = true;
-  std::vector<std::unordered_set<TR> > common;
-  common.resize (output_layers.size ());
-
-  int index = 0;
-  int total = int (m_contexts.size ());
-
-  //  NOTE: we use the ordering provided by key_type::operator< rather than the unordered map to achieve
-  //  reproducibility across different platforms. unordered_map is faster, but for processing them,
-  //  strict ordering is a more robust choice.
-  std::vector<std::pair<const context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> > sorted_contexts;
-  sorted_contexts.reserve (m_contexts.size ());
-  for (typename std::unordered_map<context_key_type, db::local_processor_cell_context<TS, TI, TR> >::iterator c = m_contexts.begin (); c != m_contexts.end (); ++c) {
-    sorted_contexts.push_back (std::make_pair (&c->first, &c->second));
-  }
-
-  std::sort (sorted_contexts.begin (), sorted_contexts.end (), context_sorter<TS, TI, TR> ());
-
-  for (typename std::vector<std::pair<const context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> >::const_iterator c = sorted_contexts.begin (); c != sorted_contexts.end (); ++c) {
-
-    proc->next ();
-    ++index;
-
-    if (tl::verbosity () >= proc->base_verbosity () + 20) {
-      tl::log << tr ("Computing local results for ") << cell->layout ()->cell_name (cell->cell_index ()) << " (context " << index << "/" << total << ")";
-    }
-
-    if (first) {
-
-      {
-        tl::MutexLocker locker (&c->second->lock ());
-        for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
-          common [o - output_layers.begin ()] = c->second->propagated (*o);
-        }
-      }
-
-      CRONOLOGY_COMPUTE_BRACKET(event_compute_local_cell)
-      proc->compute_local_cell (contexts, cell, mp_intruder_cell, op, *c->first, common);
-      first = false;
-
-    } else {
-
-      std::vector<std::unordered_set<TR> > res;
-      res.resize (output_layers.size ());
-
-      {
-        tl::MutexLocker locker (&c->second->lock ());
-        for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
-          res [o - output_layers.begin ()] = c->second->propagated (*o);
-        }
-      }
-
-      {
-        CRONOLOGY_COMPUTE_BRACKET(event_compute_local_cell)
-        proc->compute_local_cell (contexts, cell, mp_intruder_cell, op, *c->first, res);
-      }
-
-      if (common.empty ()) {
-
-        CRONOLOGY_COMPUTE_BRACKET(event_propagate)
-        for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
-          c->second->propagate (*o, res [o - output_layers.begin ()]);
-        }
-
-//  gcc 4.4.7 (at least) doesn't have an operator== in std::unordered_set, so we skip this
-//  optimization
-#if defined(__GNUC__) && __GNUC__ == 4
-      } else {
-#else
-      } else if (res != common) {
-#endif
-
-        CRONOLOGY_COMPUTE_BRACKET(event_propagate)
-
-        for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
-
-          size_t oi = o - output_layers.begin ();
-
-          std::unordered_set<TR> lost;
-
-          for (typename std::unordered_set<TR>::const_iterator i = common[oi].begin (); i != common[oi].end (); ++i) {
-            if (res[oi].find (*i) == res[oi].end ()) {
-              lost.insert (*i);
-            }
-          }
-
-          if (! lost.empty ()) {
-
-            subtract (lost, res[oi], cell->layout (), proc);
-
-            if (! lost.empty ()) {
-              subtract (common[oi], lost, cell->layout (), proc);
-              for (typename std::vector<std::pair<const context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> >::const_iterator cc = sorted_contexts.begin (); cc != c; ++cc) {
-                cc->second->propagate (*o, lost);
-              }
-            }
-
-          }
-
-        }
-
-        for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
-
-          std::unordered_set<TR> gained;
-
-          size_t oi = o - output_layers.begin ();
-          for (typename std::unordered_set<TR>::const_iterator i = res[oi].begin (); i != res[oi].end (); ++i) {
-            if (common[oi].find (*i) == common[oi].end ()) {
-              gained.insert (*i);
-            }
-          }
-
-          if (! gained.empty ()) {
-
-            subtract (gained, common[oi], cell->layout (), proc);
-
-            if (! gained.empty ()) {
-              c->second->propagate (*o, gained);
-            }
-
-          }
-
-        }
-
-      }
-
-    }
-
-  }
-
-  for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
-    size_t oi = o - output_layers.begin ();
-    proc->push_results (cell, *o, common[oi]);
-  }
-}
-
 // ---------------------------------------------------------------------------------------------
 
 template <class TS, class TI>
@@ -2535,64 +1803,7 @@ local_processor<TS, TI, TR>::run_flat (const generic_shape_iterator<TS> &subject
 
 // ---------------------------------------------------------------------------------------------
 
-//  NOTE: don't forget to update the explicit instantiations in dbLocalOperation.cc
-
-//  explicit instantiations
-template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Polygon, db::Polygon>;
-template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Text, db::Polygon>;
-template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Edge, db::Polygon>;
-template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Text, db::Text>;
-template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Edge, db::Edge>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::PolygonRefWithProperties>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgeWithProperties>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgePairWithProperties>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonWithProperties, db::PolygonWithProperties, db::PolygonWithProperties>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgeWithProperties>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgePairWithProperties>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonRef, db::PolygonRef, db::PolygonRef>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonRef, db::Edge, db::PolygonRef>;
-template class DB_PUBLIC local_processor_cell_context<db::PolygonRef, db::PolygonRef, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Polygon, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_context<db::Edge, db::Edge, db::Edge>;
-template class DB_PUBLIC local_processor_cell_context<db::Edge, db::Polygon, db::Edge>;
-template class DB_PUBLIC local_processor_cell_context<db::Edge, db::Edge, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::Polygon, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::PolygonRef, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::Edge, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::Polygon, db::Polygon>;
-template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::PolygonRef, db::PolygonRef>;
-template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::Edge, db::Edge>;
-
-//  explicit instantiations
-template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Polygon, db::Polygon>;
-template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Edge, db::Polygon>;
-template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Edge, db::Edge>;
-template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Text, db::Polygon>;
-template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Text, db::Text>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::PolygonRefWithProperties>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgeWithProperties>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgePairWithProperties>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonWithProperties, db::PolygonWithProperties, db::PolygonWithProperties>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgeWithProperties>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgePairWithProperties>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRef, db::PolygonRef, db::PolygonRef>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRef, db::Edge, db::PolygonRef>;
-template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRef, db::PolygonRef, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Polygon, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_contexts<db::Edge, db::PolygonRef, db::Edge>;
-template class DB_PUBLIC local_processor_cell_contexts<db::Edge, db::Polygon, db::Edge>;
-template class DB_PUBLIC local_processor_cell_contexts<db::Edge, db::Edge, db::Edge>;
-template class DB_PUBLIC local_processor_cell_contexts<db::Edge, db::Edge, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::Polygon, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::PolygonRef, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::Edge, db::EdgePair>;
-template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::Polygon, db::Polygon>;
-template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::PolygonRef, db::PolygonRef>;
-template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::Edge, db::Edge>;
+//  NOTE: don't forget to update the explicit instantiations in dbHierProcessor2.cc
 
 //  explicit instantiations
 template class DB_PUBLIC shape_interactions<db::Polygon, db::Polygon>;
diff --git a/src/db/db/dbHierProcessor2.cc b/src/db/db/dbHierProcessor2.cc
new file mode 100644
index 000000000..badfc3b0c
--- /dev/null
+++ b/src/db/db/dbHierProcessor2.cc
@@ -0,0 +1,590 @@
+
+/*
+
+  KLayout Layout Viewer
+  Copyright (C) 2006-2024 Matthias Koefferlein
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+
+#include "dbHierProcessor.h"
+#include "dbBoxScanner.h"
+#include "dbRecursiveShapeIterator.h"
+#include "dbBoxConvert.h"
+#include "dbEdgeProcessor.h"
+#include "dbEdgeBoolean.h"
+#include "dbPolygonGenerators.h"
+#include "dbLocalOperationUtils.h"
+#include "dbShapeFlags.h"
+#include "dbCellVariants.h"
+#include "dbHierProcessorUtils.h"
+#include "tlLog.h"
+#include "tlTimer.h"
+#include "tlInternational.h"
+
+// ---------------------------------------------------------------------------------------------
+//  Cronology debugging support (TODO: experimental)
+
+#if defined(HAVE_CRONOLOGY)
+
+#include <cronology/events.hpp>
+
+CRONOLOGY_MAKE_EVENT(event_compute_contexts, "Compute contexts")
+CRONOLOGY_MAKE_EVENT(event_compute_contexts_unlocked, "Compute contexts (unlocked)")
+
+cronology::events::event_collection<event_compute_contexts, event_compute_contexts_unlocked> collect_events;
+
+#define CRONOLOGY_COLLECTION_BRACKET(event_name) cronology::EventBracket __bracket##event_name (collect_events.threadwise ()->event<event_name> ().event ());
+
+CRONOLOGY_MAKE_EVENT(event_compute_results, "Compute results")
+CRONOLOGY_MAKE_EVENT(event_compute_local_cell, "Compute local cell results")
+CRONOLOGY_MAKE_EVENT(event_propagate, "Propagate local cell results")
+
+cronology::events::event_collection<event_compute_results, event_compute_local_cell, event_propagate> compute_events;
+
+#define CRONOLOGY_COMPUTE_BRACKET(event_name) cronology::EventBracket __bracket##event_name (compute_events.threadwise ()->event<event_name> ().event ());
+
+#else
+#define CRONOLOGY_COLLECTION_BRACKET(event_name)
+#define CRONOLOGY_COMPUTE_BRACKET(event_name)
+#endif
+
+namespace db
+{
+
+// ---------------------------------------------------------------------------------------------
+//  LocalProcessorCellContext implementation
+
+template <class TS, class TI, class TR>
+local_processor_cell_context<TS, TI, TR>::local_processor_cell_context ()
+{
+  //  .. nothing yet ..
+}
+
+template <class TS, class TI, class TR>
+local_processor_cell_context<TS, TI, TR>::local_processor_cell_context (const local_processor_cell_context &other)
+  : m_propagated (other.m_propagated), m_drops (other.m_drops)
+{
+  //  .. nothing yet ..
+}
+
+template <class TS, class TI, class TR>
+local_processor_cell_context<TS, TI, TR> &
+local_processor_cell_context<TS, TI, TR>::operator= (const local_processor_cell_context &other)
+{
+  if (this != &other) {
+    m_propagated = other.m_propagated;
+    m_drops = other.m_drops;
+  }
+  return *this;
+}
+
+template <class TS, class TI, class TR>
+void
+local_processor_cell_context<TS, TI, TR>::add (db::local_processor_cell_context<TS, TI, TR> *parent_context, db::Cell *parent, const db::ICplxTrans &cell_inst)
+{
+  m_drops.push_back (local_processor_cell_drop<TS, TI, TR> (parent_context, parent, cell_inst));
+}
+
+template <class TS, class TI, class TR>
+void
+local_processor_cell_context<TS, TI, TR>::propagate (unsigned int output_layer, const std::unordered_set<TR> &res)
+{
+  if (res.empty ()) {
+    return;
+  }
+
+  db::Layout *subject_layout = 0;
+  shape_reference_translator_with_trans<TR, db::ICplxTrans> rt (subject_layout);
+
+  for (typename std::vector<local_processor_cell_drop<TS, TI, TR> >::const_iterator d = m_drops.begin (); d != m_drops.end (); ++d) {
+
+    tl_assert (d->parent_context != 0);
+    tl_assert (d->parent != 0);
+
+    if (subject_layout != d->parent->layout ()) {
+      subject_layout = d->parent->layout ();
+      rt = shape_reference_translator_with_trans<TR, db::ICplxTrans> (subject_layout);
+    }
+
+    rt.set_trans (d->cell_inst);
+    std::vector<TR> new_refs;
+    new_refs.reserve (res.size ());
+    for (typename std::unordered_set<TR>::const_iterator r = res.begin (); r != res.end (); ++r) {
+      new_refs.push_back (rt (*r));
+    }
+
+    {
+      tl::MutexLocker locker (&d->parent_context->lock ());
+      d->parent_context->propagated (output_layer).insert (new_refs.begin (), new_refs.end ());
+    }
+
+  }
+}
+
+// ---------------------------------------------------------------------------------------------
+//  LocalProcessorCellContexts implementation
+
+template <class TS, class TI, class TR>
+local_processor_cell_contexts<TS, TI, TR>::local_processor_cell_contexts ()
+  : mp_intruder_cell (0)
+{
+  //  .. nothing yet ..
+}
+
+template <class TS, class TI, class TR>
+local_processor_cell_contexts<TS, TI, TR>::local_processor_cell_contexts (const db::Cell *intruder_cell)
+  : mp_intruder_cell (intruder_cell)
+{
+  //  .. nothing yet ..
+}
+
+template <class TS, class TI, class TR>
+db::local_processor_cell_context<TS, TI, TR> *
+local_processor_cell_contexts<TS, TI, TR>::find_context (const context_key_type &intruders)
+{
+  typename std::unordered_map<context_key_type, db::local_processor_cell_context<TS, TI, TR> >::iterator c = m_contexts.find (intruders);
+  return c != m_contexts.end () ? &c->second : 0;
+}
+
+template <class TS, class TI, class TR>
+db::local_processor_cell_context<TS, TI, TR> *
+local_processor_cell_contexts<TS, TI, TR>::create (const context_key_type &intruders)
+{
+  return &m_contexts[intruders];
+}
+
+template <class TR>
+static void
+subtract_set (std::unordered_set<TR> &res, const std::unordered_set<TR> &other)
+{
+  //  for everything else, we don't use a boolean core but just set intersection
+  for (typename std::unordered_set<TR>::const_iterator o = other.begin (); o != other.end (); ++o) {
+    res.erase (*o);
+  }
+}
+
+template <class TS, class TI>
+static void
+subtract (std::unordered_set<db::PolygonRef> &res, const std::unordered_set<db::PolygonRef> &other, db::Layout *layout, const db::local_processor<TS, TI, db::PolygonRef> *proc)
+{
+  if (other.empty ()) {
+    return;
+  }
+
+  if (! proc->boolean_core ()) {
+    subtract_set (res, other);
+    return;
+  }
+
+  size_t max_vertex_count = proc->max_vertex_count ();
+  double area_ratio = proc->area_ratio ();
+
+  db::EdgeProcessor ep;
+  ep.set_base_verbosity (proc->base_verbosity () + 30);
+
+  size_t p1 = 0, p2 = 1;
+
+  for (std::unordered_set<db::PolygonRef>::const_iterator i = res.begin (); i != res.end (); ++i) {
+    const db::PolygonRef &subject = *i;
+    for (db::PolygonRef::polygon_edge_iterator e = subject.begin_edge (); ! e.at_end(); ++e) {
+      ep.insert (*e, p1);
+    }
+    p1 += 2;
+  }
+
+  for (std::unordered_set<db::PolygonRef>::const_iterator i = other.begin (); i != other.end (); ++i) {
+    const db::PolygonRef &subject = *i;
+    for (db::PolygonRef::polygon_edge_iterator e = subject.begin_edge (); ! e.at_end(); ++e) {
+      ep.insert (*e, p2);
+    }
+    p2 += 2;
+  }
+
+  res.clear ();
+  db::BooleanOp op (db::BooleanOp::ANotB);
+  db::PolygonRefGenerator pr (layout, res);
+  db::PolygonSplitter splitter (pr, area_ratio, max_vertex_count);
+  db::PolygonGenerator pg (splitter, true, true);
+  ep.process (pg, op);
+}
+
+template <class TS, class TI>
+static void
+subtract (std::unordered_set<db::PolygonRefWithProperties> &res, const std::unordered_set<db::PolygonRefWithProperties> &other, db::Layout *layout, const db::local_processor<TS, TI, db::PolygonRefWithProperties> *proc)
+{
+  if (other.empty ()) {
+    return;
+  }
+
+  if (! proc->boolean_core ()) {
+    subtract_set (res, other);
+    return;
+  }
+
+  size_t max_vertex_count = proc->max_vertex_count ();
+  double area_ratio = proc->area_ratio ();
+
+  std::unordered_set<db::PolygonRefWithProperties> first;
+  first.swap (res);
+
+  std::map<db::properties_id_type, std::pair<std::vector<const db::PolygonRefWithProperties *>, std::vector<const db::PolygonRefWithProperties *> > > by_prop_id;
+  for (auto i = first.begin (); i != first.end (); ++i)   {
+    by_prop_id [i->properties_id ()].first.push_back (i.operator-> ());
+  }
+  for (auto i = other.begin (); i != other.end (); ++i)   {
+    by_prop_id [i->properties_id ()].second.push_back (i.operator-> ());
+  }
+
+  db::EdgeProcessor ep;
+  ep.set_base_verbosity (proc->base_verbosity () + 30);
+
+  for (auto s2p = by_prop_id.begin (); s2p != by_prop_id.end (); ++s2p) {
+
+    db::properties_id_type prop_id = s2p->first;
+    size_t p1 = 0, p2 = 1;
+
+    ep.clear ();
+
+    for (auto i = s2p->second.first.begin (); i != s2p->second.first.end (); ++i) {
+      ep.insert (**i, p1);
+      p1 += 2;
+    }
+
+    for (auto i = s2p->second.second.begin (); i != s2p->second.second.end (); ++i) {
+      ep.insert (**i, p2);
+      p2 += 2;
+    }
+
+    db::BooleanOp op (db::BooleanOp::ANotB);
+    db::polygon_ref_generator_with_properties<db::PolygonRefWithProperties> pr (layout, res, prop_id);
+    db::PolygonSplitter splitter (pr, area_ratio, max_vertex_count);
+    db::PolygonGenerator pg (splitter, true, true);
+    ep.process (pg, op);
+
+  }
+}
+
+template <class TS, class TI>
+static void
+subtract (std::unordered_set<db::Edge> &res, const std::unordered_set<db::Edge> &other, db::Layout * /*layout*/, const db::local_processor<TS, TI, db::Edge> *proc)
+{
+  if (other.empty ()) {
+    return;
+  }
+
+  if (! proc->boolean_core ()) {
+    subtract_set (res, other);
+    return;
+  }
+
+  db::box_scanner<db::Edge, size_t> scanner;
+  scanner.reserve (res.size () + other.size ());
+
+  for (std::unordered_set<Edge>::const_iterator i = res.begin (); i != res.end (); ++i) {
+    scanner.insert (i.operator-> (), 0);
+  }
+  for (std::unordered_set<Edge>::const_iterator i = other.begin (); i != other.end (); ++i) {
+    scanner.insert (i.operator-> (), 1);
+  }
+
+  std::unordered_set<db::Edge> result;
+  EdgeBooleanClusterCollector<std::unordered_set<db::Edge> > cluster_collector (&result, EdgeNot);
+  scanner.process (cluster_collector, 1, db::box_convert<db::Edge> ());
+
+  res.swap (result);
+}
+
+template <class TS, class TI>
+static void
+subtract (std::unordered_set<db::EdgeWithProperties> &res, const std::unordered_set<db::EdgeWithProperties> &other, db::Layout * /*layout*/, const db::local_processor<TS, TI, db::EdgeWithProperties> *proc)
+{
+  if (other.empty ()) {
+    return;
+  }
+
+  if (! proc->boolean_core ()) {
+    subtract_set (res, other);
+    return;
+  }
+
+  std::unordered_set<db::EdgeWithProperties> first;
+  first.swap (res);
+
+  std::map<db::properties_id_type, std::pair<std::vector<const db::EdgeWithProperties *>, std::vector<const db::EdgeWithProperties *> > > by_prop_id;
+  for (auto i = first.begin (); i != first.end (); ++i)   {
+    by_prop_id [i->properties_id ()].first.push_back (i.operator-> ());
+  }
+  for (auto i = other.begin (); i != other.end (); ++i)   {
+    by_prop_id [i->properties_id ()].second.push_back (i.operator-> ());
+  }
+
+  for (auto s2p = by_prop_id.begin (); s2p != by_prop_id.end (); ++s2p) {
+
+    if (s2p->second.second.empty ()) {
+
+      for (auto i = s2p->second.first.begin (); i != s2p->second.first.end (); ++i) {
+        res.insert (**i);
+      }
+
+    } else {
+
+      db::box_scanner<db::Edge, size_t> scanner;
+      scanner.reserve (s2p->second.first.size () + s2p->second.second.size ());
+
+      for (auto i = s2p->second.first.begin (); i != s2p->second.first.end (); ++i) {
+        scanner.insert (*i, 0);
+      }
+      for (auto i = s2p->second.second.begin (); i != s2p->second.second.end (); ++i) {
+        scanner.insert (*i, 1);
+      }
+
+      db::property_injector<db::Edge, std::unordered_set<db::EdgeWithProperties> > prop_inject (&res, s2p->first);
+      EdgeBooleanClusterCollector<db::property_injector<db::Edge, std::unordered_set<db::EdgeWithProperties> > > cluster_collector (&prop_inject, EdgeNot);
+      scanner.process (cluster_collector, 1, db::box_convert<db::Edge> ());
+
+    }
+
+  }
+}
+
+template <class TS, class TI, class TR>
+static void
+subtract (std::unordered_set<TR> &res, const std::unordered_set<TR> &other, db::Layout * /*layout*/, const db::local_processor<TS, TI, TR> * /*proc*/)
+{
+  subtract_set (res, other);
+}
+
+namespace {
+
+template <class TS, class TI, class TR>
+struct context_sorter
+{
+  bool operator () (const std::pair<const typename local_processor_cell_contexts<TS, TI, TR>::context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> &a,
+                    const std::pair<const typename local_processor_cell_contexts<TS, TI, TR>::context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> &b)
+  {
+    return *a.first < *b.first;
+  }
+};
+
+}
+
+template <class TS, class TI, class TR>
+void
+local_processor_cell_contexts<TS, TI, TR>::compute_results (const local_processor_contexts<TS, TI, TR> &contexts, db::Cell *cell, const local_operation<TS, TI, TR> *op, const std::vector<unsigned int> &output_layers, const local_processor<TS, TI, TR> *proc)
+{
+  CRONOLOGY_COMPUTE_BRACKET(event_compute_results)
+
+  bool first = true;
+  std::vector<std::unordered_set<TR> > common;
+  common.resize (output_layers.size ());
+
+  int index = 0;
+  int total = int (m_contexts.size ());
+
+  //  NOTE: we use the ordering provided by key_type::operator< rather than the unordered map to achieve
+  //  reproducibility across different platforms. unordered_map is faster, but for processing them,
+  //  strict ordering is a more robust choice.
+  std::vector<std::pair<const context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> > sorted_contexts;
+  sorted_contexts.reserve (m_contexts.size ());
+  for (typename std::unordered_map<context_key_type, db::local_processor_cell_context<TS, TI, TR> >::iterator c = m_contexts.begin (); c != m_contexts.end (); ++c) {
+    sorted_contexts.push_back (std::make_pair (&c->first, &c->second));
+  }
+
+  std::sort (sorted_contexts.begin (), sorted_contexts.end (), context_sorter<TS, TI, TR> ());
+
+  for (typename std::vector<std::pair<const context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> >::const_iterator c = sorted_contexts.begin (); c != sorted_contexts.end (); ++c) {
+
+    proc->next ();
+    ++index;
+
+    if (tl::verbosity () >= proc->base_verbosity () + 20) {
+      tl::log << tr ("Computing local results for ") << cell->layout ()->cell_name (cell->cell_index ()) << " (context " << index << "/" << total << ")";
+    }
+
+    if (first) {
+
+      {
+        tl::MutexLocker locker (&c->second->lock ());
+        for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
+          common [o - output_layers.begin ()] = c->second->propagated (*o);
+        }
+      }
+
+      CRONOLOGY_COMPUTE_BRACKET(event_compute_local_cell)
+      proc->compute_local_cell (contexts, cell, mp_intruder_cell, op, *c->first, common);
+      first = false;
+
+    } else {
+
+      std::vector<std::unordered_set<TR> > res;
+      res.resize (output_layers.size ());
+
+      {
+        tl::MutexLocker locker (&c->second->lock ());
+        for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
+          res [o - output_layers.begin ()] = c->second->propagated (*o);
+        }
+      }
+
+      {
+        CRONOLOGY_COMPUTE_BRACKET(event_compute_local_cell)
+        proc->compute_local_cell (contexts, cell, mp_intruder_cell, op, *c->first, res);
+      }
+
+      if (common.empty ()) {
+
+        CRONOLOGY_COMPUTE_BRACKET(event_propagate)
+        for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
+          c->second->propagate (*o, res [o - output_layers.begin ()]);
+        }
+
+//  gcc 4.4.7 (at least) doesn't have an operator== in std::unordered_set, so we skip this
+//  optimization
+#if defined(__GNUC__) && __GNUC__ == 4
+      } else {
+#else
+      } else if (res != common) {
+#endif
+
+        CRONOLOGY_COMPUTE_BRACKET(event_propagate)
+
+        for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
+
+          size_t oi = o - output_layers.begin ();
+
+          std::unordered_set<TR> lost;
+
+          for (typename std::unordered_set<TR>::const_iterator i = common[oi].begin (); i != common[oi].end (); ++i) {
+            if (res[oi].find (*i) == res[oi].end ()) {
+              lost.insert (*i);
+            }
+          }
+
+          if (! lost.empty ()) {
+
+            subtract (lost, res[oi], cell->layout (), proc);
+
+            if (! lost.empty ()) {
+              subtract (common[oi], lost, cell->layout (), proc);
+              for (typename std::vector<std::pair<const context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> >::const_iterator cc = sorted_contexts.begin (); cc != c; ++cc) {
+                cc->second->propagate (*o, lost);
+              }
+            }
+
+          }
+
+        }
+
+        for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
+
+          std::unordered_set<TR> gained;
+
+          size_t oi = o - output_layers.begin ();
+          for (typename std::unordered_set<TR>::const_iterator i = res[oi].begin (); i != res[oi].end (); ++i) {
+            if (common[oi].find (*i) == common[oi].end ()) {
+              gained.insert (*i);
+            }
+          }
+
+          if (! gained.empty ()) {
+
+            subtract (gained, common[oi], cell->layout (), proc);
+
+            if (! gained.empty ()) {
+              c->second->propagate (*o, gained);
+            }
+
+          }
+
+        }
+
+      }
+
+    }
+
+  }
+
+  for (std::vector<unsigned int>::const_iterator o = output_layers.begin (); o != output_layers.end (); ++o) {
+    size_t oi = o - output_layers.begin ();
+    proc->push_results (cell, *o, common[oi]);
+  }
+}
+
+// ---------------------------------------------------------------------------------------------
+
+//  NOTE: don't forget to update the explicit instantiations in dbHierProcessor.cc
+
+//  explicit instantiations
+template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Polygon, db::Polygon>;
+template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Text, db::Polygon>;
+template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Edge, db::Polygon>;
+template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Text, db::Text>;
+template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Edge, db::Edge>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::PolygonRefWithProperties>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgeWithProperties>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgePairWithProperties>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonWithProperties, db::PolygonWithProperties, db::PolygonWithProperties>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgeWithProperties>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgePairWithProperties>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonRef, db::PolygonRef, db::PolygonRef>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonRef, db::Edge, db::PolygonRef>;
+template class DB_PUBLIC local_processor_cell_context<db::PolygonRef, db::PolygonRef, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_context<db::Polygon, db::Polygon, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_context<db::Edge, db::Edge, db::Edge>;
+template class DB_PUBLIC local_processor_cell_context<db::Edge, db::Polygon, db::Edge>;
+template class DB_PUBLIC local_processor_cell_context<db::Edge, db::Edge, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::Polygon, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::PolygonRef, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::Edge, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::Polygon, db::Polygon>;
+template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::PolygonRef, db::PolygonRef>;
+template class DB_PUBLIC local_processor_cell_context<db::EdgePair, db::Edge, db::Edge>;
+
+//  explicit instantiations
+template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Polygon, db::Polygon>;
+template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Edge, db::Polygon>;
+template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Edge, db::Edge>;
+template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Text, db::Polygon>;
+template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Text, db::Text>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::PolygonRefWithProperties>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgeWithProperties>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgePairWithProperties>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRefWithProperties, db::PolygonRefWithProperties, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonWithProperties, db::PolygonWithProperties, db::PolygonWithProperties>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgeWithProperties>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgePairWithProperties>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonWithProperties, db::PolygonWithProperties, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRef, db::PolygonRef, db::PolygonRef>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRef, db::Edge, db::PolygonRef>;
+template class DB_PUBLIC local_processor_cell_contexts<db::PolygonRef, db::PolygonRef, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_contexts<db::Polygon, db::Polygon, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_contexts<db::Edge, db::PolygonRef, db::Edge>;
+template class DB_PUBLIC local_processor_cell_contexts<db::Edge, db::Polygon, db::Edge>;
+template class DB_PUBLIC local_processor_cell_contexts<db::Edge, db::Edge, db::Edge>;
+template class DB_PUBLIC local_processor_cell_contexts<db::Edge, db::Edge, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::Polygon, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::PolygonRef, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::Edge, db::EdgePair>;
+template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::Polygon, db::Polygon>;
+template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::PolygonRef, db::PolygonRef>;
+template class DB_PUBLIC local_processor_cell_contexts<db::EdgePair, db::Edge, db::Edge>;
+
+}
+
diff --git a/src/db/db/dbHierProcessorUtils.h b/src/db/db/dbHierProcessorUtils.h
new file mode 100644
index 000000000..1bd209315
--- /dev/null
+++ b/src/db/db/dbHierProcessorUtils.h
@@ -0,0 +1,308 @@
+
+/*
+
+  KLayout Layout Viewer
+  Copyright (C) 2006-2024 Matthias Koefferlein
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+#ifndef HDR_dbHierProcessorUtils
+#define HDR_dbHierProcessorUtils
+
+#include "dbCommon.h"
+#include "dbLayout.h"
+#include "tlThreads.h"
+
+#include <unordered_map>
+
+namespace db
+{
+
+// ---------------------------------------------------------------------------------------------
+//  determines the default boolean core flag per result type
+
+template <class TR>
+struct default_boolean_core
+{
+  bool operator() () const { return false; }
+};
+
+template <>
+struct default_boolean_core<db::PolygonRef>
+{
+  bool operator() () const { return true; }
+};
+
+// ---------------------------------------------------------------------------------------------
+//  Shape reference translator
+
+template <class Ref> class shape_reference_translator;
+template <class Ref, class Trans> class shape_reference_translator_with_trans;
+
+template <class Ref>
+class shape_reference_translator
+{
+public:
+  typedef typename Ref::shape_type shape_type;
+  typedef typename Ref::trans_type ref_trans_type;
+
+  shape_reference_translator (db::Layout *target_layout)
+    : mp_layout (target_layout)
+  {
+    //  .. nothing yet ..
+  }
+
+  Ref operator() (const Ref &ref) const
+  {
+    typename std::unordered_map<const shape_type *, const shape_type *>::const_iterator m = m_cache.find (ref.ptr ());
+    if (m != m_cache.end ()) {
+
+      return Ref (m->second, ref.trans ());
+
+    } else {
+
+      const shape_type *ptr;
+      {
+        tl::MutexLocker locker (&mp_layout->lock ());
+        ptr = mp_layout->shape_repository ().repository (typename shape_type::tag ()).insert (ref.obj ());
+      }
+
+      m_cache[ref.ptr ()] = ptr;
+      return Ref (ptr, ref.trans ());
+
+    }
+  }
+
+  template <class Trans>
+  Ref operator() (const Ref &ref, const Trans &tr) const
+  {
+    shape_type sh = ref.obj ().transformed (tr * Trans (ref.trans ()));
+    ref_trans_type red_trans;
+    sh.reduce (red_trans);
+
+    typename std::unordered_map<shape_type, const shape_type *>::const_iterator m = m_cache_by_shape.find (sh);
+    if (m != m_cache_by_shape.end ()) {
+
+      return Ref (m->second, red_trans);
+
+    } else {
+
+      const shape_type *ptr;
+      {
+        tl::MutexLocker locker (&mp_layout->lock ());
+        ptr = mp_layout->shape_repository ().repository (typename shape_type::tag ()).insert (sh);
+      }
+
+      m_cache_by_shape[sh] = ptr;
+      return Ref (ptr, red_trans);
+
+    }
+  }
+
+private:
+  db::Layout *mp_layout;
+  mutable std::unordered_map<const shape_type *, const shape_type *> m_cache;
+  mutable std::unordered_map<shape_type, const shape_type *> m_cache_by_shape;
+};
+
+template <class Shape>
+class simple_shape_reference_translator
+{
+public:
+  typedef Shape shape_type;
+
+  simple_shape_reference_translator ()
+  {
+    //  .. nothing yet ..
+  }
+
+  const shape_type &operator() (const shape_type &s) const
+  {
+    return s;
+  }
+
+  template <class Trans>
+  shape_type operator() (const shape_type &s, const Trans &tr) const
+  {
+    return s.transformed (tr);
+  }
+};
+
+template <>
+class shape_reference_translator<db::Edge>
+  : public simple_shape_reference_translator<db::Edge>
+{
+public:
+  shape_reference_translator (db::Layout * /*target_layout*/) { }
+};
+
+template <>
+class shape_reference_translator<db::Polygon>
+  : public simple_shape_reference_translator<db::Polygon>
+{
+public:
+  shape_reference_translator (db::Layout * /*target_layout*/) { }
+};
+
+template <>
+class shape_reference_translator<db::Text>
+  : public simple_shape_reference_translator<db::Text>
+{
+public:
+  shape_reference_translator (db::Layout * /*target_layout*/) { }
+};
+
+template<class Basic>
+class shape_reference_translator<db::object_with_properties<Basic> >
+  : public shape_reference_translator<Basic>
+{
+public:
+  typedef db::object_with_properties<Basic> shape_type;
+
+  shape_reference_translator (db::Layout *target_layout)
+    : shape_reference_translator<Basic> (target_layout)
+  {
+    //  .. nothing yet ..
+  }
+
+  shape_type operator() (const shape_type &s) const
+  {
+    return shape_type (shape_reference_translator<Basic>::operator () (s), s.properties_id ());
+  }
+
+  template <class Trans>
+  shape_type operator() (const shape_type &s, const Trans &tr) const
+  {
+    return shape_type (shape_reference_translator<Basic>::operator () (s, tr), s.properties_id ());
+  }
+};
+
+template <class Ref, class Trans>
+class shape_reference_translator_with_trans_from_shape_ref
+{
+public:
+  typedef typename Ref::shape_type shape_type;
+  typedef typename Ref::trans_type ref_trans_type;
+
+  shape_reference_translator_with_trans_from_shape_ref (db::Layout *target_layout)
+    : mp_layout (target_layout)
+  {
+    //  .. nothing yet ..
+  }
+
+  void set_trans (const Trans &trans)
+  {
+    m_trans = trans;
+    m_ref_trans = ref_trans_type (trans);
+    m_bare_trans = Trans (m_ref_trans.inverted ()) * trans;
+  }
+
+  Ref operator() (const Ref &ref) const
+  {
+    auto m = m_cache.find (std::make_pair (ref.ptr (), m_bare_trans));
+    if (m != m_cache.end ()) {
+
+      return Ref (m->second.first, ref_trans_type (m_trans * Trans (ref.trans ())) * m->second.second);
+
+    } else {
+
+      shape_type sh = ref.obj ().transformed (m_bare_trans);
+      ref_trans_type red_trans;
+      sh.reduce (red_trans);
+
+      const shape_type *ptr;
+      {
+        tl::MutexLocker locker (&mp_layout->lock ());
+        ptr = mp_layout->shape_repository ().repository (typename shape_type::tag ()).insert (sh);
+      }
+
+      m_cache[std::make_pair (ref.ptr (), m_bare_trans)] = std::make_pair (ptr, red_trans);
+
+      return Ref (ptr, ref_trans_type (m_trans * Trans (ref.trans ())) * red_trans);
+
+    }
+  }
+
+private:
+  db::Layout *mp_layout;
+  Trans m_trans;
+  ref_trans_type m_ref_trans;
+  Trans m_bare_trans;
+  mutable std::unordered_map<std::pair<const shape_type *, Trans>, std::pair<const shape_type *, ref_trans_type> > m_cache;
+};
+
+template <class Trans>
+class shape_reference_translator_with_trans<db::PolygonRef, Trans>
+  : public shape_reference_translator_with_trans_from_shape_ref<db::PolygonRef, Trans>
+{
+public:
+  shape_reference_translator_with_trans (db::Layout *target_layout)
+    : shape_reference_translator_with_trans_from_shape_ref<db::PolygonRef, Trans> (target_layout)
+  {
+    //  .. nothing yet ..
+  }
+};
+
+template <class Sh, class Trans>
+class shape_reference_translator_with_trans
+{
+public:
+  typedef Sh shape_type;
+
+  shape_reference_translator_with_trans (db::Layout * /*target_layout*/)
+  {
+    //  .. nothing yet ..
+  }
+
+  void set_trans (const Trans &trans)
+  {
+    m_trans = trans;
+  }
+
+  shape_type operator() (const shape_type &s) const
+  {
+    return s.transformed (m_trans);
+  }
+
+private:
+  Trans m_trans;
+};
+
+template <class Basic, class Trans>
+class shape_reference_translator_with_trans<db::object_with_properties<Basic>, Trans>
+  : public shape_reference_translator_with_trans<Basic, Trans>
+{
+public:
+  typedef db::object_with_properties<Basic> shape_type;
+
+  shape_reference_translator_with_trans (db::Layout *target_layout)
+    : shape_reference_translator_with_trans<Basic, Trans> (target_layout)
+  {
+    //  .. nothing yet ..
+  }
+
+  shape_type operator() (const shape_type &s) const
+  {
+    //  CAUTION: no property ID translation happens here (reasoning: the main use case is fake ID for net tagging)
+    return shape_type (shape_reference_translator_with_trans<Basic, Trans>::operator () (s), s.properties_id ());
+  }
+};
+
+}
+
+#endif
+