About

Ravi Chugh is an Associate Professor of Computer Science at the University of Chicago, where he has been a faculty member since 2014. He was promoted to Associate Professor in 2021 and is set to serve as the Director of Undergraduate Studies starting July 2023. Ravi received his Ph.D. from the University of California, San Diego in 2013. His research focuses on programming language technology, including program synthesis, type systems, and program analysis techniques, with the goal of enabling more user-friendly integrated development environments (IDEs) and more programmable graphical user interfaces (GUIs). His interests extend to exploring interfaces between people and technologies, as well as devising new ways of programming the computers of today and tomorrow. Ravi has been recognized with several awards, including an NSF CAREER Award in 2017 and a Neubauer Fellowship from UChicago in 2015 for his innovative and effective undergraduate teaching.

Research topics

• Computer Science
• Programming language
• Artificial Intelligence
• Theoretical computer science
• Human–computer interaction
• Software engineering

Selected publications

• Code Style Sheets: CSS for Code

  ArXiv.org · 2025-02-13 · 1 citations

  preprintOpen accessSenior author

  Program text is rendered using impoverished typographic styles. Beyond choice of fonts and syntax-highlighting colors, code editors and related tools utilize very few text decorations. These limited styles are, furthermore, applied in monolithic fashion, regardless of the programs and tasks at hand. We present the notion of _code style sheets_ for styling program text. Motivated by analogy to cascading style sheets (CSS) for styling HTML documents, code style sheets provide mechanisms for defining rules to select elements from an abstract syntax tree (AST) in order to style their corresponding visual representation. Technically, our selector language generalizes essential constructs from CSS to a programming-language setting with algebraic data types (such as ASTs). Practically, code style sheets allow ASTs to be styled granularly, based on semantic information -- such as the structure of abstract syntax, static type information, and corresponding run-time values -- as well as design choices on the part of authors and readers of a program. Because programs are heavily nested in structure, a key aspect of our design is a layout algorithm that renders nested, multiline text blocks more compactly than in existing box-based layout systems such as HTML. In this paper, we design and implement a code style sheets system for a subset of Haskell, using it to illustrate several code presentation and visualization tasks. These examples demonstrate that code style sheets provide a uniform framework for rendering programs in multivarious ways, which could be employed in future designs for text-based as well as structure editors.

  PublisherOA PDFDOI

• Code Style Sheets: CSS for Code

  Proceedings of the ACM on Programming Languages · 2025-04-09 · 4 citations

  articleOpen accessSenior author

  Program text is rendered using impoverished typographic styles. Beyond choice of fonts and syntax-highlighting colors, code editors and related tools utilize very few text decorations. These limited styles are, furthermore, applied in monolithic fashion, regardless of the programs and tasks at hand. We present the notion of _code style sheets_ for styling program text. Motivated by analogy to cascading style sheets (CSS) for styling HTML documents, code style sheets provide mechanisms for defining rules to select elements from an abstract syntax tree (AST) in order to style their corresponding visual representation. Technically, our selector language generalizes essential constructs from CSS to a programming-language setting with algebraic data types (such as ASTs). Practically, code style sheets allow ASTs to be styled granularly, based on semantic information—such as the structure of abstract syntax, static type information, and corresponding run-time values—as well as design choices on the part of authors and readers of a program. Because programs are heavily nested in structure, a key aspect of our design is a layout algorithm that renders nested, multiline text blocks more compactly than in existing box-based layout systems such as HTML. In this paper, we design and implement a code style sheets system for a subset of Haskell, using it to illustrate several code presentation and visualization tasks. These examples demonstrate that code style sheets provide a uniform framework for rendering programs in multivarious ways, which could be employed in future designs for text-based as well as structure editors.

  PublisherDOI

• Slowness, Politics, and Joy: Values That Guide Technology Choices in Creative Coding Classrooms

  2025-01-31 · 1 citations

  preprintOpen accessSenior author

  There are many tools and technologies for making art with code, each embodying distinct values and affordances. Within this landscape, creative coding educators must evaluate how different tools map onto their own principles and examine the potential impacts of those choices on students' learning and artistic development. Understanding the values guiding these decisions is critical, as they reflect insights about these contexts, communities, and pedagogies. We explore these values through semi-structured interviews with (N=12) creative coding educators and toolbuilders. We identify three major themes: slowness (how friction can make room for reflection), politics (including the lasting effects of particular technologies), and joy (or the capacity for playful engagement). The lessons and priorities voiced by our participants offer valuable, transferable perspectives---like preferring community building (such as through documentation) over techno-solutionism. We demonstrate application of these critical lenses to two tool design areas (accessibility and AI assistance).

  PublisherDOI

• Ragged Blocks: Rendering Structured Text with Style

  2025-09-27

  preprintOpen accessSenior author

  Boxes Layout Rocks LayoutRocks Layout, Simplified Figure 1: A code fragment rendered without nested styling, with nested boxes, with rocks, and with simplified rocks.

  PublisherOA PDFDOI

• Slowness, Politics, and Joy: Values That Guide Technology Choices in Creative Coding Classrooms

  2025-04-24 · 1 citations

  articleOpen accessSenior author
  PublisherDOI

