Skip to content
Published on

Modern Smalltalk in 2026 — A Deep Dive into Pharo 12, Squeak, Cuis Smalltalk, Glamorous Toolkit, Amber, VAST, GemStone/S, and Seaside

🇰🇷KO🇺🇸EN🇯🇵JA
Split View필사 모드
Authors

Prologue — Why Smalltalk Still Matters in 2026

The "Smalltalk is dead" joke has been told in the same form for 25 years. And it has been wrong for 25 years. In spring 2026, Pharo 13 shipped on time, Glamorous Toolkit 1.x is driving a new paradigm called moldable development, and GemStone/S 64 Bit 3.7 still moves the massive transactional engine behind JPMorgan Chase. Seaside 3.5 is a living, cited example of continuation-based web frameworks in academic literature, and Squeak 6.0 is quietly back in classrooms.

Smalltalk is not a language that explodes in new-user counts. But people who fall in once rarely leave. Why? Because the image-based paradigm — saving a memory snapshot of live objects instead of text files, and writing, debugging, and recompiling code inside that snapshot — once experienced, makes you unable to stop asking "why is everyone else editing text files?"

Smalltalk is not a language; it is a system. Text files are a byproduct of the system. The actual artifact is a living object graph. Once you internalize that, the question shifts from "why are people still using Smalltalk?" to "why isn't everyone using this?"

This deep dive covers:

  1. Alan Kay and Adele Goldberg — Xerox PARC and Smalltalk-72/76/80
  2. The image-based paradigm — what makes Smalltalk unlike every other language
  3. Pharo 12 / 13 — the flagship of modern Smalltalk
  4. Squeak 6.x — the direct descendant of Smalltalk-80
  5. Cuis Smalltalk — the minimalist's choice
  6. Glamorous Toolkit (GT) — the moldable development environment
  7. Amber Smalltalk — Smalltalk in the browser
  8. Dolphin, VisualWorks, VAST — the commercial camp
  9. GemStone/S — distributed OO database with Smalltalk inside
  10. Seaside — the continuation-based web framework
  11. Iliad, AIDA/Web, Pier CMS — the other web frameworks
  12. Roassal3, Bloc, DataFrame — modern Pharo libraries
  13. Iceberg, Metacello, STON — packages, Git, serialization
  14. Industry adoption — finance, logistics, education, research
  15. Korean and Japanese Smalltalk scenes
  16. Self and Newspeak — Smalltalk's successors
  17. Influence on Objective-C, Ruby, Python, JavaScript
  18. Learning resources and communities
  19. Starting fresh with Smalltalk in 2026
  20. Wrap-up — what Smalltalk teaches you
  21. References

1. Alan Kay and Adele Goldberg — Everything Began in 1972 at Xerox PARC

Smalltalk's history starts in 1972 at Xerox PARC (Palo Alto Research Center). Alan Kay had a vision called the Dynabook — every person, from a child to an adult, should be able to program their own computer. The language that would realize that vision was Smalltalk.

Smalltalk-72 was the first language to elevate message-passing to a first-class concept. Everything is an object, and objects communicate by sending each other messages. When Adele Goldberg joined the team, the language grew more sophisticated, and Smalltalk-76 established the structure of a class hierarchy with metaclasses.

Smalltalk-80 — this is what almost everyone means by "Smalltalk" today. Released to the public in 1980, this version appeared on the cover of Byte Magazine's August 1981 issue and was the decisive moment when object-oriented programming was formally introduced to the world. "Smalltalk-80: The Language and Its Implementation" (1983) by Adele Goldberg and David Robson — the famous Blue Book — remains a classic of object-oriented design.

Alan Kay later famously said, "I made up the term 'object-oriented', and I can tell you I did not have C++ in mind." The OOP defined by C++ and the OOP defined by Smalltalk are essentially different. Smalltalk's OOP is centered on message-passing, not on bundling methods with data.

2. The Image-Based Paradigm — What Makes Smalltalk Unlike Every Other Language

Most programming languages are source-file based. You open .py, .js, or .java files in a text editor, save them, and hand them to a compiler or interpreter. Smalltalk is image-based.

