HN Debrief

Squeak 6.1

  • Programming
  • Developer Tools
  • Open Source
  • AI

The release notes for Squeak 6.1 cover another update to the classic Smalltalk environment, including work on high-DPI support, Morphic UI improvements, and general maintenance of a system that still ships the full live image experience Smalltalk is famous for. That means you do not just edit source files and restart a process. You work inside a persistently running world where code, objects, tools, and UI are all inspectable and changeable while the system is alive.

If you build developer tools, internal platforms, or AI-assisted workflows, the live image model is worth revisiting because it makes inspection, stateful editing, and system-wide introspection first-class instead of bolted on. If you want newcomers to actually adopt these ideas, UI polish and deployment paths still matter as much as language elegance.

Discussion mood

Mostly positive and nostalgic about Smalltalk’s core ideas, especially the live image and deep introspection. Frustration centered on Squeak’s dated UI, uneven deployment story, and the sense that better descendants or neighboring projects now carry the torch more convincingly for day-to-day use.

Key insights

  1. 01

    The image model kills initialization boilerplate

    The persistently running image reframes an application as something you shape in place instead of repeatedly tearing down and reconstructing. That makes a lot of ordinary startup and state restoration code look like accidental complexity. When the object graph already exists in the right form, many problems vanish before they become framework conventions or serialization chores.

    Look at your stack’s startup, hydration, and persistence layers as product decisions, not inevitable plumbing. If your team is building long-lived tools, agents, or internal systems, prototype a stateful workflow that preserves live object state across sessions.

      Attribution:
    • kitd #1
    • lilbigdoot #1
    • fidotron #1
    • TheTaytay #1
  2. 02

    Morphic came from Self, not just Smalltalk

    The most useful architectural lineage runs from Self Morphic into Squeak, then outward into browser-based systems like Lively Kernel and morphic.js. That matters because the original design was not a classic class hierarchy. It leaned on prototypes, traits, copyable morph trees, and direct manipulation. Squeak translated those ideas into a more conventional Smalltalk class system, but the live feel came from the object model and copying semantics, not from inheritance tricks.

    If you want to borrow ideas from Morphic for modern tools, start with the Self handbook and Lively-era implementations, not just Squeak screenshots. The transferable lesson is copyable live objects and inspectable UI state, which you can apply outside Smalltalk.

      Attribution:
    • DonHopkins #1 #2
    • pjmlp #1
  3. 03

    JavaScript’s family tree is broader

    The claim that JavaScript got its good parts from Smalltalk was called out as too neat. Self deserves explicit credit for prototype-based objects, and Scheme shaped other core parts of the language. That correction sharpens the historical lesson. Modern dynamic languages did not inherit from one clean lineage. They are hybrids, and the parts people love often came from different ancestors than the syntax suggests.

    When you mine old languages for ideas, trace the specific mechanism you want instead of copying the brand label. Prototype systems, live environments, and functional control structures traveled through different lines and should be evaluated separately.

      Attribution:
    • addaon #1
    • Jtsummers #1
    • vanderZwan #1
  4. 04

    Direct inspection is still ahead of today’s tooling

    Being able to inspect a running button and jump straight to the object and code behind it still feels better than the usual browser devtools plus framework indirection stack. The point is not that old GUI builders were perfect. It is that live introspection across UI and code used to be normal in some environments and is now oddly rare outside specialized tools.

    If you build frameworks or IDEs, invest in object-level inspection that crosses from UI element to live code and back. That capability has more leverage than another layer of abstractions or generated scaffolding.

      Attribution:
    • Decabytes #1
    • eitland #1
  5. 05

    Persistent objects remain technically plausible

    Several concrete implementations pushed the image idea beyond nostalgia. One described a proxy-based object store that lazily loads objects from a key-value database through doesNotUnderstand. Another described a git-style content-addressed image with residency-based paging and delta saves. GemStone/S and InterSystems Caché came up as older systems that already treated objects as the primary persisted unit. The hard part is not fantasy. It is collections, paging behavior, and operational boundaries between live state and saved state.

    If your domain model fights constant object-relational translation, evaluate object persistence or content-addressed snapshots for narrow subsystems first. The right pilot is a state-heavy tool or data model where identity and graph structure matter more than ad hoc SQL querying.

      Attribution:
    • unignorant #1
    • dev_dan_2 #1
    • actionfromafar #1
    • fuzztester #1
  6. 06

    High-DPI support is a gating issue

    For many people, the biggest barrier was not the language or object model. It was that Squeak looked blurry or old on modern displays for years. The release notes claim meaningful high-DPI improvements, and at least one person reported it now looked good on macOS. Others pointed to Cuis and its vector-based GUI as evidence that the problem is solvable and that presentation quality heavily shapes whether these systems get a fair trial.

    Do not assume powerful ideas survive poor ergonomics. If you maintain a niche but ambitious platform, fix display quality, fonts, and input polish early because they determine whether newcomers ever reach the deeper ideas.

      Attribution:
    • atemerev #1
    • mparrett #1
    • sswezey #1
    • adius #1

