Schedule

Opening

Fighting the Branch Predictor

Inline caches speed up message sends by storing recent types and methods per call site.

Traditionally such caches are implemented using code patching: message sends use a fixed sequence of machine instructions that is later rewritten.

This design requires that machine code is not only executable but also writable, making patching expensive, preventing the sharing of machine code and being vulnerable to attacks.

This talks explores a different design of inline caches avoiding code patching, and the fight to obtain decent performance against our arch enemy: the branch predictor.

Smalltalk as a Teaching Tool in Computer Science and Engineering: The UBA Experience

Five years ago, the School of Engineering at the University of Buenos Aires (UBA) decided to change the way object-oriented programming was taught. The person responsible for leading this initiative was Luciano Leveroni, MSc in Computer Science who at that moment was Head of Teaching Assistants at the Software Engineering course at the School of Exact and Natural Sciences (UBA). What followed was unprecedented within UBA: the curriculum of this course was shared between the two schools, enabling a level of collaboration among teaching staff that had never been seen before.

In this talk, we will discuss the benefits of this collaboration, what we have accomplished through it, and the opportunities ahead. We will also explain why we continue to choose Smalltalk as our teaching environment, highlighting both its strengths and weaknesses with an eye toward the future.

Amazing Bugs and Where to Find Them

Language Virtual Machines (VMs) are complex software systems that implement interpreters, just-in-time (JIT) compilers, and memory managers. Ensuring their correctness is particularly challenging due to low-level implementation details, cross-architecture deployment, and the difficulty of reproducing subtle bugs such as memory corruption.

Lots of bugs are found in widespread language implementation every year by researchers, and they are typically difficult to reproduce, minimize and debug.

Besides these challenges, simple software engineering techniques remain very powerful.

In this talk we explore how we can tackle complex testing problems in the Pharo Virtual Machine with simple ideas: testing, fuzzing and simulation.

Who knows, maybe we find a bug

Heed the call of Sairen: LLMs inside your image

This talk will present Sairen, an open source framework that integrates several modern LLMs into the Smalltalk development environment.

An extensible design allows adding your AI platform of choice, to be used in connection with several tools and features already included in the framework.

Examples will be shown on how to integrate LLMs as part of a web application that includes image and text generation.

Tools inside Pharo and VAST will be presented, that offer insight about customizing the environment and analyzing code.

Enhancing Security in VAST: Static Vulnerability Scanning for Smalltalk

Security tooling in the Smalltalk ecosystem remains limited compared to mainstream languages. To address this gap on the VAST Platform, Instantiations initiated an R&D project to explore how static analysis can help identify vulnerabilities in Smalltalk applications. We have now completed the project’s first stage: defining the scope of a vulnerability scanner and delivering an initial working version, which we’re planning to ship in Q4 of this year.

This talk shares our hands-on experience building the scanner, from architectural decisions to practical implementation challenges. We will showcase the features developed so far: seamless IDE integration, support for whitelisting, multiple output and reporting formats, and configurable levels of code redaction within reports. We’ll also discuss trade-offs, false positives, and the inherent limitations of static analysis in a highly reflective language like Smalltalk, offering insights for anyone interested in bringing effective security analysis to dynamic language environments.

Teaching Kids to Hack Their Own Games: Metaprogramming, Debugging, and Creativity from Age 7

What if children could learn programming by bending the rules of their own games?

Diálogo is an innovative visual programming environment designed for kids aged 7 and up, where they draw their own characters, create interactive worlds, and program behaviors using an intuitive, symbol-based language.

In this talk, we’ll explore a unique didactic sequence that introduces concepts usually reserved for advanced programmers — metaprogramming, dynamic rule modification, and debugging strategies — all through the lens of game creation.

Children start by drawing, then attach meaning to their creations using visual code blocks. As they play and test their games, they debug, experiment, and even change the rules while the game is running, discovering that code is not fixed but something they can transform.

We’ll share insights from our workshops, where kids as young as seven have designed games involving physics, AI behaviors, and emergent mechanics — without writing a single line of traditional code.

Whether you’re an educator, a developer, or simply curious about the future of creative coding, this session will showcase how Diálogo empowers kids to think critically, code visually, and hack their own worlds.

Open Source .NET interop with Smalltalk

In this talk we will present an open source implementation of a Smalltalk/.NET interoperation framework. The system is designed in a way that allows being adopted by different dialects, in particular Cuis and Egg Smalltalk, and could even be reused in other languages through a thin plain C layer.

The opensmalltalk-vm threaded FFI