What is a Smalltalk image? In one phrase, a snapshot of live object memory. Classes, methods, instances, debugger state, open windows, even suspended in-flight processes — the entire VM heap is saved to disk in one shot. The next time you open the image, everything resumes exactly where it left off.

Differences from the source-file paradigm

AspectSource filesSmalltalk image
Storage unitText filesVM heap snapshot
BuildCompile and bundleAlways live
DebuggingRerun to reproduceFix in place and continue
Dependenciesnpm / pip / mavenObject graph inside the image
CollaborationGit text diffMonticello / Iceberg serializes object to text

The consequences of this paradigm are strong. Exception in the debugger? Smalltalk lets you fix the method inside the debugger, leave the stack right there, and resume execution from that point. There is no fix-and-restart cycle. That is live coding.

There are downsides, of course. How do you collaborate on an object graph as text? The Smalltalk community has built Monticello, Metacello, and Iceberg to solve that. We cover those in chapter 13.

3. Pharo 12 / 13 — The Flagship of Modern Smalltalk

The most common answer to "where do I start with Smalltalk?" today is Pharo. Pharo is an MIT-licensed, actively developed modern Smalltalk forked from Squeak in 2008. The RMoD team at INRIA, together with contributors around the world, ships one major release per year.

Pharo 12 (April 2024) brought:

  • Major Spec UI framework improvements
  • Bloc graphics framework alpha/beta integration
  • Stabilized threaded FFI
  • Improved Iceberg Git integration
  • Roassal3 visualization

Pharo 13 (April 2025) brought:

  • Bloc graphics promoted to first-class (the successor to Morphic)
  • Dynamic instrumentation via Metalinks
  • Faster OpenSmalltalk-VM
  • Deeper Glamorous Toolkit integration
  • Iceberg 2.x

When Pharo forked from Squeak, it made a deliberate choice — partially abandon Smalltalk-80 backward compatibility in exchange for modernization. The result is a codebase cleaner and more internally consistent than any other Smalltalk. The trade-off is that Squeak's legacy code (Etoys and so on) cannot be moved over directly.

For learning, "Pharo by Example" (Stéphane Ducasse and others, free PDF at books.pharo.org) and "Deep into Pharo" (Andrew Black and others) are the classics.

4. Squeak 6.x — The Direct Descendant of Smalltalk-80

If Pharo chose modernization, Squeak chose to preserve compatibility with Smalltalk-80. Started in 1996 by Alan Kay, Dan Ingalls, and Ted Kaehler at Apple, Squeak is a direct descendant of the original Smalltalk-80 image, released as open source.

Squeak 6.0 (2022) made 64-bit the default, and Squeak 6.1 (2024) brought Cairo-based rendering and a faster Cog VM. Squeak's appeal goes beyond the language — inside the image you find Etoys (the environment Alan Kay built for children to learn programming) and Croquet (later forked into Open Cobalt), historical projects you can still run and modify directly.

Squeak still has a foothold in education. Japan's "Squeak EToys" was once one of the default environments on the OLPC (One Laptop Per Child) project, and some Korean universities have used Squeak in introductory OO courses.

The Squeak license is a mix of Apache 2.0 and MIT, freely usable for commercial projects.

5. Cuis Smalltalk — The Minimalist's Choice

Cuis Smalltalk is a minimalist fork of Squeak by Juan Vuletich. "Cuis" is Spanish for guinea pig — small, fast, and clean.

Cuis's philosophy is clear: drop everything in Squeak you do not need. Etoys, the heavy parts of Morphic, ancient compatibility layers — all gone. The result is a minimal core of about 600 classes, down from Squeak's five thousand. The image is a few megabytes, small enough that the selling point is "you can read all the code and understand it."

Cuis 6.x (2024-2025) emphasizes:

  • VectorGraphics-based clean rendering
  • A codebase one person can read entirely
  • Unicode support
  • Open VM compatibility

Cuis is widely considered the implementation that best shows how Smalltalk was "originally" intended. A huge advantage for learners, possibly a downside for people who want library breadth.