• A Study of Editor Features in a Creative Coding Classroom

  2023-04-19 · 16 citations

  articleSenior author

  Creative coding is a rapidly expanding domain for both artistic expression and computational education. Numerous libraries and IDEs support creative coding, however there has been little consideration of how the environments themselves might be designed to serve these twin goals. To investigate this gap, we implemented and used an experimental editor to teach a sequence of college and high-school creative coding courses. In the first year, we conducted a log analysis of student work (n=39) and surveys regarding prospective features (n=25). These guided our implementation of common enhancements (e.g. color pickers) as well as uncommon ones (e.g. bidirectional shape editing). In the second year, we studied the effects of these features through logging (n=39+) and survey (n=23) studies. Reflecting on the results, we identify opportunities to improve creativity- and novice-focused IDEs and highlight tensions in their design—as in tools that augment artistry or efficiency but may be perceived as hindering learning.

  PublisherDOI

• Projectional Editors for JSON-Based DSLs

  2023-10-03 · 4 citations

  articleSenior author

  Augmenting text-based programming with rich structured interactions has been explored in many ways. Among these, projectional editors offer an enticing combination of structure editing and domain-specific program visualization. Yet such tools are typically bespoke and expensive to produce, leaving them inaccessible to many DSL and application designers. We describe a relatively inexpensive way to build rich projectional editors for a large class of DSLs—namely, those defined using JSON. Given any such JSON-based DSL, we derive a projectional editor through (i) a language-agnostic mapping from JSON Schemas to structure-editor GUIs and (ii) an API for application designers to implement custom views for the domain-specific types described in a schema. We implement these ideas in a prototype, Prong, which we illustrate with several examples including the Vega and Vega-Lite data visualization DSLs.

  PublisherDOI

• Projectional Editors for JSON-Based DSLs

  arXiv (Cornell University) · 2023-07-20

  preprintOpen accessSenior author

  Augmenting text-based programming with rich structured interactions has been explored in many ways. Among these, projectional editors offer an enticing combination of structure editing and domain-specific program visualization. Yet such tools are typically bespoke and expensive to produce, leaving them inaccessible to many DSL and application designers. We describe a relatively inexpensive way to build rich projectional editors for a large class of DSLs -- namely, those defined using JSON. Given any such JSON-based DSL, we derive a projectional editor through (i) a language-agnostic mapping from JSON Schemas to structure-editor GUIs and (ii) an API for application designers to implement custom views for the domain-specific types described in a schema. We implement these ideas in a prototype, Prong, which we illustrate with several examples including the Vega and Vega-Lite data visualization DSLs.

  PublisherOA PDFDOI

• A Study of Editor Features in a Creative Coding Classroom

  arXiv (Cornell University) · 2023-01-30 · 1 citations

  preprintOpen accessSenior author

  Creative coding is a rapidly expanding domain for both artistic expression and computational education. Numerous libraries and IDEs support creative coding, however there has been little consideration of how the environments themselves might be designed to serve these twin goals. To investigate this gap, we implemented and used an experimental editor to teach a sequence of college and high-school creative coding courses. In the first year, we conducted a log analysis of student work (n=39) and surveys regarding prospective features (n=25). These guided our implementation of common enhancements (e.g. color pickers) as well as uncommon ones (e.g. bidirectional shape editing). In the second year, we studied the effects of these features through logging (n=39+) and survey (n=23) studies. Reflecting on the results, we identify opportunities to improve creativity- and novice-focused IDEs and highlight tensions in their design -- as in tools that augment artistry or efficiency but may be perceived as hindering learning.

  PublisherOA PDFDOI

• Maniposynth: Bimodal Tangible Functional Programming

  DROPS (Schloss Dagstuhl – Leibniz Center for Informatics) · 2022-01-01 · 2 citations

  preprintOpen accessSenior author

  Traditionally, writing code is a non-graphical, abstract, and linear process. Not everyone is comfortable with this way of thinking at all times. Can programming be transformed into a graphical, concrete, non-linear activity? While nodes-and-wires and blocks-based programming environments do leverage graphical direct manipulation, users perform their manipulations on abstract syntax tree elements, which are still abstract. Is it possible to be more concrete - could users instead directly manipulate live program values to create their program? We present a system, Maniposynth, that reimagines functional programming as a non-linear workflow where program expressions are spread on a 2D canvas. The live results of those expressions are continuously displayed and available for direct manipulation. The non-linear canvas liberates users to work out-of-order, and the live values can be interacted with via drag-and-drop. Incomplete programs are gracefully handled via hole expressions, which allow Maniposynth to offer program synthesis. Throughout the workflow, the program is valid OCaml code which the user may inspect and edit in their preferred text editor at any time. With Maniposynth's direct manipulation features, we created 38 programs drawn from a functional data structures course. We additionally hired two professional OCaml developers to implement a subset of these programs. We report on these experiences and discuss to what degree Maniposynth meets its goals of providing a non-linear, concrete, graphical programming workflow.

  PublisherDOI

Recent grants

• SHF: Small: Collaborative Research: Semantic Foundations for Hole-Driven Development

  NSF · $247k · 2018–2021

• CAREER: Direct Manipulation Programming Systems

  NSF · $526k · 2017–2022

Frequent coauthors

• Brian Hempel

  16 shared

• Ranjit Jhala

  12 shared

• Justin Lubin

  University of California, Berkeley

  11 shared

• Cyrus Omar

  University of Michigan–Ann Arbor

  9 shared

• Ian Voysey

  Carnegie Mellon University

  6 shared

• Andrew McNutt

  5 shared

• Nick Collins

  Durham University

  5 shared

• Patrick M. Rondon

  Google (United States)

  4 shared

Education

• Ph.D.

  University of California, San Diego

  2013

Awards & honors

• NSF CAREER Award (2017)
• Neubauer Faculty Fellowship (2015)
• Best Paper Honorable Mention, CHI (2025)