Array bounds check elimination for the Java HotSpot™ client compiler. - Thomas Würthinger; Christian Wimmer; Hanspeter Mössenböck (PPPJ, 2007)

Visualization of Program Dependence Graphs. - Thomas Würthinger; Christian Wimmer; Hanspeter Mössenböck (CC, 2008)

Multi-level Virtual Machine Debugging Using the Java Platform Debugger Architecture. - Thomas Würthinger; Michael L. Van de Vanter; Doug Simon (Ershov Memorial Conference, 2009)

Lazy continuations for Java virtual machines. - Lukas Stadler; Christian Wimmer; Thomas Würthinger; Hanspeter Mössenböck; John Rose (PPPJ, 2009)

Array bounds check elimination in the context of deoptimization. - Thomas Würthinger; Christian Wimmer; Hanspeter Mössenböck (Sci. Comput. Program., 2009)

Improving aspect-oriented programming with dynamic code evolution in an enhanced Java virtual machine. - Thomas Würthinger; Walter Binder; Danilo Ansaloni; Philippe Moret; Hanspeter Mössenböck (RAM-SE@ECOOP, 2010)

Applications of enhanced dynamic code evolution for Java in GUI development and dynamic aspect-oriented programming. - Thomas Würthinger; Walter Binder; Danilo Ansaloni; Philippe Moret; Hanspeter Mössenböck (GPCE, 2010)

Efficient coroutines for the Java platform. - Lukas Stadler; Thomas Würthinger; Christian Wimmer (PPPJ, 2010)

Dynamic code evolution for Java. - Thomas Würthinger; Christian Wimmer; Lukas Stadler (PPPJ, 2010)

Improving compiler-runtime separation with XIR. - Ben L. Titzer; Thomas Würthinger; Doug Simon; Marcelo Cintra (VEE, 2010)

Dynamic Code Evolution for Java. - Thomas Würthinger (2011)

Dynamische Code-Evolution für Java. - Thomas Würthinger (Ausgezeichnete Informatikdissertationen, 2011)

Extending the graal compiler to optimize libraries. - Thomas Würthinger (OOPSLA Companion, 2011)

Safe and atomic run-time code evolution for Java and its application to dynamic AOP. - Thomas Würthinger; Danilo Ansaloni; Walter Binder; Christian Wimmer; Hanspeter Mössenböck (OOPSLA, 2011)

Self-optimizing AST interpreters. - Thomas Würthinger; Andreas Wöß; Lukas Stadler; Gilles Duboscq; Doug Simon; Christian Wimmer (DLS, 2012)

Compilation queuing and graph caching for dynamic compilers. - Lukas Stadler; Gilles Duboscq; Hanspeter Mössenböck; Thomas Würthinger (VMIL@SPLASH, 2012)

Truffle: a self-optimizing runtime system. - Christian Wimmer; Thomas Würthinger (SPLASH, 2012)

An experimental study of the influence of dynamic compiler optimizations on Scala performance. - Lukas Stadler; Gilles Duboscq; Hanspeter Mössenböck; Thomas Würthinger; Doug Simon (SCALA@ECOOP, 2013)

An intermediate representation for speculative optimizations in a dynamic compiler. - Gilles Duboscq; Thomas Würthinger; Lukas Stadler; Christian Wimmer; Doug Simon; Hanspeter Mössenböck (VMIL@SPLASH, 2013)

One VM to rule them all. - Thomas Würthinger; Christian Wimmer; Andreas Wöß; Lukas Stadler; Gilles Duboscq; Christian Humer; Gregor Richards; Doug Simon; Mario Wolczko (Onward!, 2013)

Unrestricted and safe dynamic code evolution for Java. - Thomas Würthinger; Christian Wimmer; Lukas Stadler (Sci. Comput. Program., 2013)

Graal and truffle: modularity and separation of concerns as cornerstones for building a multipurpose runtime. - Thomas Würthinger (MODULARITY (Companion), 2014)

Partial Escape Analysis and Scalar Replacement for Java. - Lukas Stadler; Thomas Würthinger; Hanspeter Mössenböck (CGO, 2014)

An efficient approach for accessing C data structures from JavaScript. - Matthias Grimmer; Thomas Würthinger; Andreas Wöß; Hanspeter Mössenböck (ICOOOLPS@ECOOP, 2014)

A domain-specific language for building self-optimizing AST interpreters. - Christian Humer; Christian Wimmer; Christian Wirth 002; Andreas Wöß; Thomas Würthinger (GPCE, 2014)

Speculation without regret: reducing deoptimization meta-data in the Graal compiler. - Gilles Duboscq; Thomas Würthinger; Hanspeter Mössenböck (PPPJ, 2014)

Dynamically composing languages in a modular way: supporting C extensions for dynamic languages. - Matthias Grimmer; Chris Seaton; Thomas Würthinger; Hanspeter Mössenböck (MODULARITY, 2015)

High-performance cross-language interoperability in a multi-language runtime. - Matthias Grimmer; Chris Seaton; Roland Schatz; Thomas Würthinger; Hanspeter Mössenböck (DLS, 2015)

Memory-safe Execution of C on a Java VM. - Matthias Grimmer; Roland Schatz; Chris Seaton; Thomas Würthinger; Hanspeter Mössenböck (PLAS@ECOOP, 2015)