cuis.st — official site.

6. Glamorous Toolkit — The Moldable Development Environment

Glamorous Toolkit (GT) is a new kind of development environment that feenk built on top of Pharo. Not just an IDE — GT introduces a new paradigm called moldable development. What does moldable mean? The tooling itself reshapes to fit the data and the domain you are working with.

For example, to inspect a SQL query result, a typical IDE shows you text output or a generic table widget. In GT you can build a specialized view for that result in five minutes. That view knows the most about that specific domain.

GT 1.x is composed of:

  • GT Inspector — object inspector that lets you attach domain-specific views to objects
  • GT Playground — a Smalltalk execution environment somewhere between a notebook and a REPL
  • GT Documenter — live, executable documentation
  • Lepiter — pages that combine notes, code, and execution results
  • Bloc — GT's graphics foundation
  • Brick — UI widgets on top of Bloc

feenk, founded in 2018 by Tudor Girba and colleagues, releases all GT code under the MIT license. Download at gtoolkit.com and you get an image with Pharo and GT bundled together.

GT's ambition is not small — they argue that "developers should build tools to understand their systems": every time you analyze a new codebase, you write and throw away custom tools for that codebase. Whether this claim is real or marketing is something you can only decide by trying it yourself.

7. Amber Smalltalk — Smalltalk Running in the Browser

Amber Smalltalk is an implementation that compiles Smalltalk-80 code to JavaScript and runs in the browser. Started in the early 2010s by Nicolas Petton and others, Amber lets you use a Smalltalk IDE in the browser and produce JavaScript apps as the output.

Amber's appeal:

  • Just open a browser and write Smalltalk
  • Call JavaScript libraries (jQuery, D3 and so on) directly from Smalltalk
  • Smalltalk classes map cleanly to JavaScript prototypes

As of 2026, Amber is closer to maintenance than active development. But for "I am curious what Smalltalk on the web looks like," it still answers the question. amber-lang.net.

The successor concept is PharoJS — write code in Pharo and transpile to JavaScript.

8. Dolphin, VisualWorks, VAST — The Commercial Camp

Not all of Smalltalk is open source. The commercial implementations are very much alive.

Dolphin Smalltalk (Object Arts) — Windows only. After being open-sourced in 2016, it has been community-maintained on GitHub. Tight integration with native Windows UI makes it the right answer when the requirement is "I want to write Smalltalk on Windows."

VisualWorks (Cincom) — a direct commercial successor of Smalltalk-80. Used in industry since the 1990s under the name Cincom Smalltalk. Cross-platform, multi-language, and a huge body of enterprise libraries are its strengths. Pricey, but JPMorgan Chase, Texas Instruments, and many insurance and logistics companies still use it.

VA Smalltalk (VAST) (Instantiations) — successor to IBM VisualAge for Smalltalk, which IBM created in the 1990s. The license moved from IBM to Instantiations in 2002, and IBM CICS and MQ integration is still strong. The right answer for an enterprise Smalltalk project that needs to talk to a mainframe.

Smalltalk/X — another commercial implementation developed in Germany. Native on Win32 and Linux.

What the commercial camp shares in common: they are deeply embedded in companies that can afford them (finance, logistics, telcos), which keeps them alive. But new adoptions are rare.

9. GemStone/S — Distributed OO Database with Smalltalk Inside

GemStone/S 64 Bit is a distributed object database built by GemTalk Systems. Not a relational database — an OODB that persists Smalltalk objects directly. Every Smalltalk object lives on disk automatically and can be modified safely inside transactions.

Where GemStone is used

  • JPMorgan Chase — parts of asset management systems
  • Cargill — global grain trading
  • Sears — at one point, the catalog system
  • Texas Instruments — manufacturing
  • Many insurance back offices

GemStone's selling point is managing a huge OO model in a transaction-safe way. You deal with billions of objects like memory — using plain Smalltalk syntax. No separate query language like SQL is needed.

GemTalk Systems is the company that maintains the GemStone product family. GemStone/S 64, Maglev (Ruby on GemStone), and some consulting. The license is expensive, but a free community edition exists.

