# Lamdu: a live, projectional Haskell programming environment

> Lamdu is an experimental Haskell IDE built around projectional editing, immediate evaluation, and structurally navigable code. It suits programmers interested in nontraditional editing models, but its sparse build guidance and old release history require careful evaluation.

**lamdu/lamdu** — lamdu - towards the next generation IDE

- Repository: https://github.com/lamdu/lamdu
- Website: https://www.lamdu.org
- Stars: 1,894 · Forks: 77
- Language: Haskell
- License: GPL-3.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/lamdu-lamdu

## Lamdu's live programming model and intended users

Lamdu addresses programmers who want editing, evaluation, navigation, and program storage to operate as parts of one environment rather than as separate tasks. Its README describes the project as a live programming environment, while its repository topics identify it as a projectional editor, structure editor, and WYSIWYG-style programming tool. The primary implementation language is Haskell.

The defining choice is that code is treated as structured program data, not as an ordinary stream of characters. Typing an operator can complete an expression, moving away from an argument can establish its boundary, and selecting a name can insert the syntax required for an application. The interface also displays evaluations as annotations beneath their expressions. This makes intermediate results visible while the user is still constructing the surrounding expression.

Lamdu is therefore most relevant to programmers who understand functional programming and are willing to learn editor-specific keys and structural navigation. It may also interest language designers experimenting with direct manipulation of syntax trees. The README does not position Lamdu as a replacement for conventional general-purpose editors in which file text and formatting remain the primary interface.

This is not a thin text editor with evaluation added as a side panel. The README presents calculation, definition, function construction, recursive calls, and navigation as one connected workflow. That focus creates a clear identity, but it also means familiarity with normal editor commands will not transfer completely. Contextual F1 help is important because the README says that the active key bindings change with the current interface context.

## Projectional editing, annotations, and saved evaluations

At the top of the Lamdu interface, an interactive shell uses the `⋙` prompt. The README compares it to a calculator: an expression is entered, evaluated, and then replaced or cleared for the next calculation. This shell is part of the same persistent program environment as definitions rather than a separate terminal session.

Lamdu interprets input according to expected types. In the documented `1+s` example, typing `s` opens a menu containing suitable values or functions whose names contain that character. Continuing to type `sqrt` narrows the choices, and pressing space accepts the selected entry. Delimiters and parentheses are supplied by the editor. After selecting a whole expression and typing `/2`, Lamdu inserts the parentheses needed for division.

Evaluation is shown recursively. The README explains that an expression's annotation appears below the annotations of its children. For `(1 + sqrt 5) / 2`, the display includes results for the complete expression and for `(1 + sqrt 5)`, while smaller annotations may initially be shrunk. Selecting a child expression exposes its value at normal size. This direct association between syntax and result reduces the need to move between an editor and a separate output location.

Programs are stored continuously. After creating a calculated value, the user selects the `⋙` sign, presses return twice to name the definition, and enters `golden`. The README explicitly states that no separate save operation is required. This changes the meaning of persistence: the Lamdu program is the document, and its definitions remain available as part of that program.

Navigation is structural as well. In a recursive factorial example, arrows beneath an argument connect to the application's corresponding argument or related function applications. The user moves left and right among these nodes instead of scanning lines of conventional source text. The trade-off is a learning cost: structural position and contextual keys become essential interface knowledge.

## Building Lamdu and checking the source layout

Lamdu does not document a package-manager installation or a prebuilt binary in the README. It directs users to the platform-specific build instructions in `doc/Build.md` for building from source. Because the repository entry exists, that file is the correct first place to inspect for prerequisites and commands. The README does not reproduce those instructions, so this review does not supply an invented installation command or assume a package manager.

The repository layout confirms that this is a source project rather than a small single-file application. Haskell-specific files include `Setup.hs`, `package.yaml`, `stack.yaml`, and `runghc`, while `flake.nix` and `flake.lock` provide Nix-related build definitions. There are also directories for source code, documentation, tests, data, tools, and continuous-integration configuration.

Before attempting a first build, a prospective user should follow `doc/Build.md` for the selected operating system and check that its dependencies match the repository state. The README does not list supported versions of GHC, Cabal, Stack, or Nix, nor does it describe build outputs or an application launch command. Those omissions matter because platform setup is not interchangeable across projects.

The first real use can begin in the interactive shell described by the README. At `⋙`, enter this exact expression:

```text
1+s
```

Continue with `sqrt`, use the displayed menu and space key to accept it, and enter `5`. The result is `(1 + sqrt 5) / 2` after the expression is divided by 2. The interface should show annotations for the complete calculation and relevant subexpressions. This exercise verifies both structural input and immediate evaluation without requiring creation of a named source file.

## Defining and invoking a function in Lamdu

The README's function tutorial demonstrates Lamdu's automatic construction of syntax. At the `New...` button, the tutorial asks the user to enter:

```text
factorial x=
```

Lamdu adds spacing, recognizes `x` as a function parameter, and supplies the definition structure. The equals sign need not be typed. The documented body is built from the following pieces, with tab used to move between structural positions:

