How can we evaluate a global query on huge graphs in 0.1 seconds? Given ourcurrent technology, that would be magic. The lack of wizarding skills did notstop us, however, from tackling the problem by using smart caching structures,which are witchcrafts on their own. Why is this challenge important? Several applications evaluate global querieson continuously changing graphs: [fraud detection in financialtransactions], [analysis of source coderepositories] and [validating engineeringmodels].Current approaches employ domain-specific optimizations, which are difficultand error-prone to implement. Meanwhile, the requirements of these (andsimilar) use cases could be uniformly addressed by incremental graph queryevaluation. With this technique, the first execution of the queries takes sometime, but once the result are calculated, they can be efficiently maintainedfor each change in the graph. To allow incremental queries on property graphs, we implemented the[ingraph] engine, based on the[openCypher] language specification. We aim tosupport the [standardsubset] of openCypher, as most standard constructs can be calculatedincrementally. We already mapped some of the standard constructs to[relational algebra], defined [incremental relational algebraicoperators] andimplemented them in an [incremental relationalengine] using [Akka] actors. We start the talk by presenting use cases that evaluate complex global querieson continuously changing graphs and discuss the idea of incremental graphqueries. We show the mapping of basic openCypher constructs (e.g. `MATCH`,`WHERE`, `WITH`, `RETURN`) to relational operators, such as joins, selectionsand projections. Finally, we show our approach for optimizing incrementalgraph queries and outline related challenges. Target audience: Developers, looking for a deeper understanding of openCypherand/or facing complex queries on continuously changing graphs