Against the grain

  1. 01

    Static boundaries protect systems from themselves

    The strongest pushback was that the very fluidity people love in Smalltalk also removes safety rails. Operating system boundaries, explicit deployment artifacts, and restart-based workflows are not just historical baggage. They contain blast radius. A world where you inherit someone else’s entire live machine, or worse share that mental model with production, can turn clarity into operational chaos fast.

    Use live images and in-place mutation where the team owns the full lifecycle and can recover from mistakes. For shared production systems, keep clear boundaries for reproducibility, rollback, and handoff even if that means giving up some elegance.

      Attribution:
    • bowsamic #1
    • xjdjdkdjn #1
  2. 02

    Better Smalltalk experiences now live elsewhere

    Some people treated Squeak itself as the wrong place to start. Glamorous Toolkit on top of Pharo was suggested as a more modern on-ramp, especially for people who care about sharper UI and richer inspectors. That undercuts the idea that the release alone is the main event. The concepts are still alive, but the best packaging may have moved to sibling projects.

    If your goal is to learn live object systems rather than contribute to Squeak specifically, compare Pharo, Glamorous Toolkit, and Cuis before committing. The best entry point may be the project that modernized the rough edges, not the oldest lineage.

      Attribution:
    • pmkary #1
    • efficax #1
    • flowardnut #1

In plain english

content-addressed
A storage approach where data is identified by a hash of its contents rather than by a location or mutable name.
Cuis
A simplified fork of Squeak that modernized parts of the system, especially its graphics and Morphic implementation.
doesNotUnderstand
A Smalltalk message hook that runs when an object receives a message it does not implement, often used for proxies and metaprogramming.
GemStone/S
A Smalltalk-based object database and application platform designed to persist objects directly.
Glamorous Toolkit
A Smalltalk-based environment built on Pharo that emphasizes moldable tools, custom inspectors, and exploratory programming.
high-DPI
High dots per inch, meaning modern displays with very dense pixels that need scaling and sharper rendering to avoid blurry interfaces.
image
A saved snapshot of a running language environment, including code, objects, and often tool state, that can be resumed later.
InterSystems Caché
A commercial data platform with object database features and its own programming environment.
JavaScript
The main scripting language of the web, influenced by Self, Scheme, and other languages despite its C-like syntax.
key-value database
A database that stores data as pairs of unique keys and associated values, without relational tables.
Lively Kernel
A browser-based live programming environment inspired by Smalltalk and Morphic.
Morphic
A direct-manipulation graphical user interface framework used in Self and later in Squeak and related systems.
morphic.js
A JavaScript implementation of Morphic, best known as the graphics and interaction layer used by Snap!.
Pharo
A modern Smalltalk environment that shares ancestry with Squeak and focuses on tooling and developer experience.
prototype-based
An object model where objects inherit behavior directly from other objects rather than mainly through classes.
Ruby
A dynamic programming language heavily influenced by Smalltalk’s object model and message-sending style.
Scheme
A minimalist dialect of Lisp that influenced JavaScript’s functional features and language design.
Self
A prototype-based programming language that strongly influenced JavaScript and the original Morphic user interface model.
Smalltalk
A family of programming languages and live development environments built around objects, message passing, and editing a running system directly.
Squeak
An open source Smalltalk system that runs inside a virtual machine and stores the whole environment as a live image.
SqueakJS
A JavaScript-based virtual machine that runs Squeak images in a web browser.
traits
Reusable units of behavior that can be composed into objects or classes without using standard inheritance alone.

Reference links

Release and runnable systems

Morphic architecture and lineage

Browser and JavaScript descendants

Alternative Smalltalk environments and ports

  • Cuis Smalltalk
    Suggested as a simplified Squeak fork with vector-based graphics and better high-DPI behavior.
  • Glamorous Toolkit
    Mentioned as a more modern Smalltalk environment built on Pharo.
  • Newspeak
    Raised as a related Smalltalk-family project for compiling to modern targets.
  • SmallJS
    Suggested for building standalone apps and targeting JavaScript-adjacent deployment.
  • Amber Smalltalk
    Mentioned as a Smalltalk-to-HTML and JavaScript option, though apparently less active now.

Object persistence references

JavaScript history and language influence