LIVE 2025

The 11th Workshop on Live Programming

Spreadsheets are particularly useful for thinking through financial models, budgets, or any situation that involves considering lots of possible scenarios. Instead of laboriously redoing a bunch of math, you can quickly ask "what if?" questions and see the effects.

But, as good as spreadsheets already are for this task, we think they could be even better. In this essay we explore a small extension to the spreadsheet: what if a single cell could hold multiple values at once?

We present a novel spreadsheet language and interface called Ambsheet, built around that core idea. We also demonstrate how Ambsheet can be useful for exploring real-world scenarios. Finally, we speculate on opportunities to further extend the concept of amb values into a full-featured live programming environment for probabilistic simulation.

Automat is a skeuomorphic desktop automation tool (similar in function to AutoHotKey) with the end-goal of evolving into a fast & intuitive general purpose computing environment. This article aims to give an overview of Automat, focusing on it's distinguishing approach to object-oriented programming.

Recent interactive debugging tools effectively exhibit high‑level insights into program execution, yet most focus on imperative programming languages and neglect an important component of functional programming: pattern matching. We present an interactive debugger built atop an expressive pattern‑matching syntax (the Ultimate Conditional Syntax) and describe three user interfaces for understanding failures and control flow: (1) culprit-pattern highlighting that pinpoints successful and failed subpattern, (2) fallback-flow visualization that reveals how default branches are shared and taken, and (3) automatic recursion tracing that exhibits the high-level control flow of recursive functions.

Explorable explanations are interactive web essays that explain challenging technical ideas. For example, an elegant distill.pub article explains matrix convolution and related ideas like receptive field, important notions in CNNs that also have applications in image processing. Educational efforts like these are valuable but labour-intensive, especially for the kind of interactive graphics we might like to use in order to illustrate how an algorithm like convolution works.

In this talk we present a programming language with built-in dependency tracking, called Fluid, which produces computed content where the relationship to inputs can be interactively explored. To date we have mainly explored the applications of this feature to open science. For this talk we explore the idea that built-in provenance-tracking can also help with science communication, allowing a reader to explore the relationships between the stages of a pipeline, using automatically provided interactions. While our current implementation has some limitations, we hope to motivate the idea that this direction in languages moves real implementations closer to being self-explanatory artifacts, potentially reducing the need for separate, custom-crafted explorables. Enriched with integrated documentation, “explorable implementations” like these could form the basis of a kind of literate execution and provide a way of authoring explorable explanations with less effort.

Live programming research gravitates inward towards the creation of isolated environments whose success is measured by domination: achieving adoption by displacing rather than integrating with existing tools and practices. To counter this tendency, we advocate that live programming research broaden its purview from the creation of new environments to the augmenting of existing ones and, through a selection of prototypes, explore three adversarial strategies for introducing programmatic capabilities into existing environments which are unfriendly or antagonistic to modification. We discuss how these strategies might promote more pluralistic futures and avoid aggregation into siloed platforms.

Programming has an incredibly high cognitive load, and few tools address this cognitive load at the foundations. From programming languages, to data formats, to tools for creativity and creation, cognitive load seems to always bubble up from the core. Few systems are able to balance the concerns of cross-cutting logic, user/authoring experiences, and the gradient of experience that a programmer/user navigates throughout their life. There are few tools that grow with us, and context switching plagues modern software development.

Nova is an attempt to address this in a concise, malleable form. Nova is a programming language, a notation, a model of computation, a way of modeling systems, a way of speaking with machines, and a way of telling stories. As a programming language, it is a rule-based programming language built around a physically intuitive computational model. As a notation, it's a format for notes, sketches, doodles, and other casual documents. Nova's particular blend of features makes it ideal for anyone from total beginner to advanced programmers and users.

Nova's intent is to go from casual, sketch-like documents to working, performant code in as few steps as possible. The intent is to bridge the semantic gap as far as possible with a simple core metaphor so that you can "write what you mean." This presentation will be going over how to read and write some simple Nova snippets, reason about the mechanics of Nova's execution in different forms, and equip you with curiosity to pursue the deeper, more emergent behaviors that Nova's rule-based execution and data model allows.

REPL-driven development is an interactive programming technique indispensible to many Lispers. Despite semantic similarities with Scheme, JavaScript has seen very little adoption of REPL-driven development, and there has been virtually none in industry. This is mysterious, but could in part be due to a lack of adequate tooling.