```text
if x=0
```

The tutorial then enters `1` for one branch and `x*fac (x-1)` for the recursive branch. The `|` marker represents a suspended computation, and the active conditional branch receives a visual highlight. Recursive applications can be visited through the arrows beneath the `x` parameter.

There is a concrete naming inconsistency in this tutorial. The definition is introduced as `factorial x=`, but the call is shown as `fac 5`. The README does not explain whether `factorial` creates or references a shorter name, whether one side contains a typo, or whether some earlier interface action renamed the definition. A new user should not assume that this exact call is valid without checking the displayed definition name.

The intended exercise is to open a REPL from `New...`, press space, move into its body, enter the documented call, and press space:

```text
fac 5
```

The interface should display the evaluation of the function and its subexpressions. Before relying on the example, reconcile the name mismatch by confirming which identifier is actually bound. This is a small documentation defect, but it affects the first recursive workflow and can send a new user looking for a missing definition rather than teaching the structural navigation model.

## GPL-3.0, release age, and Lamdu's maintenance boundary

Lamdu is licensed under GPL-3.0. That identifier is the relevant project fact for license review, but this article does not interpret legal obligations. Distribution, modification, linking, and internal deployment scenarios can have different GPL implications, so users needing a compliance decision must evaluate the actual distribution model separately.

The repository is not archived, and its last push was on 2026-09-25. That indicates recent repository activity, but it does not by itself establish a regular release process. The latest listed release is `v0.8.1`, dated 2022-05-25. Earlier releases include `v0.8.0` from 2021-09-05 and `v0.7.1` from 2018-11-19.

The gap between repository pushes and published releases is an important adoption constraint. A recent commit can update documentation, code, build files, or dependencies without producing a new packaged IDE release. The repository description does not identify a rolling-release policy, stable branch, compatibility matrix, or migration guide.

Upgrade cost also depends on how a team runs Lamdu. The presence of `stack.yaml`, `package.yaml`, Nix files, tests, and platform build documentation suggests several possible build paths, but the README does not state which path is preferred or whether old projects migrate cleanly between versions. It also does not document rollback or compatibility between `v0.7.1`, `v0.8.0`, and `v0.8.1`.

For an individual experimenting with Lamdu, the source build and old release history may be acceptable. For a team standardizing on it, the absence of a documented upgrade contract is more serious than the age of the latest tag alone.

## How Lamdu differs from conventional editor plus REPL workflows

The closest practical alternative is a conventional text editor paired with a Haskell REPL or separate evaluation tool. That approach leaves source code as text, while the programmer submits expressions independently and reads output in another interface. Formatting, delimiters, function application syntax, and navigation remain manual or delegated to language tooling.

Lamdu instead stores and edits structured expressions. Its shell, definitions, functions, annotations, and navigation belong to the same environment. The editor can infer parameter roles, complete type-appropriate names, insert parentheses, and connect recursive applications visually. Program state is saved without an explicit save step.

This approach can fit exploratory and functional programming, where small calculations lead into named values and recursive definitions. It creates friction for users who need plain-text compatibility, conventional line-oriented workflows, or predictable character-level editing. The README does not document interoperability with external `.hs` files, so it is not possible to confirm that Lamdu projects can be moved directly into another editor.

Lamdu is also the wrong choice when immediate evaluation is optional rather than central. If the priority is stable releases, documented package installation, migration policy, or a conventional source representation, the repository gives fewer reasons to select it. Its distinguishing value lies in making structure, evaluation, and navigation part of one interactive document, not simply offering Haskell syntax highlighting.

## Conclusion

Programmers who want to evaluate code while editing a persistent, structure-oriented program should examine Lamdu. Conventional text-editor users or teams needing a clearly documented release and migration path should look elsewhere first. Before adoption, verify that the current repository builds on the intended platform, resolve the `factorial` and `fac` naming discrepancy in the tutorial, and confirm that GPL-3.0 obligations fit the intended distribution model.

## FAQ

### How do I install and build Lamdu?

The README directs users to the platform-specific instructions in `doc/Build.md` and does not provide a universal installation command there. The repository includes Haskell build files and Nix definitions, but the README does not identify a preferred build path.

### Does Lamdu support immediate evaluation while editing code?

Yes. Lamdu displays expression and subexpression results as annotations, and its interactive shell evaluates calculator-like expressions while the program remains continuously saved.

### What makes Lamdu different from a conventional Haskell editor?

Lamdu uses projectional editing, type-appropriate completion, automatic syntax insertion, persistent program structures, and structural navigation among expressions and recursive applications. Evaluations appear directly with the expressions instead of only in a separate terminal view.

## Sources

- [lamdu/lamdu on GitHub](https://github.com/lamdu/lamdu)
- [License: GPL-3.0](https://github.com/lamdu/lamdu/blob/main/LICENSE)
- [Project website](https://www.lamdu.org)
- [README](https://github.com/lamdu/lamdu/blob/main/README.md)
- [Releases](https://github.com/lamdu/lamdu/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/lamdu-lamdu