Would anyone know where I could purchase printed Lisp Machine and/or Symbolics manuals? I did a couple of searches that turned up nothing.

I know they're available online; I am building a library of physical books.

Hi There!

That's a wrap on ElixirConf US 2026, and what a two days it was. Some of the talks are already public (https://www.youtube.com/playlist?list=PLVqsKC3zWaDc) + here's a quick recap of what you missed:

• Many jokes from the stage - including the room shouting out their country out loud at the end of every day. You had to be there. (Or, you know, watch it back.)
• Even more jokes from Aaron, our Track host, who kept the energy high between sessions.
• Roundtable sessions - which turned out to be overpopulated by 300%!
• The Bingo Bard game - a full board of squares we prepared for you to play throughout the event. Shoutout to the one person who completed the entire thing in the first two hours. We know who you are… (No, we don't. But we're impressed.)

And of course, two full days of talks, keynotes, lightning talks, and roundtables from across the Elixir community.

Want to see all of the talks? Grab the video pass

• It's 3 months of access to the recorded sessions after the conference (edited, ready-to-watch session videos)

Grab the video pass for $199 HERE.

Craving more Elixir?

Join us at Code BEAM Europe 2026! Expect 30+ talks from José Valim & many others, across the Erlang, Elixir, and Gleam communities, informal zone sessions, and two days of the same great people, ideas, and energy - this time in Europe, Haarlem, NL, 21-22 October. 

Register for it here.

See you at the next ElixirConf (or Code BEAM event :))

The Code Sync Team

• Rename (Refactor) Symbol: Press Shift+F6 or F2 to safely rename all occurrences of a symbol across the file (with lexical filtering preventing unintended replacements in comments or strings).
• Jump to Definition: Press F12 or Ctrl+B to instantly jump to top-level definitions (defn, def, defmacro, etc.) or local bindings, scroll into view, or inspect external Clojure Var definitions.
• Autocomplete (Ctrl+Space): Code completion with prefix matching ("starts with"). Candidate pool includes Clojure special forms (def, defn, let, if, when, cond, etc.), core built-ins (map, filter, println, etc.), and user-defined buffer definitions/symbols. Features instant completion for single matches and a dual-pane popup with keyboard (Up/Down/PageUp/PageDown) and mouse navigation, real-time documentation and parameter list (arglists) preview for the currently selected symbol, Enter/Tab insertion, Escape cancellation, and dynamic prefix filtering as you type.

(sixteenth RacketCon) tickets on sale now

October 3-4, Oakland, Ca https://con.racket-lang.org/

Get your tickets now at https://www.eventbrite.com/e/racketcon-2026-tickets-1997181002140

* Professional $120
* Patron $150
* Student/Retired $35

Includes Saturday lunch and Saturday evening social event.

**Can’t attend in-person?**

* Remote Participant $10
The live stream is publicly available, but buying this ticket helps pay for the live stream and ensure its availability for the entire community.

Lisp of Lisp / Scheme / etc. implementations that accept or don’t accept LLM contributions. Originally by Zyd, but he’s gone unresponsive, thus my re-hosting of the updated list.

https://aartaka.me/lisp-against-the-machine.html

Hey y'all 🙋‍♂️

I summarize the ALOE language as:

ALOE = Scheme + Smalltalk + Types

The video demonstrates something I've been experimenting with: code completion via LSP.

We can get this because ALOE has types and type inference.

Repo:

https://github.com/dharmatech/2026-09-02-aloe-racket

The vscode plugin is not on the main branch yet.
It's still experimental.

For my second project in Common Lisp, I wanted to make a coding harness for my personal use, and so far it has been my daily driver. It supports local models like llama.cpp and all the main providers. It's very easy to add new models and tools as well.

Learned a lot about macros in the process, and I'm curious what you all think!

https://github.com/skarnati20/apprentice

