# Passerine: a small functional language running on a Rust VM

> Passerine is an experimental functional language with pattern matching, structural types and fiber concurrency, implemented as a virtual machine in Rust, and the README states plainly that it is not ready for production use.

**vrtbl/passerine** — A small extensible programming language designed for concise expression with little code.

- Repository: https://github.com/vrtbl/passerine
- Website: https://passerine.io
- Stars: 1,092 · Forks: 39
- Language: Rust
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/vrtbl-passerine

## What Passerine is and who started it

Passerine is described in the README as a small, concise, extensible functional scripting language powered by a virtual machine written in Rust. The language has roots in Scheme and ML, and the design centre is lambda calculus with pattern matching, structural types, fiber based concurrency and syntactic extension.

That combination tells you what kind of language it is. Pattern matching over structures, structural types rather than nominal ones, fibers for concurrency and an extension mechanism for syntax all point to a language in the Lisp and ML family, with the emphasis on writing a lot of behaviour in a small amount of source.

The project started at the end of 2019, when Isaac Clayton began it, and in August of 2022 he handed over the maintenance of the language and its community to Ben Siraphob. The README carries a long list of contributors who offered feedback and suggestions over the years, and one of them, Shaw, develops MiniVM, a portable cross platform runtime whose eventual goal is to replace the current Passerine virtual machine.

The crate is published on crates.io as passerine, the documentation is on docs.rs, and the homepage is passerine.io. The syntax overview has been moved off the README to a separate site, the Passerine Codex.

## The Rust workspace and what each crate does

The repository is a Cargo workspace with four active members and one that is switched off:

```toml
[workspace]

members = [
    "passerine-common",
    "passerine-derive",
    "passerine",
    "passerine-aspen",
    # "passerine-qualm",
]
```

The naming is not documented in the visible part of the repository, so the roles have to be read from the directory layout. passerine is the package published to crates.io, passerine-common is shared code, passerine-derive is the procedural macro crate, which fits a language with syntactic extension since extensions usually need to generate code, and passerine-aspen is a separate front end. passerine-qualm is commented out of the member list, which means it is present in the tree but not part of the build, and the topics on the repository include macros, interpreter, compiler and vm.

The practical consequence of a workspace layout like this is that the language implementation is split into a front end, a shared layer and a backend, which is the arrangement you need if the goal is to swap the virtual machine out later.

## Types today, and the type checker planned for the next release

The FAQ in the README is where the project is most honest about its state. On whether Passerine is statically typed, the answer is that it is currently strongly and dynamically typed, technically structurally typed, and the answer explains that this is partly out of necessity because types are defined by patterns and patterns can be predicated.

The plan is a compile time type checker based on Hindley-Milner inference. The author says the checker is the target of the next release, and that with it in place the interpreter can assume more about the types, go faster, and possibly monomorphise or generate LLVM IR or WASM.

That last sentence is the interesting part, because it ties three separate things together: the type checker, the performance work, and the move away from the current virtual machine. Without a static type checker the interpreter has to check types at runtime on every operation, which is a fair description of why an interpreter for a dynamically typed language is slow.

Two further features are named as wanted but deliberately deferred. Algebraic effects would fill the design space that fibers currently occupy, and kind based macros would give the macro system a firmer base. Both are listed behind the type checker in priority, and the README asks readers to suggest features that would suit the design philosophy.

## Vaporization memory management and its three invariants

The longest part of the FAQ describes vaporization, the memory management model the author designed for Passerine. The name is unusual and the idea is worth reading carefully, because it is a claim about how little a compiler has to do.

The model allows functional but in place programming, and it rests on three invariants. First, all function parameters are passed by value via a copy-on-write reference, so only the lifetimes of returned objects need preserving and everything else is deleted when it goes out of scope. Second, a form of SSA is performed, where the last usage of a value is not a copy of that value. Third, all closure references are immutable copies of a value, and those copies may be reference counted in an acyclic manner.

Given those invariants, the README claims two results. Values are alive only where they are still useful, and code can be written in a functional style while all mutation happens in place under the second rule.

What makes the design interesting for a virtual machine is the amount of compiler involvement. The README says the compiler only has to annotate the last usage of the value of a variable, and the rest can be handled at runtime efficiently.

The catch is stated just as plainly. The third invariant, immutable closure references, is not what the language does today. Passerine is pass by value, but it currently allows mutation in the current scope in the style of a let-style redefinition, and the author says that once that changes, the model applies in full.

