HN Debrief

Rhombus Language 1.0

  • Programming
  • Developer Tools
  • Open Source

The post announces Rhombus 1.0, a language built on Racket that aims to combine familiar surface syntax with Racket’s unusually powerful macro system and open compiler hooks. Under the hood it still lives in the Racket ecosystem, so the interesting claim is not “yet another general-purpose language” so much as “can you make a macro-extensible language feel approachable to people who bounce off s-expressions.” That framing landed. People kept coming back to two concrete things: Rhombus’s syntax layer, called Shrubbery, and the fact that macros are still first-class enough to define operators and context-sensitive forms that would be baked into the compiler in most languages. One example that got attention was the `…` repetition operator, which commenters described as a macro rather than a primitive and as powerful enough to traverse nested structures and replace some `map` patterns.

If you care about language design, DSLs, or metaprogramming, Rhombus is worth watching as a test of whether Lisp-grade extensibility can survive contact with mainstream syntax. If you care about shipping apps today, the key question is still tooling, packaging, and ecosystem depth, not whether the macro system is clever.

Discussion mood

Curious and mostly positive, with a big caveat: people respected the language-design ambition and the macro system, but many were unconvinced by the announcement’s pitch and unsure Rhombus is ready to compete on tooling, ecosystem, or everyday production ergonomics.

Key insights

  1. 01

    The standout feature is contextual macros

    Rhombus’s most interesting trick is not the indentation syntax. It is that operators like `…` can be implemented as macros that behave differently depending on where they appear, including binding positions versus expression positions. That pushes more of the language surface into user-extensible space than most languages allow, while still looking like ordinary syntax instead of a pile of compiler intrinsics.

    If you evaluate Rhombus, inspect the macro model before the syntax. The real differentiator is how much language design it hands to library authors without forcing them back into raw compiler work.

      Attribution:
    • ashton314 #1
    • mkl #1
  2. 02

    The launch post undersold the real pitch

    The weak spot was not the language but the framing. Readers wanted the introduction to lead immediately with debuggable, powerful macros on top of conventional syntax, because words like “approachable” and “extensible” are too vague to carry a language launch. The follow-up pointing to the Racket stepper and `syntax-parse` matters because it hints that the surrounding tooling story for macro development is more mature than the announcement made obvious.

    For language launches, lead with one concrete capability and one concrete workflow. If your differentiator is metaprogramming, show how people build, inspect, and debug macros in practice.

      Attribution:
    • jerf #1
    • rscho #1
  3. 03

    Production questions still land in Racket territory

    The practical answers on distribution, libraries, typing, and editor support all reduced to “you can lean on Racket.” That is a strength because Rhombus inherits a real runtime and library base. It is also the limit, because the responses did not paint a polished standalone developer experience for teams choosing a language today.

    Treat Rhombus as an entry point into the Racket platform, not as an isolated greenfield ecosystem. The adoption decision is really whether your team wants Racket’s tradeoffs with a different syntax.

      Attribution:
    • bbkane #1
    • gus_massa #1
  4. 04

    Performance is respectable, not magical

    The performance story came through as disciplined engineering rather than hype. Commenters tied current speed to years of backend work targeting Chez Scheme, plus optimizations like flonum unboxing and type recovery, and still framed the result as roughly several times slower than C or Java. That puts Rhombus in the “fast enough for many things” bucket, not the “systems language challenger” bucket.

    Do not dismiss Rhombus as a toy on speed alone, but do not assume the syntax or macro system changes the usual dynamic-language economics. Benchmark the specific workload, especially if CPU cost drives your architecture.

      Attribution:
    • rscho #1
    • gus_massa #1 #2
  5. 05

    Shrubbery includes escape hatches for whitespace pain

    The indentation-sensitive syntax is not as rigid as it first appears. Shrubbery has guillemet-delimited regions that disable indentation sensitivity for a block, specifically to make copy-paste and movement less fragile. That does not make the design universally liked, but it shows the syntax layer was built with operational annoyances in mind instead of treating them as user error.

    If whitespace sensitivity is your main objection, look at the escape hatches before writing it off. The right question is whether the editor support around those escapes is good enough for real use.

      Attribution:
    • miffi #1
    • rscho #1

Against the grain

  1. 01

    Changing syntax may not win over skeptics

    The case against the whole project is simple. Some experienced developers do understand Lisp-family ideas and still dislike s-expressions on sight because the uniform notation makes code visually flatten out. If that reaction is real and persistent, Rhombus is not a mere polish pass on Racket. It is an admission that syntax alone can block adoption even when the semantics are good.

    If you build developer tools or languages, stop assuming syntax objections are shallow. Readability and visual parsing costs can outweigh deep semantic advantages for a lot of competent users.

      Attribution:
    • cptmurphy #1
    • bjoli #1
    • adastra22 #1 #2
  2. 02

    Whitespace syntax and middling speed narrow appeal

    Some readers were out immediately on indentation-sensitive scope, calling it awkward for moving code and fragile around formatting. Others added that a language pitching novelty but landing at a few times slower than C or Java does not get much slack if the ergonomics are also unfamiliar. That combination makes Rhombus a hard sell for engineers who optimize first for operational simplicity.

    Expect resistance from teams that already distrust whitespace syntax or care deeply about predictable deployment and performance. The macro story has to be strong enough to overcome both objections at once.

      Attribution:
    • ginko #1 #2
    • cmoski #1
    • poulpy123 #1

In plain english

Chez Scheme ↩
A high-performance implementation of the Scheme programming language that Racket can target as a backend.
DSL ↩
Domain-specific language, a small language or specialized syntax built for a particular problem area.
flonum ↩
A floating-point number representation used in Lisp-family systems, often optimized separately from other numeric types.
homoiconic ↩
Describes a language where code has the same basic structure as the language’s data, making programs easy to manipulate as data.
IDE ↩
Integrated Development Environment, a programming tool that combines an editor, debugger, and other developer features in one application.
macro ↩
A feature that lets programmers extend a language by transforming code before it runs or compiles.
Racket ↩
A programming language and language-building platform in the Lisp family, known for powerful macros and support for creating new languages.
s-expressions ↩
Short for symbolic expressions, the parenthesized tree-like notation used by Lisp languages for both code and data.
Shrubbery ↩
Rhombus’s indentation-sensitive surface syntax layer that is parsed before being expanded into deeper language forms.
type recovery ↩
A compiler optimization that infers more precise type information from code to improve generated performance.

Reference links

Rhombus and Racket documentation

Macro and tooling references

  • Matthew Flatt RacketCon 2023 talk
    Video explanation of how Rhombus approaches macros without s-expressions
  • Racket stepper
    Macro and execution inspection tooling mentioned in response to calls for better macro debuggability
  • Racket syntax-parse
    Reference for Racket’s macro system, cited as evidence that macro tooling is already mature

Performance and implementation

Background papers and essays

  • Type Tailoring paper
    Paper shared by a commenter who compared metaprogramming features across languages
  • Bicameral, not homoiconic
    Essay cited in a question about why more languages do not adopt a Rhombus-like intermediate syntax