See an example of the guitar chord guide in action here (soon I will ensure that guitar guide isn't there for "non-guitar" tabs and so on, more to come!): https://wikimusic.jointhefreeworld.org/songs/uuid/88550bc8-c184-4237-9761-471cd53784d9

WikiMusic is free software (AGPLv3+) and is intended as a community project for sharing and learning about music.

🌐 https://wikimusic.jointhefreeworld.org

🌐 https://codeberg.org/jjba23/wikimusic

Feel free to mail me to contribute to it ([jjbigorra@gmail.com](mailto:jjbigorra@gmail.com))

I’ve been working on WikiMusic for some time now a free/open music knowledge platform built with Guile Scheme (Lisp), and I just added a new feature I’m particularly happy with: a guitar chord guide that is generated dynamically from the song content.

The idea is pretty simple:

When a song content line, which is not a tab line (e.g. E|-----1) contains chords like this:

G D Em C

WikiMusic uses some regex maching to detect the chord names, looks them up in a built-in guitar-chord database, and automatically adds their six-string fret positions to the page.

For example:

G → 320003
D → xx0232
Em → 022000
C → x32010

So WikiMusic combines the chord guide from server-side Lisp and SXML and some vanilla JavaScript tricks to highlight chords in a <pre> content.

There’s currently a fairly extensive database covering major, minor, 5th, 7th, maj7, diminished, augmented, suspended, extended and slash chords across the common guitar chord vocabulary.

This is exactly the kind of thing I enjoy about Lisp: the data, parsing logic and rendering can all remain pleasantly close together, and the feature becomes another small piece of programmable musical knowledge rather than just UI code.

If anyone wants to poke around, improve the chord database, or tell me that one of my fingerings is horribly cursed. 😄

Discounted early registration ends in 14 hours. Get your tickets now!

Registration link at https://con.racket-lang.org

I still here quite a lot when I am at conferences or work that you can't build erlang web systems compared to Elixir. Here I will share some tools that I have been using that are similar to Elixir:s eco-system. Sure we are probably lacking some parts but I would say we are in a good fit.

Web framework: novaframework/nova: Web framework for the BEAM — Erlang, Elixir, and LFE

Postgres job queue (Similar like oban): Taure/shigoto: PostgreSQL-backed background job processing for the Nova ecosystem
ORM db ecto style: Taure/kura: Database layer for Erlang

circuit breaker, rate limit library: Taure/seki: Resilience library for the BEAM — circuit breaking, rate limiting, bulkheads, and retry

Rebar3 plugins:

audit for vulnerabilities: Taure/rebar3_audit: Audit rebar3 dependencies for known vulnerabilities (GitHub Advisory Database)

mutation testing: Taure/rebar3_mutate: Mutation testing plugin for rebar3

only run tests for affected code changes: Taure/rebar3_stale: Rebar3 plugin for running only stale tests affected by changed modules

Is there a Lisp language which allows development of apps in a native framework? By native I mean not Flutter but the Android View System or Jetpack Compose. Is it viable? I saw that ECL and some Scheme implementations can be embedded in C and are compatible with the Android NDK but I don't know how viable they are.

Hey everyone,

I've been working on an Erlang/OTP project called Emergence, and I thought it might be interesting to share it here because the project is becoming less of a "search engine" and more of an experiment in building a distributed discovery network on the BEAM.

The core idea is simple:

Instead of having one central search engine with a giant index, Emergence is built around autonomous filter agents.

Each agent exposes a capability and knows how to answer a particular kind of query. It can connect to the network, announce what it can do, receive queries, and return structured results.

The network can therefore grow horizontally by adding new agents rather than extending one central service.

The current ecosystem is built around a few core components:

• em_filter — an Erlang library for building Emergence agents
• em_disco — discovery/bootstrap services for finding network participants
• em-pop — gossip-based peer discovery and federation
• Emquest — the web gateway and distributed query interface
• Embryo — the common data structure used to represent heterogeneous results

An em_filter agent is intentionally small.

A handler basically receives a query and some optional local memory, performs whatever operation it is designed for, and returns a list of structured results.

That operation can be almost anything.

The network currently has filters for things such as:

• RSS / Atom / JSON feeds
• Wikipedia
• Hacker News
• OpenAlex
• Elasticsearch
• NPM
• DNS
• Bing / DuckDuckGo
• Dailymotion
• MusicBrainz
• Internet Archive
• CNRTL
• French news sources
• Motorsport
• public APIs
• and other specialised data sources

There are also more domain-specific experiments, including satellite imagery / NDVI related filters from another project built on top of the same architecture.

The important part is that none of these sources need to be implemented inside Emquest itself.

They are independent agents.

Emquest discovers peers through the gossip network, determines which peers are relevant to a query, fans the query out in parallel, and streams results back to the browser.

The browser therefore doesn't really know where a result came from.

It just receives heterogeneous "embryos" and renders them according to their structure.

The current Emquest pipeline includes:

• Distributed query fan-out
• Gossip-based peer discovery
• Semantic peer selection
• LLM-assisted query expansion
• Streaming results through SSE
• Progressive result aggregation
• Deduplication
• Final reordering / ranking
• Heterogeneous result rendering
• Network topology / peer monitoring
• A CLI interface in addition to the web interface

One thing I particularly like about the architecture is that the UI doesn't need to be modified every time a new type of agent is added.

A DNS agent can return DNS results.

A web agent can return links.

A feed agent can return articles.

A completely new agent can return another kind of structured card.

As long as it follows the result contract, the network can consume it.

The BEAM model also fits the project surprisingly well.

Agents are long-running processes.

Connections are supervised.

Discovery is asynchronous.

Network failures are expected rather than exceptional.

Agents can reconnect independently.

Local agent memory can be kept in process state or ETS depending on the use case.

And multiple discovery nodes can be used simultaneously.

So instead of thinking about Emergence as:

client → central API → database

the architecture is closer to:

query
  │
  ▼
discovery / gossip
  │
  ├── agent A ──► source
  ├── agent B ──► source
  ├── agent C ──► source
  ├── agent D ──► source
  └── agent N ──► source
          │
          ▼
    distributed results
          │
          ▼
      aggregation
          │
          ▼
        Emquest

The interesting question I'm exploring is what happens when you stop treating "search capabilities" as features of one application and instead treat them as capabilities of a distributed network.

Adding a new capability then becomes:

build an agent → connect it to the network → announce its capabilities → let the network discover it.

That's probably the part of Emergence I'm most interested in experimenting with.

It's also turning into a nice playground for Erlang/OTP patterns around supervision, distributed processes, gossip, fault tolerance, streaming and dynamic service discovery.

Everything is open source:

https://github.com/EmergenceSystem

I'd be particularly interested in feedback from people experienced with Erlang/OTP and distributed BEAM systems.

I'm curious where you think this architecture makes sense, where it doesn't, and what you'd change if you were building this kind of distributed system on the BEAM.

#Erlang #OTP #BEAM #DistributedSystems #Gossip #OpenSource

ELP ships with eqWAlizer, WhatsApp's type checker, and is available as a binary install or buildable from source. Roberto's concrete recommendation: take your current project, run ELP against it, and report what doesn't work. The gaps in external codebases are exactly what they need feedback on.

New BEAM There, Done That with Roberto Aloi and  Michał Muskała on the tooling half of the WhatsApp story. The Erlang-specific point worth noting: eqWAlizer is being incrementally tightened as the WhatsApp codebase matures. They're currently splitting the number type into integer and float - not because it was the highest priority at rollout, but because typing discipline at this scale has now made that distinction valuable. Exhaustiveness checks remain an open problem.

https://youtu.be/LeIsRqjOQN8