Schedule

Opening

Claude Code does not program

In this talk, I will show the results of using Claude to develop different projects through a Cuis MCP, varying the configured tools (with or without refactoring, with or without LiveTyping, etc.), the skills used, and the development technique employed. We will analyze token consumption and design quality among other variables.

Smalltalk AI Agents, inside and outside

Since the end of last year, pressure to introduce AI agents everywhere has grown to the point where it is doubtful that we could continue working with Smalltalk if agents cannot operate on the code. This talk reflects on our journey to achieve that and how we are trying to work alongside the robots in our workspace, but also "enjoy" remote interventions via MCP.

What We Talk About When We Talk About Software

Technical and business landscapes have shaped the practice of Software Development ever since computers became a thing. Today, Software Development is at its biggest crossroads ever. Recent developments in AI are having such an big impact that a broad review of our objectives and practices is in order. Let's rethink why and how we build Software so we can align our practice with our goals.

The VAST AI Assistant

Smalltalk environments have long been pioneers in developer productivity. With the VAST Platform AI Assistant, we extend that tradition by integrating Large Language Models (LLMs) directly into the VAST Smalltalk environment. This tool brings advanced AI capabilities seamlessly into the developer’s daily workflow.

In this demonstration, we showcase how the assistant—powered by both frontier cloud models and local models—can investigate source code, debug errors, merge AI-generated application code, and leverage Model Context Protocol (MCP) servers to extend its reach beyond the local VAST Smalltalk image.

By leveraging the live, reflective nature of Smalltalk, the VAST AI Assistant acts as a true pair programmer. Rather than functioning as a standalone chat interface, it actively interacts with the live VAST environment.

Join us to explore how we are shaping the future of AI-assisted development in VAST. Experience the tool in action, try it out, and join the conversation on GitHub: https://github.com/instantiations/VAST-Platform-AI-Assistant.

Building a simple MCP server in Smalltalk

The Model Context Protocol (MCP) has quickly become the usual way to give an LLM access to a system: a server exposes a set of tools, and the model decides when to call them. Now that everyone is implementing them, a natural question is what implementing one in Smalltalk is like, and whether a live, introspectable system has something particular to offer here.

In this talk, I'll build a minimal MCP server live (using Cuis-Smalltalk), showing one possible starting path, along with the decisions and surprises found along the way.

Documentation That Outlived Its Medium, A look inside how VAST documentation gets made

VAST Platform documentation has been continuously accessible across every release for over two decades. This talk offers an inside look at our recent migration of the entire corpus (every guide, reference, and code sample) away from the legacy print and PDF publishing toolchain and into plain text that we publish as a modern, searchable site. 

That architecture is what makes continuous improvement possible from here on. The documentation is now read not only by people, but by machines, including search engines and AI models such as our own VAST AI Assistant. That closes a useful loop: every question the assistant cannot answer well points straight at the page that needs work.

GemStone: Introducción y desarrollo hands-on (Spanish)

Workshop introductorio al desarrollo con GemStone. Es conveniente traer notebooks.

Is it true, or True? An exploration of singular objects

In Smalltalk, every object is an instance of a class. From a modelling perspective, classes are used to represent concepts. From an implementation perspective, they are used to provide their instances with behavior (among other things).

But sometimes there is no clear distinction between a concept and an object falling under it. The object `true` is one of those cases: the class True has a single instance, and there is nothing to say about "what is true" that is not already said by `true` itself.

There have been many attempts, in Smalltalk and in other languages, to let these singular objects exist on their own. In this talk, we're going to briefly explore the idea from a theoretical point of view, and then see one possible way of implementing it in Cuis-Smalltalk.

Advances in Smalltalk Portability: OpenSmalltalk on Android and JavaScript

We will present an Android port of OpenSmalltalk, enabling Cuis and Squeak to run on Android devices. The project was motivated by a workshop associated with the previous Smalltalks 2025 conference, and we will discuss the motivations, design decisions, and current state of the implementation. We will also present the proposed solution and discuss future work aimed at improving its usability, performance, and portability.

Building Agentic Applications with VAST: VAST ADK and A2UI

How can Smalltalk applications participate in the emerging world of AI agents without abandoning the systems, business logic, and development practices that make them valuable?

This session introduces the technologies Instantiations is developing to make agentic AI a native capability of the VAST Platform. We will demonstrate VAST ADK, a Smalltalk implementation of the programming model introduced by Google’s Agent Development Kit. Attendees will see how VAST applications can create agents that use tools, maintain sessions and memory, manage artifacts, stream results, work with different AI model providers, and coordinate more complex workflows.

We will also explore VAST A2UI, which enables agents to produce structured, interactive user experiences rather than being limited to conversational text. The session will include a look at our evolving tools and experiments for designing, testing, and working with these agent-driven interfaces. We will also discuss how technologies such as MCP and A2A can connect agents with tools, services, other agents, and existing enterprise applications.