15 years after the prototype was shown unofficially at FAST 2010 opensmalltalk-vm's threaded FFI is in production, thanks to support from Potsdam and LabWare. Another talk by Felipe Zak will present its use in an ODBC connect and a new Socket library. This talk presents the architecture, which is based on that developed by David Simmons for SmalltalkAgents, and the range of facilities the system provides. The core of the system is a very lightweight lock-free mechanism that allows any and all FFI calls to be threaded. This is far superior to lock-based mechanisms as found in the Pharo and Python VMs. When the VM finds it is blocked in an FFI call the VM starts another thread to run Smalltalk. The basic idea is that while any thread can run Smalltalk, only one thread can do so at any time, thread switches occurring at FFI callouts, callbacks, and process switches. Callbacks can be taken both from a thread that has called out, and from foreign threads. The architecture allows plugin primitive to thread also. The fact that the VM can run Smalltalk concurrently with multiple callouts and plugin primitives requires care but greatly extends the ability of Cuis and Squeak to exploit multiple cores, and to implement applications that no longer pause when interacting with the outside world.

Reaching the Summit: Introducing Aconcagua v11

Aconcagua is a library designed to model quantities as first-class objects, enabling more expressive and type-safe domain modeling. In this talk, we'll introduce version 11, a major upgrade that brings significant changes to the library. We'll walk through the key motivations behind this release, highlight the most impactful changes, and explore how they improve both usability and maintenance.

Redis for VAST: Building Responsive Smalltalk Applications

This high-performance Redis client for the VAST Platform supports synchronous and asynchronous modes with true non-blocking operation enabled by VAST’s native threading. It offers a clean Smalltalk API structured around Redis data types and includes full support for pipelining, transactions, Pub/Sub, connection pooling, SSL/TLS, and both RESP2 and RESP3 protocols. Comprehensive runnable examples and an extensive test suite demonstrate usage and ensure reliability, making it easy for developers to build responsive, high-throughput applications. This session will walk through its design and internals, share performance results, and demonstrate how to integrate it into your own Smalltalk projects.

A tour to the Morphic UI in Cuis

UIs for Web applications are usually made of UI controls from a standardized, pre-made set. The design of a User Interface involves composing them to show the state of the application, and to allow the user to modify it. The same happens with Desktop and Mobile apps. Morphic is a User Interface framework that encourages the construction of domain specific visual metaphors and interactive graphical objects. Originally created for Self in 1993, it was reimplemented for Squeak in 1997. It was later redesigned for Cuis where it is called Morphic 3. This new design enabled the incremental inclusion of higher quality Vector Graphics and other advanced features while at the same time greatly simplifying the development of application code. Morphic and the ideas it is based on are still exotic to mainstream Software Development practice. In this talk I’ll explain them and demo them in the working system.

Introducing Behavioral Programming with Smalltalk

What if your program’s behavior scenarios—requirements or use cases— and your code could be one and the same? Behavioral Programming (BP), introduced by David Harel, makes this possible.

In this talk, we’ll introduce the BP approach and explore it through practical examples implemented in Smalltalk.

Seamless OAuth2.0 and OpenID Connect Integration in VAST

OAuth2.0 and OpenID Connect (OIDC) are essential protocols for secure user authorization and authentication in modern applications. This session will provide an overview of these frameworks and showcase VAST’s upcoming OAuth2.0 & OIDC client, which enables developers to effortlessly integrate single sign-on (SSO) with providers like Google and Microsoft. Learn how to streamline workflows and securely access OAuth2.0-protected APIs across web, desktop, and server applications in VAST.

Microservices: The Good, the Bad, and the Ugly

Companies like Netflix, Amazon, and Google pioneered microservices architecture (starting around 2010), demonstrating its scalability and resilience. Their success stories encouraged widespread adoption across various industries. Is this just another passing fad or should you rewrite your "monolithic" system to keep up?

Refactoring Enhancements for Cuis Smalltalk

In the last year Cuis has grown in the number of automatic refactorings. In this talk we will present the support for repeated code in the extract variable refactoring and how the support of parameterized repeated code in the extract method refactoring among minor changes in other refactorings.

Cuando lo clásico se vuelve disruptivo: la historia de Smalltalk dentro de Telecom (in Spanish)

En telecomunicaciones, el cambio es la única constante: pasamos de las redes 2G y los SMS al 5G avanzado. 

En este recorrido, las operadoras se enfrentan a un gran desafío: cómo inventariar y modelar redes cada vez más complejas y en permanente evolución.

En esta charla contaremos cómo desde Telecom Argentina encaramos ese reto con Smalltalk y GemStone.

La experiencia mostrará que, incluso frente a un ecosistema en constante transformación, es posible construir soluciones robustas y escalables si se apuesta por herramientas que rompen con lo tradicional.

A BrAIn inside VAST

MCP server running inside VAST

The MCP and the business application share the same VM image.

By being embedded in the VAST image, the MCP can:

