# rhombus: a customizable language built as a Racket package set

> Rhombus is a general-purpose programming language whose entire implementation lives in this repository as a set of Racket packages, with a rhombus package you can install into any Racket or a bundled distribution, and an open design process run by the Racket team. It suits language experimenters and educators, and the cost is that a program is only as portable as the Racket installation carrying it.

**racket/rhombus** — Rhombus programming language

- Repository: https://github.com/racket/rhombus
- Website: https://rhombus-lang.org/
- Stars: 614 · Forks: 77
- Language: Racket
- License: NOASSERTION
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/racket-rhombus

## A language whose source is the whole repository

Rhombus is described as a general-purpose programming language that is easy to use and uniquely customizable. The unusual thing about this repository is what it contains. It houses the Racket packages that make up the current Rhombus implementation, so the language you read about is the language source, not a wrapper around one.

That choice has consequences in both directions. Reading the implementation means reading Racket packages, which are a form of code where a module's bindings are ordinary values and the whole system is built on macros and phase separation. A reader comfortable with Racket gets a clear picture of how the compiler front end, the expander and the runtime fit together. A reader who has not written Racket is looking at a language with a lot of metaprogramming in the middle of the stack, and the topics on the repository confirm the emphasis, listing language, metaprogramming, racket and rhombus.

The design goals are documented separately from the implementation. The README points to the Rhombus Goals page, to the documentation as rendered by the Racket package build service, and to an OOPSLA 2023 paper with a DOI and a talk video. That is a well-organised project by any standard, and the fact that the goals live outside the repository tells you the language is a research and design effort rather than a product with a backlog.

The homepage is rhombus-lang.org, the default branch is master, the repository is not archived, and the last push was on 2026-10-20. There are no GitHub releases, which is consistent with a language distributed as Racket packages rather than as versioned binaries.

The licence is recorded as a custom one that the platform cannot classify, with the terms in the LICENSE file at the repository root.

## Two ways to get it, and what the packages mean

There are two install paths, and the documentation explains the difference between the package sets.

The first is a Rhombus distribution, which the download page describes as a Racket distribution bundled with Rhombus packages. The second is to start with an ordinary Racket installation and add the language as a package, either through the Install Package item in DrRacket or on the command line:

```
raco pkg install rhombus
```

The distinction between the packages matters and is easy to miss. More precisely, the documentation says, the rhombus-main package has everything that is included in a Rhombus distribution, but rhombus provides the basics. So the package named rhombus is the small one, and rhombus-main is the complete set.

That structure is visible in the repository itself, where the top level is a long list of package directories. The naming is systematic. Each library tends to come in a pair, a rhombus-something package and a rhombus-something-lib package, for example rhombus-json and rhombus-json-lib, rhombus-html and rhombus-html-lib, rhombus-xml and rhombus-xml-lib, rhombus-http and rhombus-http-lib. There are also compound packages where a feature spans several, such as rhombus-html-page with rhombus-html-page-lib alongside rhombus-html, and rhombus-main with rhombus-main-distribution and rhombus-main-distribution-lib.

The standard library is broad. There is rhombus-csv, rhombus-draw, rhombus-pict, rhombus-json, rhombus-xml, rhombus-url, rhombus-http, rhombus-ssl, rhombus-net-cookie, rhombus-parser, rhombus-icons, rhombus-scribble, rhombus-slideshow, rhombus-gui and rhombus-ffi for foreign function interface work. There is a rhombus-exe package, which is presumably how the standalone executable is built, and a no-ffi directory, which suggests an alternative build path that avoids the foreign function interface entirely.

There is also a demo.rhm and a gui_demo.rhm at the root, which is the Racket module extension for Rhombus source, and a distro/ directory for packaging.

## enforest and shrubbery, the two pieces you cannot ignore

Two directory names in the repository tell you more about the implementation than any amount of prose would.

enforest/ and enforest-lib/ are the parser and the expander. Enforest is the parsing and expansion machinery that Rhombus uses, and having it as a separate package with its own library is a design decision in itself, because it means the front end is separable from the rest of the language and can be worked on independently of the runtime.

shrubbery/ and shrubbery-render/ with shrubbery-render-lib/ is the other one. Shrubbery is the source of Rhombus's surface syntax, and it is a separate language in its own right, with a rendering stage that turns shrubbery syntax into the language the expander actually sees. That is a two-language design: an author-friendly surface syntax and a core language underneath, with a rendering step between them.

This is where the metaprogramming topic tag earns its place, and it is the part of the project that will look alien to someone coming from a mainstream language. The surface syntax is not the language. There is a translation step, and that translation is where the language's extensibility lives.

The consequence for a user is that a Rhombus program is not directly a Racket program, and it is not obviously portable. The rhombus-exe package exists to produce a native executable, and the no-ffi directory suggests there is a second route for environments where the foreign function interface is a problem. Neither is explained in the visible README, so the practical question of how a Rhombus program ships to a machine without Racket is one the documentation available here does not answer.

