Presentations
NOTE:The information on this page is not yet complete; more information will be added when it is available
Dyalog Presentations
D01: Welcome to Dyalog ’26
Show Summary
Dyalog Ltd's Managing Director opens the user meeting.
D02: The Road Ahead
Show Summary
In accordance with tradition, Morten looks briefly back over his shoulder before turning his gaze to the future, presenting his view of the road that lies before Dyalog Ltd and users of Dyalog, and setting the scene for the technical presentations that follow.
D03: Slowly Getting Faster
Show Summary
One of the promises of array programming is fast execution of algorithms written in a high-level notation. Asher describes how performance improvements planned for the next Dyalog releases continue to deliver on this promise.
D04: Improving APL Threads
Show Summary
APL threads can be a convenient way to structure concurrent applications. As the use of threading has grown, the implementation has started to show signs of strain, and issues can become apparent as the number of simultaneous threads increases. Peter presents some of the work being undertaken that aims to improve the performance and behaviour of APL thread switching, and the thread related language features such as :Hold and ⎕TGET.
D05: Dyalog and AI
Show Summary
Large Language Models (LLMs) are having significant impacts on our industries, in both good and bad ways. It's a fast-moving field. Stefan’s presentation is a "state of the LLM nation" snapshot of how we as APLers can take advantage of the good parts of what LLMs can do, and how we can avoid some of the downsides. He demonstrates how to enable communication between LLMs and the APL session, and takes us on a tour of the current models, tools, and techniques.
D06: Inside Dyalog Labs – From Prototype to Project
Show Summary
Dyalog Labs is an open-source initiative for tools, libraries, and experimental projects written in and for Dyalog APL. It has been established in response to new ways of developing software, and provides a place where ideas can be prototyped and turned into real projects.
Martina introduces the initiative, showcases some of the projects developed so far, and discusses the role of Dyalog Labs in growing the ecosystem of modern tools for the APL community.
D07: “Cooler Than Keanu”
Show Summary
John is a big fan of "Dark Mode"; he thinks it is very cool and has enabled it on all his devices. Unfortunately, Dyalog (and, by extension, your applications) doesn’t have a "Dark Mode". What can we do? How cool can we make Dyalog APL? (Hint: there's a clue in the title).
D08: Web Services Overview
Show Summary
As applications increasingly need to interact with other systems, data sources, and cloud-based services, web services have become a standard mechanism for communication. The Dyalog ecosystem provides a range of tools for consuming and exposing web services, enabling APL applications to participate in modern, distributed architectures and integrate seamlessly with the broader software landscape. In this presentation, Brian discusses the capabilities and common use cases of Jarvis, HttpCommand, and WebSockets.
D09: Making Web Services More Accessible
Show Summary
REST (Representational State Transfer) is the most widely used architectural style for web service APIs, allowing applications to exchange data and perform operations using standard HTTP protocols. OpenAPI is an industry-standard, machine-readable, specification for describing REST APIs, making it possible to automatically generate documentation, client libraries, testing tools, and other integration assets. Holden introduces the Dyalog OpenAPI Client Generator, which can generate APL client interfaces directly from OpenAPI specifications, greatly simplifying access to thousands of existing web services. He also introduces Stark, a framework that streamlines the development of Jarvis REST services and can automatically generate OpenAPI specifications for them, making those services easier to document, discover, and consume.
D10: Time’s Up
Show Summary
The I-Beam function that formats date-times as text has been merged into ⎕DT in Dyalog v21.0 and will be removed from a future Dyalog release. Richard discusses why the functions have been separate until now and the various enhancements that have been made to ⎕DT. He also explains why and when features are deprecated and removed, and demonstrates a tool to help you prepare for when this happens.
D11: Dyalog Static Analysis Tool – In Practice and the Future
Show Summary
Dyalog's Static Analysis Tool (DSAT) now enjoys real world usage. Brandon presents an overview of DSAT in practice and discusses what its future may look like. In particular, he looks at Continuous Integration/Continuous Delivery/Distribution checks, session integration, an emerging VSCode extension, and applications to AI tooling.
D12: The APL Forge – Introduction and Prize Ceremony
Show Summary
What is The APL Forge? How do you compete, and who won the 2026 and 2025 rounds? Stine introduces this competition and discusses some upcoming changes for the 2027 round, culminating in the award ceremony for the winners.
D13: Behind the Curtain: The Creation of a New Operator
Show Summary
Dyalog v20.0 introduced a new operator, behind (⍛). Silas explains some of the processes involved in adding a new language element like an operator, using the behind operator and the lessons learnt during its implementation as a reference.
D14: EWC in 2026
Show Summary
EWC is Dyalog's cross-platform implementation of the ⎕WC GUI family. Your APL applications are constructed using the same forms as under ⎕WC; EWC renders them as a real GUI on Linux, macOS, or Microsoft Windows, either in a desktop window or a browser tab.
Aarush demonstrates how EWC works; his demonstration includes examples of applications that have already been re-platformed without changes and others that have been built using EWC from the start. He explains what's changed since Morten’s Dyalog ’24 presentation on EWC, and shares the plan for the future.
D15: Ten Years Without Workspaces
Show Summary
The workspace is 60 years old, and at Dyalog '18, Paul Mansour declared it dead. Adám reviews the decade since. He traces the history of APL source – from binary workspaces and ⎕ORs in component files, through transfer files and SALT's scripted namespaces, to Link, Acre, Cider, Tatin, and Git – and shows how the interpreter has taken over jobs that once needed a bootstrap workspace. He considers what the workspace is still good for, and looks ahead to modules, single-file source, and source handling built into the interpreter.
D16: APL Media Update 2026
Show Summary
It can be difficult for professional users to make time to learn about everything happening in the world of Dyalog. The user meeting offers a great opportunity, but there's no need to wait for the next one to learn about new features, projects, and techniques. Rich provides an overview of what APLers have been saying and doing in this whirlwind tour of APL community projects and publications.
D17: Co-dfns Update (v6)
Show Summary
Co-dfns is an APL compiler that is designed to let a programmer use APL in more places and for more applications. When compared with the standard Dyalog interpreter, it can enable better integration with other programming environments and high-performance domains (such as scientific computing, machine learning, and graphics), and improved performance in certain situations. A lot has been happening with the Co-dfns compiler since Aaron’s last update at Dyalog ’24; he introduces the new version 6 release and provides a roadmap of what's next on the horizon for APL compilation.
D18: One Extension and Seven New Primitives
Show Summary
Many everyday APL expressions are longer than they need to be. Adám presents a draft proposal for eight small language changes, each of which shortens a common idiom: monadic ≤ and ≥ to sort ascending and descending, monadic ∧ and ∨ to promote and demote rank, monadic ⊤ and ⊥ to encode and decode binary, monadic ⊇ (a companion to monadic ⊃) to pick the last, and an extension to dyadic ⍴ allowing one axis length to be inferred. He demonstrates each in use and invites discussion.
D19: Testing the Untestable – GUIs, Fuzzers, and Dyalog APL
Show Summary
Every Dyalog release is preceded by a lot of testing that users never see. Aarush introduces through the test suites that run continuously against the interpreter: the long-standing unit tests, ullu's primitive-by-primitive tests, coverage-instrumented builds that report exactly which lines of the interpreter's C source each suite exercises, and fuzzing, which compiles an instrumented interpreter and then spends entire weekends inventing APL expressions designed to crash it. Crashes are automatically minimised, deduplicated, and added to a growing body of tests that are replayed against every platform and edition on later builds.
He then introduces CITA, which lets our APL tools be tested against many interpreter versions, editions, and platforms on real hardware.
Aarush concludes by looking at the testing of GUIs, which have always been the part everyone struggles to automate. He demonstrates how EWC and ⎕WC are now covered by several hundred tests with pixel-tight visual regression running on every pull request. Much of this suite was written by LLM agents exploring the running application, and he concludes with his thought on this approach might change the way in which test suites are built and maintained.
D20: Plots and Tables: A Modern Approach
Show Summary
It is usually convenient to represent data visually, for example, as a table or as some kind of technical plot, and Dyalog already offers several options for doing this. Jesús introduces a different approach that uses some of Dyalog APL’s features: user commands are organised in Tatin packages, configuration options and data are defined as namespaces, and external JavaScript libraries take care of the actual rendering. As a lighter option, a text-based alternative renderer is provided, which makes it possible to display simple plots and tables directly in your session in any environment.
D21: Closing Session
Show Summary
Dyalog Ltd's Managing Director closes the user meeting.
User Presentations
U01: Think in Arrays: Design, Iterate, and Build in the Age of AI
Dave Thomas (Canada), Bedarra Corporation
Show Summary
Dave presents a brief review of the essentials of array thinking and its impact before discussing how array practitioners move from thinking to program design and implementation. Jumping forward to the current Age of AI, he explores the role of arrays – what some call 'Iverson's Ghost', visible today in NumPy and PyTorch – in today's Machine Learning (ML) and Large Language Models (LLMs). This leads naturally into approaches for the generative development of array programs. Dave concludes with a discussion of promising compiler and hardware research.
U02: Dyalog in the Global Investment Management Architecture
Oliver Lanz (Denmark), SimCorp A/S
Show Summary
Dyalog Ltd has been SimCorp’s trusted partner for core processing throughout all major technology transitions. Oliver explains what SimCorp do in the context of their latest transitions from desktop applications to cloud-native backend-systems and the emergence of useful AI use cases.
U03: Coming Up for Air: What I’d Like to See from Dyalog
Gilgamesh Athoraya (Sweden), Tiamatica AB
Show Summary
After five years focused on a large migration project, Gilgamesh takes a step back and looks at Dyalog with fresh eyes. He shares his personal wishlist of features and improvements that would make life easier for developers and help keep Dyalog relevant in a rapidly-changing software landscape.
U04: Why CI is (Also) Important in the Age of D-AI-alog
Lars Stampe Villadsen (Denmark), SimCorp A/S
Show Summary
Lars explores how Continuous Integration (CI) discipline helps you in agent (and human) driven development, and explains why local execution and procedures should be built to steer both humans and agents.
U05: The APL Forge (Winner) – APLearn, Machine Learning in APL
Borna Ahmadzadeh (Canada), student at York University
Show Summary
In recent years, the world of artificial intelligence has been dominated by Generative Artificial Intelligence (GenAI). However, traditional models like linear regression and decision trees remain the powerhouse behind machine learning (ML) applications dealing with structured data such as tables. Borna demonstrates APLearn, an APL library implementing common ML algorithms for a variety of tasks such as supervised learning, clustering, and dimensionality reduction. He explores array programming’s relevance in the context of ML, its unique advantages and occasional drawbacks, and trains a couple of models on real data to get a taste for what ML in APL might look like in practice.
U06: The APL Forge (Winner) – Forging Voxels with Dyalog APL
Kyle Croarkin (U.S.A.), independent
Show Summary
Kyle has developed a project utilising APL to make a Minecraft-like game called “A Voxel Game”. He presents an overview of his project, describes his experiences as he went through the process of game development in APL, and explains how APL contributed to different parts of the architecture.
U07: The APL Trust – An Update
Diane Hymas (U.S.A.), independent
Show Summary
Inspired by the vision of Gitte Christensen, The APL Trust US was established as a non-profit organization in 2025 to support the growth and impact of APL in education, research, science, engineering, and mathematics. Diane provides a brief update on the APL Trust’s background, mission, current status, and early grant-funded projects. Whether you are new to the APL Trust or have followed its progress from the beginning, she invites you to learn how this initiative is helping support innovative APL work and how you can take part in its future.
U08: The Next APL Font Family
Madeline Vergani (Italy), independent
Show Summary
Madeline talks about her work on the APL387 font, focusing on the most interesting design and technical choices and her hopes about the future of the font. She is particularly interested in community opinions on perhaps the most important part of the font family...its name!
U09: Trying to Make a Point: APL Glyphs in Action
Katya Solstad (U.S.A.), KFT / The Book of Glyphs / Applied Meanings
Show Summary
Katya’s presentation will unfold not as an explanation but as a theatrical performance in which the glyphs leave the keyboard.
Iverson called notation a tool for thought – this presentation goes to the thinking itself.
U10: Claude is the New Quad
Mark Wolfson (U.S.A.), Buyers Intelligence Group (BIG)
Rich Park (U.K.), Dyalog Ltd
Show Summary
APL enables knowledgeable people to express solutions as simple, direct, code. In an ideal world, we could live in the Session, elegantly transforming from array to array. In the real world, we often need additional expertise to interface with other technologies, to utilise existing solutions, or to make our own accessible to less technical end users.
In APL, quad (⎕) denotes the machine and can be thought of as the window to the outside world. System functions have long been the primary mechanism for that interfacing. At their best, they are simple enough for a domain expert to build an entire system unaided. However, their limits are the implementor's limits, and beyond those you still need to know the external technology. Large Language Model (LLM)-assisted development is now lowering that barrier; Rich and Mark demonstrate examples of APL development and interfacing work accelerated by LLM assistance.
U11: The Newcomer's Experience: Creating a Video Game in APL
Mikaela Hsu (U.S.A.), independent
Show Summary
Mikaela describes the process, difficulties, and upsides of learning APL, as well as the mindset behind learning to apply artistic creativity to technology while creating a video game.
U12: Tacit in Practice
Max Sun (Canada), InvestCloud
Show Summary
Tacit programming is a paradigm in which the programmer, rather than writing a dfn or tradfn that explicitly references arguments, builds a single derived function and relies on operators and trains to control the flow of arguments. While purely tacit programming is best used only for recreational confusion, everyone uses derived functions. Max demonstrates common idioms that he uses – split, inspect, read, write, and select. He explains how they're useful to him, and summarises the tools and resources that help him to write tacit code.