gemtalksystems.com — downloads and documentation.

10. Seaside — The Continuation-Based Web Framework

Seaside is the most famous web framework the Smalltalk camp has produced. Started in 2002 by Avi Bryant, Seaside differs from every other web framework in that it is continuation-based.

What does continuation-based mean? It means there are no callbacks between web request and response. When the user clicks "Next," the server captures the call stack at that moment and resumes it later. The developer writes code as if building a desktop GUI.

| name |
name := self request: 'What is your name?'.
self inform: 'Hello, ', name.

These two lines show a form to the user, receive a response, and greet them by name. Callbacks, routing, and session management are all automatic.

Seaside 3.5 (2024) supports:

  • First-class behavior on Pharo 12 and 13
  • WebSocket support
  • REST API adapters
  • HTML5 components
  • jQuery and Bootstrap widgets

Because of the trade-offs of the continuation model — memory usage and scalability — Seaside is not the top pick for huge-traffic public sites, but for internal tools heavy on complex wizards and form flows, it is unbeatable.

seaside.st — official site.

11. Iliad, AIDA/Web, Pier CMS — The Other Web Frameworks

Seaside is not alone.

Iliad — a newer Smalltalk web framework. It drops continuations and adopts more RESTful routing. Started by Sebastien Audier in 2009.

AIDA/Web — another Smalltalk web framework by Igor Stasenko and others. Component-based but lighter than Seaside. A project from Croatia.

Pier CMS — a CMS built on Seaside. You can build wikis, blogs, and general websites with it. Led by Lukas Renggli. As of 2026 it is more "usable" than actively developed.

Teapot — a Sinatra-style microframework for Pharo. Fit for REST APIs. Built by Attila Magyar.

Zinc HTTP Components — Pharo's standard HTTP client/server. Practically every modern Pharo web stack runs on Zinc. Maintained by Sven Van Caekenberghe.

12. Roassal3, Bloc, DataFrame — Modern Pharo Libraries

The core libraries of the Pharo 13 era.

Bloc — Pharo's new graphics framework. Long-developed as a candidate to replace Morphic, Bloc became a first-class citizen in Pharo 13. GPU acceleration, faster text rendering, composition-based layout.

Roassal3 — Pharo's data visualization library. Led by Alexandre Bergel with a group around the University of Chile. Dynamic graphs, charts, treemaps, scatter plots, chord diagrams — all expressed in Smalltalk code. Used as a first-class visualization tool inside GT.

DataFrame — Pharo's pandas. Started by Olek Zaytsev. Performs statistical analysis and visualization on row and column data. For data science.

PolyMath — Pharo's numerical computing library. Linear algebra, statistical distributions, optimization. NumPy's Smalltalk cousin. Not as deep as NumPy but practical enough.

ML-Smalltalk / Mathemagics — for machine learning. Not an industrial-grade ML library; educational and research-oriented.

NB / Pharo FFI — Native Boost. The FFI you use from Smalltalk to call C libraries. SQLite, OpenSSL, libsodium and so on.

13. Iceberg, Metacello, STON — Packages, Git, Serialization

How does an image-based paradigm mesh with Git? Know three core tools.

Iceberg — Pharo's Git integration. It bidirectionally synchronizes classes and methods inside the image with text files in a Git repository. You can commit, push, pull, merge, and branch — all from inside Pharo. The UI feels like GitHub Desktop.

Metacello — Pharo's package manager. Declare dependencies in a ConfigurationOfXxx or BaselineOfXxx class, and Metacello loads them from GitHub into the image. Similar to npm and pip, but at the class level rather than the file level.

Metacello new
  baseline: 'Roassal3';
  repository: 'github://ObjectProfile/Roassal3:master';
  load.

STON (Smalltalk Object Notation) — a JSON-like text format for serializing Smalltalk objects. More expressive than JSON, preserving object graphs and references. Used for configuration and data exchange.

Tonel — Pharo's text-based source format. The trend has moved from one method per file (Filetree) to one class per file (Tonel). Git diffs become much cleaner.

