The subgraph enumeration problem asks us to find all subgraphs of a target graph that are isomorphic to a given pattern graph. Determining whether even one such isomorphic subgraph exists is N P-complete-and therefore finding all such subgraphs (if they exist) is a time-consuming task. Subgraph enumeration has applications in many fields, including biochemistry and social networks, and interestingly the fastest algorithms for solving the problem for biochemical inputs are sequential. Since they depend on depth-first tree traversal, an efficient parallelization is far from trivial. Nevertheless, since important applications produce data sets with increasing difficulty, parallelism seems beneficial.We thus present here a shared-memory parallelization of the state-of-the-art subgraph enumeration algorithms RI and RI-DS (a variant of RI for dense graphs) by Bonnici et al. [BMC Bioinformatics, 2013]. Our strategy uses work stealing and our implementation demonstrates a significant speedup on real-world biochemical data-despite a highly irregular data access pattern. We also improve RI-DS by pruning the search space better; this further improves the empirical running times compared to the already highly tuned RI-DS.Graphs are used in a plethora of fields to model relations or interactions between entities. One frequently occurring (sub)task in graph-based analysis is the subgraph isomorphism problem (SGI). It requires finding a smaller pattern graph G p in a larger target graph G t or, equivalently, finding an injection from the nodes of G p to the nodes of G t such that the edges of G p are preserved. The SGI decision problem is N P-complete [1]. Finding all isomorphic subgraphs of G p in G t is commonly referred to as the subgraph enumeration (SGE) problem; this is the problem we deal with in this paper. Note that SGE algorithms require exponential time in the worst case, as there may be exponentially many matches to enumerate.Efficient algorithms for SGI exist only for special cases such as planar graphs [2], where a linear time algorithm exists for constant query graph size; this method can further be used to count the number of occurrences of the query graph in linear time. Consequently, the most successful tools in practice for more general graphs are quite time-consuming when one or all exact subgraphs are sought [3]. At the same time, the data volumes in common SGI and SGE applications are steadily increasing. Example fields are life science [4], complex network analysis [3,5], decompilation of computer programs [6], and computer vision [7]. A problem related to SGE is motif discovery, where the goal is to find all frequent subgraphs up to a very small size [8]; note