## The VM roadmap: MiniVM Assembly and LLVM IR

The repository topics list the project as a compiler, an interpreter, a macro system and a virtual machine, and the stated direction is to move away from the current VM.

The target named in the README is MiniVM Assembly, VASM, developed by the contributor Shaw, described as a portable cross platform runtime. After VASM, the stated next step is LLVM IR as a first class compiler target. The author's framing is that Passerine is largely a test of whether a modern compiler pipeline can be built, and that the interesting part is the tooling around development environments rather than the language features themselves.

That claim shapes how to read the project. The README positions it against text based editing, arguing that the number of semantically correct programs is far smaller than the number of possible text files, and names Pharo and Unison as the direction it wants to see, an editor and environment built around a small language rather than around a text buffer. A language project that measures its own success partly in terms of editing environments is a different kind of project from a library you would depend on.

It also explains the long gap in the release history. The most recent tagged releases are v0.9.1 on 2021-03-30, v0.9.2 on 2021-04-02 and v0.9.3 on 2021-10-21, while the last push to the repository was on 2026-04-22. There is work in the tree that has not been cut into a release.

## Getting the language and running it

The README is blunt about the installation story. It opens the installation section by saying Passerine is still very much a work in progress, and the section is not finished in the text the repository presents. The project states where to get the code: the crate is on crates.io as passerine, the API documentation is generated on docs.rs, and the syntax overview lives on the Passerine Codex site.

Two practical notes follow from that. First, the crates.io version and the repository can be out of step, so a project that wants the current tree should build the workspace from a checkout rather than trust the published crate. Second, the example the README offers is a rendered image, Example.svg, rather than a code block you can paste, which is a hint about how much of the language is documented by example rather than by text.

The overview itself has also moved to a separate site, and the README warns that Passerine is a work in progress where features mentioned may be unimplemented or subject to change. Reading the Codex before writing code is the only reliable approach the project offers.

## Where Passerine is the wrong tool

The FAQ answers the production question directly. Passerine is not ready for production use, it is in early stages of development, and it has frequent breaking changes. That is the author's own assessment rather than an inference, and it rules out the language for anything where a surprise release would be a service incident.

The second limitation is the size of the investment. The type checker that would make the language credible for larger programs is described as a future release, so today you get a dynamically typed language whose performance depends on a runtime type checker and a memory model that is not yet in force. A project that cares about the performance or the type safety of a compiled language is paying for neither yet.

The third limitation is the maintenance situation. The original author handed the project over in 2022, the last tagged release is from 2021, and the repository has not seen a release in the years since even though commits continued into 2026. For a language, the release cadence is the ecosystem: without a new release, the crates.io version, the documentation and the compiler do not move together.

The honest alternative for most people is a Scheme or ML family language that already has a type checker, a package manager and a community, and to read Passerine for what it offers as a pipeline and environment design exercise. If you want to work on a compiler and on the tooling around a small language, the repository is a legitimate place to spend time.

## Conclusion

Passerine is worth reading as a compiler pipeline experiment and worth running if you build language tooling, not worth shipping a service on. Check the crates.io version against the repository state first, since the most recent tagged release is v0.9.3 from 2021 while the last push to the repository was on 2026-04-22.

## FAQ

### Is Passerine ready for production use?

No. The README states that Passerine is still in early stages of development, with frequent breaking changes, and that features mentioned in the overview may be unimplemented or subject to change.

### Is Passerine statically typed?

Not currently. The README describes it as strongly and dynamically typed and technically structurally typed, and says the plan is a compile time type checker based on Hindley-Milner inference, which is the target of the next release.

### What is vaporization in Passerine?

It is the proposed automatic memory management model. It rests on three invariants, copy-on-write by value parameters, a form of SSA for last usage, and immutable acyclic closure references, and it would allow functional style code with in place mutation. The README notes the third invariant does not hold in the language today.

### What is the Passerine virtual machine written in and what is it planned to be replaced with?

The current VM is written in Rust. The README names MiniVM Assembly, VASM, as the intended replacement, with LLVM IR as a later first class target, and describes the project as a test of building a modern compiler pipeline.

## Sources

- [License: MIT](https://github.com/vrtbl/passerine/blob/master/LICENSE)
- [Project website](https://passerine.io)
- [README](https://github.com/vrtbl/passerine/blob/master/README.md)
- [Releases](https://github.com/vrtbl/passerine/releases)
- [vrtbl/passerine on GitHub](https://github.com/vrtbl/passerine)

---

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