14. Industry Adoption — Finance, Logistics, Education, Research

Where does Smalltalk actually run? Surprisingly many places.

Finance

  • JPMorgan Chase — runs an asset management system called Kapital on VisualWorks Smalltalk. A decades-old codebase.
  • Orient Overseas Container Line (OOCL) — a global container line. Parts of its operations are Smalltalk.
  • MoneyMarket and some hedge funds — back office for trading desks.

Logistics and manufacturing

  • Cargill — grain trading on GemStone/S.
  • Sears (historical) — catalog system.
  • Texas Instruments — manufacturing line control.
  • Desjardins (Canadian financial group) — insurance back office.

Education and research

  • Université de Berne, INRIA Lille, Université de Lille — the heart of Pharo development.
  • ETH Zürich, MIT — Smalltalk shows up in some OO courses.
  • POSTECH (Pohang University of Science and Technology) — historically used Squeak and Pharo in OO classes.
  • Universidad de Chile — birthplace of Roassal.

Live coding and art

  • Glamorous Toolkit — feenk shows it off with consulting engagements.
  • Comparable to Sonic Pi in the musical live-coding world.

Healthcare

  • Some EMR/EHR systems are built on VAST.

15. Korean and Japanese Smalltalk Scenes

Korea

The Korean Smalltalk community is small but never died out. POSTECH (Pohang University of Science and Technology) has a history of using Smalltalk in OO courses since the 1990s, and some graduates have carried that Smalltalk experience into industry.

Some courses at KAIST and Seoul National University once used Squeak for OO introductions. The Korean Pharo user group is small in scale but connected through GitHub and Discord.

Korean-language materials are scarce, so learners typically use the English "Pharo by Example" or "Deep into Pharo."

Japan

The Japanese Smalltalk community is relatively more active. Squeak JP and Squeakland Japan spread Squeak Etoys in the context of children's programming education. A group called Niiseikai Squeak has held meetups in Tokyo for years.

Tokyo Smalltalk Workshop holds regular meetings, and Japanese participants attend the ESUG Smalltalk Conference consistently. Japan's Pharo community is larger than Korea's, and there are some Japanese-translated Pharo materials.

Industrially, some Japanese insurance and logistics companies maintain VAST or VisualWorks codebases.

16. Self and Newspeak — Smalltalk's Successors

Smalltalk is not the only language driving OO research. Other languages in the same family.

Self — an object language with prototype-based inheritance, built by David Ungar and Randall Smith at Sun Microsystems. It dropped Smalltalk-80's class concept and established the model in which every object is a prototype. JavaScript's prototype model and the Hotspot JVM's JIT techniques (adaptive optimization) all trace back to Self.

Newspeak — a new Smalltalk-family language by Gilad Bracha. Emphasis on modularity and security. A more refined semantics than Smalltalk.

Strongtalk — Smalltalk with optional static types. Built at Animorphic Systems in the 1990s. Parts of its code later flowed into the HotSpot JVM.

Slate — a multiple-dispatch Smalltalk cousin.

Future Pharo branches — research into JIT compilers like Sista (speculative inlining) and Druid is ongoing.

17. Influence on Objective-C, Ruby, Python, JavaScript

Smalltalk does not have a giant user base, but its influence is enormous. Almost every modern OO language carries its traces.

Objective-C — built by Brad Cox and Tom Love. Smalltalk message-passing layered on top of C. NeXT adopted it, and after NeXT was acquired by Apple, Objective-C became the core language of macOS and iOS. The [obj message:arg] syntax is the direct trace of Smalltalk.

Ruby — Yukihiro Matsumoto's design is a synthesis of Perl and Smalltalk. Everything is an object, blocks (closures), method_missing — all of these come from Smalltalk.

Python — some of Guido van Rossum's design decisions reflect Smalltalk influence. Everything is an object, metaclasses, __getattr__ style hooks.

JavaScript — Brendan Eich looked at Self when he built JavaScript in ten days. JavaScript's prototype-based object model descends directly from Self.