I present such a tool: Replete, a JavaScript REPL designed primarily for use in commercial software projects where a variety of runtimes and browsers must be catered for. I also discuss some technical challenges to its implementation, its known limitations, some common pitfalls, and what I've leaned from four years of using it in a commercial codebase.

Scrappy is a research prototype that reimagines software creation for non-professional programmers. While modern computing is dominated by mass-market applications and enterprise solutions, there remains a significant gap in tools that empower individuals to create personalized, context-specific software. Scrappy addresses this gap through an infinite canvas environment where users can create "Scrapps" — small, shareable applications built through direct manipulation of interactive objects with lightweight scripting.

Unlike traditional development environments, Scrappy eliminates the distinction between editing and running, enabling real-time collaboration where applications remain live during modification. Drawing inspiration from HyperCard and modern productivity tools like Figma, Scrappy combines familiar canvas-based interactions with reactive formulas and JavaScript-based behaviors, making programming more accessible while maintaining expressive power. Our approach contributes to the growing movement of end-user development, casual programming, and small computing by prioritizing user agency, visible data representation, and frictionless sharing.

Today, building a simple digital tool means wrangling a stack of tools: a framework, a runtime, a database, a deployment pipeline, and brittle integrations between them. We've come to accept this complexity as the price of software. Hyperclay asks: what if we didn't?

If you were to pick up a block of clay and shape it, you'd expect it to stay in its new state. If you cut it in half, you'd expect to see, locally, an internal structure that helps it maintain its form. And you'd expect to be able to give it to someone and allow them to shape it too.

These intuitive and natural aspects of physical objects are things we take for granted with powerful software systems, like Google Docs or a photo editor. We can mold digital objects with them and then share the results.

But when it comes to making a new type of digital object for ourselves — with its own UI, state, and behavior — we end up orchestrating the background processes that maintain the illusion of software being an object rather than building the object itself.

Hyperclay reimagines personal software development as single, self-contained, self-modifying HTML files that can persist themselves. By treating the DOM as simultaneously the source code, runtime, database, and UI, we eliminate multiple levels of complexity from modern software stacks and create a new malleable software primitive you can shape in real time.

As you shape the UI, you shape the application.

Through novel techniques like packaging the editable UI and view-only UI into one, the save-strip-restore cycle, and the DOM-as-state-machine pattern, Hyperclay makes software development as immediate and tactile as working with physical objects.

This paper reflects on our experiences with musical live coding as an entry point to computer science education in both school-based and public contexts. Based on formats such as teaching units, teacher training, and an interactive booth at the "Lange Nacht der Technik" we explore how tools like Strudel can foster accessible engagement with algorithmic thinking. We discuss opportunities and challenges of this approach at the intersection of education, art, and technology.

This presentation introduces Spine, an experimental programming language built on declarative and reactive paradigms. The aim is to prototype a software architecture that enables direct manipulation while remaining live and editable at scale.

Spine uses bidirectional dataflow, where changes to an expression's output can propagate backward to modify the corresponding input variables. This process is governed by a principle of "conservation of information" to maintain logical consistency.

A custom parser enables reverse parsing, which allows changes in the program’s state to dynamically rewrite the source code, closing the loop between the live application and its definition.

While fundamentally declarative, Spine emulates an imperative-style syntax to provide both familiarity and greater expressive power.

Significant challenges still remain in both implementation and methods.

Wobble Web (https://wwwobble.org) is a hybrid graphics editor and coding environment for making and sharing small-scale websites. Dragging, pinching, and zooming something on the screen immediately changes the code, and editing the code immediately mutates what is on the page. Wobble Web includes a built-in code editor, but also works nicely with existing browser developer tools, allowing code entered via developer tools to persist into the final web page, and extending the capabilities of the browser itself as a live programming environment.

The project is built upon a set of open-source web components that can be used with the editor as well as independently. The emphasis on html as a base language allows us (as well as users) to easily integrate more advanced custom elements, such as using libraries like htmx or AlpineJS for expressing more complex logic and state-manipulation in html attributes, or using WebGL, Web Audio, or other web APIs. We additionally plan to create a set of custom html elements that can operate on each other within a draggable canvas, such as an element that can clone, delete, or modify another element that it comes in screen-space contact with.

The project differs from existing bidirectional editors in its focus on multitouch gestures and mobile-first editing, its integration with the existing browser ecosystem, and its emphasis on an extensible and modular ecosystem of custom elements.