While the separate VAST AI Assistant session focuses on using AI to help developers work within the VAST development environment, this session focuses on what VAST developers can build: AI-enabled applications and agentic systems implemented in Smalltalk.

Pulsar: Reinventing the Wheel (Because the road has changed)

Programming environments shape the way programmers think, explore, and act. Smalltalk has always carried a radical idea: the IDE is not merely where code is written, but a living interface to the system itself. Pulsar begins with that tradition and asks what it must become under the conditions in which we program today.

Pulsar is an experimental IDE for Pharo, built with Spec. It aims to give programmers more leverage in their everyday work through faster navigation, richer feedback, deeper inspection, persistent lines of investigation, and a more fluid relationship with the running image. It is not simply a new browser, but an attempt to rethink the IDE as a coherent workbench for understanding, modifying, and evolving software.

This work is also a bet on Pharo’s future. The image no longer exists in isolation: contemporary development must contend with large and long-lived systems, fragmented toolchains, the growing importance of native operating-system integration, external services, asynchronous workflows, and the rapid arrival of LLMs and software agents. These changes should not lead Pharo to abandon the live and reflective model that makes it distinctive. They challenge us to extend that model—to make new forms of assistance inspectable, composable, and subordinate to the programmer’s understanding and intent.

This keynote presents Pulsar as both a work in progress and a platform for that exploration. It is an invitation to consider what a modern Smalltalk environment can become: close to the running system, at home in the wider computing environment, and capable of increasing the programmer’s power without placing the machinery of programming beyond their reach.

ProtoST, an new actor-based Smalltalk-80 implementation

An actor-native Smalltalk for building digital twins on protoCore.

protoST is a Smalltalk-80-inspired language runtime with a first-class embedded actor model, built on the protoCore kernel. It is the third member of the protoCore language triple — alongside protoJS (JavaScript) and protoPython (Python) — and it closes the technical demonstration that one prototype-based kernel can host three genuinely different OO paradigms (prototypes / classes / messages) without flattening them to a common denominator.

protoST's distinct contribution is putting actors at the centre of the language: any object can be promoted to an actor with asActor, every message sent to it is dispatched asynchronously and returns a Future, and an internal invariant guarantees that exactly one method of a given actor runs at a time. Tens of thousands of actors share a small worker pool through cooperative scheduling — an actor suspends transparently when it waits on a future, freeing its worker for someone else.

It’s About Time: Chronology in Chalten

Handling dates, times, and durations seems straightforward—until production code encounters time zone shifts, or arithmetic across varying calendar scales. Most programming environments treat temporal data as naive wrappers over epoch milliseconds, entrenching fundamental misconceptions about how time scales actually function in domain modeling.

This talk explores the latest updates in Chalten, the Buenos Aires Smalltalk library designed for precise, object-oriented chronological modeling. We will examine common developer pitfalls—such as treating time zones as simple fixed offsets, conflating points in time with durations, or assuming calendar units scale uniformly.

Applied Research in Cuis Smalltalk

Over the past 8 years, Cuis has benefited from the applied research carried out as part of master theses in the Computer Science program at the University of Buenos Aires (UBA), and this year is no exception. We will present the work currently under development, along with what has already been completed and integrated over the last year. These goes from new refactorings and improvements to existing ones, to comprehensive code undo/redo and automated UI testing.

Debate panel: AI and Smalltalk (Spanish)

Panel de debate sobre el impacto de la IA en nuestra profesión

GemTalk Update and Roadmap

A brief overview of the GemStone architecture for scalable, multi-user Smalltalk followed by the GemStone/64 product roadmap. Also an update on the recent acquisition of GemTalk by Emergence.

A Pharo vision

Pharo has always been shaped by a human-oriented view of programming: a live, reflective environment designed to help developers understand, explore, and change software.

This talk reflects on Pharo’s achievements (already 14 versions!), but also on the challenges it faces as software development evolves around new tools, workflows, and forms of automation. The advent of Large Language Models are part of this shift, but is only one aspect of a broader transformation.

Rather than asking how Pharo can automate more of the programmer’s work, this talk explores a different direction: how Pharo can continue to augment human capabilities and remain a powerful, open, and adaptable development environment for the future.

Powerful Ideas Behind Cuis Smalltalk

Smalltalk was born to provide computer support for the creative spirit. Forty five years have elapsed since Dan Ingalls said this and inspired countless projects including Smalltalk-80 and Squeak. Cuis Smalltalk is an ongoing project attempting to capture this ethos by the application of several "Powerful Ideas". To the original ones from Smalltalk-80, we added several others, like building the UI as a nested tree of local spaces, Signal Processing theory for Anti Aliasing, and efficient data structures for Unicode text manipulation and display.

The Road to VAST 2027: An Instantiations Update

VAST is entering its next stage of evolution. In this annual company update, Seth Berman and Mariano Martinez Peck will review the progress made since the last Smalltalks conference and share the direction taking shape for VAST Platform 2027.