Java — a cousin built by simplifying the Smalltalk-80 object model. Class-based OO, garbage collection, single inheritance — Smalltalk did it first.

Dart — Google's language, the foundation of Flutter. Lars Bak designed it drawing on Strongtalk and HotSpot experience.

Erlang — Joe Armstrong drew inspiration from Smalltalk message-passing when designing the actor model.

A modern programmer who has never heard of Smalltalk is, in fact, using Smalltalk's descendants every day.

18. Learning Resources and Communities

Free books

  • Pharo by Example (books.pharo.org) — the classic introduction to Pharo.
  • Deep into Pharo — intermediate. Meta-programming, building your own tools.
  • Enterprise Pharo: a Web Perspective — for web development.
  • The Pharo MOOC — a free video course by Stéphane Ducasse and others.

Paid books

  • Smalltalk-80: The Language and Its Implementation (Goldberg and Robson) — the Blue Book. 1983.
  • Smalltalk Best Practice Patterns (Kent Beck) — patterns for good code written in Smalltalk.
  • Pharo with Style (Stéphane Ducasse and others) — modern style guide.
  • Squeak: Open Personal Computing and Multimedia (Mark Guzdial and others) — introduction to Squeak.

Conferences

  • ESUG (European Smalltalk User Group) Conference — held every August or September in Europe. The largest regular gathering.
  • Smalltalks Conference — held every year in Argentina.
  • Pharo Days — held every year in Lille, France. Pharo core team attends.
  • Camp Smalltalk — irregular hackathon-style gatherings.

Online

  • Pharo Discord — the most active channel.
  • Pharo discussion list — mailing list.
  • Smalltalk Reddit (r/smalltalk) — discussion.
  • GitHub pharo-project/pharo — the main repo.

19. Starting Fresh with Smalltalk in 2026

If you are touching Smalltalk for the first time in 2026, here is the path I recommend.

Step 1 — Install Pharo Launcher Download Pharo Launcher from pharo.org/download. This tool manages multiple Pharo images. Grab the latest Pharo 13 64-bit and open it.

Step 2 — First code in the Playground Open the Playground once the image is up. Type the following and hit Cmd+P (Print it) or Ctrl+P:

1 to: 10 collect: [ :x | x * x ]

#(1 4 9 16 25 36 49 64 81 100) prints.

Step 3 — Open the System Browser Cmd+O+B or World menu, then System Browser. Every class is here. Find Number and open the + method. Notice that even arithmetic operators are message sends.

Step 4 — Object Inspector Open any object in the inspector. You see its class, instance variables, and messages it can respond to.

Step 5 — Create a Git repo through Iceberg Push a simple project to GitHub via Iceberg. Awkward at first, but natural once you adjust.

Step 6 — Download Glamorous Toolkit Get Glamorous Toolkit at gtoolkit.com. Experience a moldable environment instead of a plain IDE.

Step 7 — Build a Roassal3 visualization Write code that takes an array of numbers and draws a bar chart. A handful of lines.

Step 8 — Tiny web app in Seaside Feel firsthand what a continuation-based web framework is like.

You can fit those eight steps into a single weekend. Once you do, the question "why am I editing text files?" starts to surface.

20. Wrap-up — What Smalltalk Teaches You

Smalltalk will never become mainstream. That is certain. But Smalltalk will not disappear either — because the ideas inside it are too powerful.

Everything is an object — really. 1 + 2 is message-passing. Classes are objects. Methods are objects.

The system is live — you change code in a system that never stops. The debugger is a first-class citizen.

Meta is first-class — the first language to consistently model the class of a class (the metaclass).

Environment is the language — the IDE, debugger, inspector, and browser are not separable from the language.

These four properties, half a century later, are not fully realized in any other language. That is why anyone who has touched Smalltalk seriously, even after switching to another language, keeps asking themselves "how do I do the thing I did in Smalltalk here?"

Alan Kay often quotes himself: "The best way to predict the future is to invent it." Smalltalk invented that future fifty years ago. We still have not caught up to it.

In 2026, give Smalltalk a try. You will not regret it.

21. References

Discuss on Twitter • View on GitHub