## An open design process, run in the open

The Participation section is short and unusual in what it commits to. Anyone can participate in Rhombus design discussions, and the Racket team's unofficial motto is quoted as anything we can do, you can do, with the explanation that programmers should feel empowered to participate in the creation of the languages they use. Discussions, pull requests and issues are open to all, and a wide variety of perspectives is described as especially beneficial.

The mechanics are then sorted by the tool that suits the task. GitHub issues are for bug reports and feature ideas, pull requests are for bug-fix candidates and other concrete proposals, and GitHub discussions provide a forum for discussing Rhombus broadly as opposed to the details of specific proposals. That is a considered separation, and it is the kind of thing a language project gets right when it has been running a public process for a while rather than announcing a spec.

The community lives in the Racket Discord server, in the rhombus channel, and on the Racket Discourse forum.

For a reader, this is the most important thing about the project after the code itself. A language whose design process is open is one where you can see why a decision was made, and where a proposal that does not fit can be argued with. The same openness is why the source is in the repository. The two decisions are the same decision.

The one line in the README that shows the process is human rather than institutional is a typo in the Conversations as Discussion paragraph, which spells discusssing with three s characters. It is a small thing, but it is a reminder that the person doing the work is also the person writing the documentation.

## Where Rhombus is the wrong tool

The first case is production software that needs a boring, stable toolchain. A Rhombus program needs a Racket installation, and the language has no GitHub releases, so there is no versioned artifact to pin. For a service that has to run the same way in two years, a language with a tagged release and a large base of deployed code is the safer bet, and Rhombus is the opposite of that.

The second case is a team that does not want Racket underneath. Even if the surface syntax of Rhombus is pleasant, the implementation is Racket packages, the tooling is the Racket package system, and the documentation is served by the Racket package build service. Anyone maintaining the system needs some Racket fluency, and the documentation for Rhombus assumes it.

The third case is a project that needs the ecosystem rather than the language. A language with a beautiful syntax and a small standard library is a poor bet when the deciding factor is which database driver, which HTTP client and which deployment story are available. Rhombus's package list is broad for a young language, with csv, json, xml, http, ssl, net-cookie, draw, pict, gui and ffi all present, but each of those is an area where a mainstream language has years of accumulated tooling behind it.

The alternative worth comparing is not another new language, it is using Racket itself, or another established language, and spending the effort on your problem rather than on the language. Racket gives you the same metaprogramming power that Rhombus is built to expose more cleanly, and it has a release cadence, a package index and a community. The genuine argument for Rhombus is not that it does things Racket cannot, it is that it makes a particular set of things easier to express, and the OOPSLA paper is where that argument is made properly. Read it before deciding.

## Conclusion

rhombus fits a language experimenter, an educator looking for a small language with a visible design process, or a Racket programmer who wants to see how a new language is layered on top of an existing one, because the whole implementation is readable Racket packages rather than a binary distribution. It is the wrong choice for a production service that needs a stable, widely deployed toolchain, and it is the wrong choice for a team that does not want Racket as a dependency. Before evaluating it, install the rhombus package and work through the Quick Start, read the OOPSLA paper for the design rationale, and check the licence file yourself, since the licence is a custom one that the platform cannot classify.

## FAQ

### How do I install the Rhombus programming language?

You can download a Rhombus distribution, which is a Racket distribution bundled with Rhombus packages, or install the rhombus package into an existing Racket with DrRacket's Install Package item or by running raco pkg install rhombus on the command line.

### What is the difference between the rhombus and rhombus-main packages?

The rhombus-main package has everything that is included in a Rhombus distribution, while the rhombus package provides the basics. The repository top level is a long list of such packages, each with a matching -lib variant for the library layer.

### What are enforest and shrubbery in the Rhombus source tree?

Both are separate packages in the repository, and their presence shows the implementation is split into layers. Enforest is the parsing and expansion machinery, and shrubbery with shrubbery-render is the surface syntax and the stage that renders it into the language the expander sees.

### How do I participate in Rhombus design discussions?

Anyone can participate, and the Racket team motto quoted in the README is that anything we can do, you can do. GitHub issues are for bug reports and feature ideas, pull requests for concrete proposals, and GitHub discussions for broader design conversations, with community on the Racket Discord rhombus channel and the Racket Discourse forum.

### What licence is the Rhombus implementation released under?

The licence is a custom one that the platform cannot classify, with the terms in the LICENSE file at the repository root. The repository is not archived and the last push was on 2026-10-20, and there are no GitHub releases because the language ships as Racket packages.

## Sources

- [Issues](https://github.com/racket/rhombus/issues)
- [Project website](https://rhombus-lang.org/)
- [racket/rhombus on GitHub](https://github.com/racket/rhombus)
- [README](https://github.com/racket/rhombus/blob/master/README.md)

---

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