Snippets: Taking the High Road to a Low Level. - Doug Simon; Christian Wimmer; Bernhard Urban; Gilles Duboscq; Lukas Stadler; Thomas Würthinger (ACM Trans. Archit. Code Optim., 2015)

Bringing low-level languages to the JVM: efficient execution of LLVM IR on Truffle. - Manuel Rigger; Matthias Grimmer; Christian Wimmer; Thomas Würthinger; Hanspeter Mössenböck (VMIL@SPLASH, 2016)

Trace-based Register Allocation in a JIT Compiler. - Josef Eisl; Matthias Grimmer; Doug Simon; Thomas Würthinger; Hanspeter Mössenböck (PPPJ, 2016)

One compiler: deoptimization to optimized code. - Christian Wimmer; Vojin Jovanovic; Erik Eckstein; Thomas Würthinger (CC, 2017)

Practical partial evaluation for high-performance dynamic language runtimes. - Thomas Würthinger; Christian Wimmer; Christian Humer; Andreas Wöß; Lukas Stadler; Chris Seaton; Gilles Duboscq; Doug Simon; Matthias Grimmer (PLDI, 2017)

Trace Register Allocation Policies: Compile-time vs. Performance Trade-offs. - Josef Eisl; Stefan Marr; Thomas Würthinger; Hanspeter Mössenböck (ManLang, 2017)

Applying Optimizations for Dynamically-typed Languages to Java. - Matthias Grimmer; Stefan Marr; Mario Kahlhofer; Christian Wimmer; Thomas Würthinger; Hanspeter Mössenböck (ManLang, 2017)

Making collection operations optimal with aggressive JIT compilation. - Aleksandar Prokopec; David Leopoldseder; Gilles Duboscq; Thomas Würthinger (SCALA@SPLASH, 2017)

Micro-Benchmarking Considered Harmful. - Thomas Würthinger (ICPE, 2017)

Dominance-based duplication simulation (DBDS): code duplication to enable compiler optimizations. - David Leopoldseder; Lukas Stadler; Thomas Würthinger; Josef Eisl; Doug Simon; Hanspeter Mössenböck (CGO, 2018)

A cost model for a graph-based intermediate-representation in a dynamic compiler. - David Leopoldseder; Lukas Stadler; Manuel Rigger; Thomas Würthinger; Hanspeter Mössenböck (VMIL@SPLASH, 2018)

Fast-path loop unrolling of non-counted loops to enable subsequent compiler optimizations. - David Leopoldseder; Roland Schatz; Lukas Stadler; Manuel Rigger; Thomas Würthinger; Hanspeter Mössenböck (ManLang, 2018)

Fast, Flexible, Polyglot Instrumentation Support for Debuggers and other Tools. - Michael L. Van de Vanter; Chris Seaton; Michael Haupt; Christian Humer; Thomas Würthinger (Art Sci. Eng. Program., 2018)

Cross-Language Interoperability in a Multi-Language Runtime. - Matthias Grimmer; Roland Schatz; Chris Seaton; Thomas Würthinger; Mikel Luján (ACM Trans. Program. Lang. Syst., 2018)

An Optimization-Driven Incremental Inline Substitution Algorithm for Just-in-Time Compilers. - Aleksandar Prokopec; Gilles Duboscq; David Leopoldseder; Thomas Würthinger (CGO, 2019)

Renaissance: a modern benchmark suite for parallel applications on the JVM. - Aleksandar Prokopec; Andrea Rosà; David Leopoldseder; Gilles Duboscq; Petr Tuma 001; Martin Studener; Lubomír Bulej; Yudi Zheng; Alex Villazón; Doug Simon; Thomas Würthinger; Walter Binder (SPLASH (Companion Volume), 2019)

Renaissance: benchmarking suite for parallel applications on the JVM. - Aleksandar Prokopec; Andrea Rosà; David Leopoldseder; Gilles Duboscq; Petr Tuma 001; Martin Studener; Lubomír Bulej; Yudi Zheng; Alex Villazón; Doug Simon; Thomas Würthinger; Walter Binder (PLDI, 2019)

On Evaluating the Renaissance Benchmarking Suite: Variety, Performance, and Complexity. - Aleksandar Prokopec; Andrea Rosà; David Leopoldseder; Gilles Duboscq; Petr Tuma 001; Martin Studener; Lubomír Bulej; Yudi Zheng; Alex Villazón; Doug Simon; Thomas Würthinger; Walter Binder (CoRR, 2019)

Initialize once, start fast: application initialization at build time. - Christian Wimmer; Codrut Stancu; Peter Hofer; Vojin Jovanovic; Paul Wögerer; Peter B. Kessler; Oleg Pliss; Thomas Würthinger (Proc. ACM Program. Lang., 2019)

GraalSP: Polyglot, efficient, and robust machine learning-based static profiler. - Milan Cugurovic; Milena Vujosevic-Janicic; Vojin Jovanovic; Thomas Würthinger (J. Syst. Softw., 2024)

Scaling Type-Based Points-to Analysis with Saturation. - Christian Wimmer; Codrut Stancu; David Kozak; Thomas Würthinger (Proc. ACM Program. Lang., 2024)