Access Smalltalk objects directly (for logging, configuration, or live debugging).

Run background daemons or agents for monitoring, queue management, or event dispatching.

It effectively becomes part of the application image — not just a service called from the outside.

GemTalk Update and Roadmap

A brief overview of the GemStone architecture for scalable, multi-user Smalltalk followed by the GemStone/64 product roadmap.

Instantiations Company Update & VAST 2026 Overview

Instantiations continues to invest in the VAST Platform, open source software, and the Smalltalk community. This session will provide a technical update on our recent progress, outline upcoming features planned for VAST Platform 2026, and showcase new products—including our compliance package and security scanner that help teams ensure secure, standards-aligned development.

Smalltalk for Urban Mobility: Building a Unified and Scalable Payment Platform

This talk presents the design and implementation of Argentina's first comprehensive urban mobility payment platform developed in Smalltalk. The solution is engineered to process a high volume of real-time transactions from multiple payment sources, including QR codes from digital wallets and contactless EMV credit/debit cards.

We will explore a transaction's full journey, from a user's 'tap' at the validator to the final settlement. We will detail our event-driven architecture, which leverages a message broker (RabbitMQ) to decouple critical processes like fare calculation and payment authorization, ensuring a seamless user experience and the integrity of every operation.

This presentation will provide a high-level overview of our architecture, serving as a case study for applying Smalltalk to modern infrastructure, positioning it as a strategic, high-performance choice for solving mission-critical challenges.

Smalltalk in Action: Real Solutions using the ba-st Repositories

The ba-st community maintains a collection of open-source libraries and tools that address common challenges in Smalltalk software development. In this talk, we will present real-world cases where these libraries simplify tasks, accelerate development, and allow developers to focus on business logic.

Leveraging OpenSmalltalk-VM’s Threaded FFI: Case Studies with ODBC and a New Socket Library

This talk explores the use of the threaded Foreign Function Interface (FFI) recently integrated into the OpenSmalltalk Virtual Machine. The threaded FFI ensures that external function calls do not block the VM’s main execution flow, allowing Smalltalk to remain responsive while interacting with native libraries. We present two examples: one with ODBC and another with a new socket library. These cases demonstrate how threaded FFI extends the capabilities of Smalltalk into domains where concurrency and performance are critical.

 Compile-time PIC Generation using LiveTyping information

Polymorphic Inline Caches (PICs) are a key optimization technique in modern virtual machines, enabling efficient method dispatch in dynamically typed languages. Traditionally, PICs are generated and extended lazily at runtime, as the system encounters polymorphic call sites. In this work, we explore an alternative approach: generating PICs proactively at compile time by leveraging runtime type feedback collected by LiveTyping during program execution. Our approach extracts type information generated by LiveTyping, analyzes the classes and target methods associated with polymorphic sends, and uses this data to build closed PICs ahead of time. By shifting part of the PIC construction process into compilation, we aim to reduce cache misses, message lookup overhead in highly polymorphic code and PIC generation at execution time.

 GUIDesigner - A Cuis tool to visually design morphs

At 10Pines we have been implementing a tool to design morphs visually, like many other programming languages and IDEs currently support. We named it GUIDesigner and we will show its main functionality, how it supports different widget libraries, design decisions we overcome and testing tools we developed to help its programming.

The Druid Metacompiler

Virtual Machines (VMs) combine interpreters and just-in-time (JIT) compiled code to achieve good performance. However, implementing different execution engines increases the cost of developing and maintaining such solutions. JIT compilers based on meta-compilation cope with these issues by automatically generating optimizing JIT compilers. This leaves open the question of how meta-compilation applies to baseline JIT compilers, which improve warmup times by trading off optimizations.

In this talk we present Druid, an ahead-of-time automatic approach to generate baseline JIT compiler frontends from interpreters. Language developers guide meta-compilation by annotating interpreter code and using Druid’s intrinsics. Druid targets the meta-compilation to an existing JIT compiler infrastructure to achieve good warm-up performance.

We applied Druid in the context of the Pharo programming language and evaluated it by comparing an autogenerated JIT compiler frontend against the one in production for more than 10 years. Our generated JIT compiler frontend is 2x faster on average than the interpreter and achieves on average 0.7x the performance of the handwritten JIT compiler. Our experiment only required changes in 60 call sites in the interpreter, showing that our solution makes language VMs easier to maintain and evolve in the long run. 

Hands-on Behavioral Programming with GToolkit

In this practical workshop, participants will explore Behavioral Programming (BP) through a guided example built in GToolkit. Step by step, you’ll extend and evolve a simple system across several iterations—learning how the gt4bp library works and how BP enables a new way of thinking about software behavior and modularity.

Participants will need a notebook with GToolkit installed.