We will discuss how Instantiations is strengthening the core platform while using its emerging AI tooling to accelerate engineering, investigate difficult issues, support customers, and improve VAST itself. Customers are also working more closely with us to shape important capabilities and strengthen the long-term stability and stewardship of the platform.

We will also explore the connection between VAST and Instantiations’ Fintech business, where our teams support critical banking systems built across VAST, Java, COBOL, and other technologies. This experience is helping us define a broader role for VAST in understanding, connecting, and responsibly evolving the long-lived systems used by major financial institutions.

Finally, we will place our emerging AI technologies within the broader VAST strategy. Separate conference sessions will provide deeper technical presentations and demonstrations of this work.

Attendees will leave with a clear view of where VAST is headed, how its evolution is accelerating, and the role it can play in the mission-critical systems enterprises will depend on for decades to come.

 Autodesarrollo en ambientes informáticos contemporáneos

La charla explora la posibilidad de construir ambientes informáticos abiertos, capaces de participar de su propio desarrollo y de sostener una relación continua entre las personas y los sistemas en ejecución.

A partir de más de tres décadas de trabajo con Smalltalk y de los modelos desarrollados durante la última década con S8, se presentan algunas ideas y experiencias relacionadas con reflexión, modificación y composición de sistemas que operan sobre dispositivos, servicios y diferentes entornos informáticos.

El objetivo es explorar qué condiciones permiten llevar las posibilidades de los ambientes de objetos hacia los soportes informáticos actuales, y qué nuevos espacios de autodesarrollo pueden surgir cuando las herramientas amplían nuestras capacidades de entendimiento y modelado del comportamiento, tanto vivo como informático.

 Debugging Smalltalk without Smalltalk. smalldbg: reconstructing objects, classes and stacks from outside the VM

The Smalltalk debugger we are used to is a guest of the image: it runs inside the thing it inspects and asks objects to describe themselves. When the VM crashes, that arrangement is gone and you are back in a core dump staring at hex numbers.

smalldbg takes the other side: a small C++ library that never executes a line of code in the target provides a portable native debugger API. Through vmdbg, another small C++ library on top of smalldbg, each dialect contributes only a description of its object model — how to decode a header, find a class, walk a green-thread stack — and from raw memory the library rebuilds what the image would have told you, including a single backtrace interleaving C++ and Smalltalk frames. A Webside server publishes it, so a familiar IDE drives a dead process, a dump, or a recording you can step backwards through.

Seamless Parallelism: Multi-Threaded GC in the VAST Platform

Modern processors offer an increasing number of cores, but leveraging this hardware in a mature Virtual Machine without breaking compatibility is a non-trivial task. In this talk, we will show how we modernized the VAST Platform Garbage Collector by extending the VM’s original memory layout to add multi-threading, requiring zero changes to existing applications.

We will walk through our analysis of the scavenge and global GC phases to identify the bottlenecks with the highest potential for optimization. We will dive into the architecture of the generic workers we added and how we parallelized object relocation during the compact phase. Finally, we will analyze the evolution of our bitmap-marking algorithm, from its division into segments and chunks to the performance showdown between two work distribution strategies: a shared global queue and work-stealing. We will showcase performance metrics, lessons learned, and the performance results we achieved.

From Sockets to TLS in Cuis: A Cross-Platform FFI implementation

Two related networking packages were implemented for Cuis: FFISocket, a blocking socket implementation based on FFI, and an OpenSSL package built on top of it. Both run on macOS, Linux and Windows.

The design of FFISocket will be presented, together with how the same Smalltalk interface is implemented over BSD sockets on macOS and Linux and Winsock on Windows, focusing on the places where apparently similar native APIs actually require different implementations.

The talk will then show how OpenSSL is built on top of FFISocket. Although OpenSSL provides a largely common API, its integration is not the same in the three platforms, with some differences in the FFI implementations for the .dylib, .so and .dll libraries, and in certificate verification, which must work with the native trust infrastructure of macOS, Linux and Windows.

Using these two implementations as concrete examples, the talk will discuss which parts of the design could remain common across the three platforms and where platform-specific code was necessary.

PharoSDL3: New FFI Bindings for SDL3 in Pharo

SDL (Simple DirectMedia Layer) is a cross-platform library widely used in game development and multimedia applications. SDL 3.0 is a major new release that brings, among other things, a GPU API for high-performance rendering.

We present PharoSDL3, the first Pharo bindings for SDL 3.4.0. Beyond wrapping the SDL 3 API with Pharo's FFI, the library provides an OSWindow backend that integrates with both Morphic and Bloc, maintaining backwards compatibility with SDL 2. It also exposes the new SDL GPU API, opening the door to hardware-accelerated rendering from Pharo.

This work is a sign of a living and active community: Pharo keeps up with the latest developments in the ecosystem. We will demo the library, explain key design, and discuss the integration with the rest of the Pharo graphical stack.