IdeaWell

Project ideas from Hacker News discussions.

Show HN: Rust but Lisp

Original Article

Hacker News Discussion

📝 Discussion Summary (Click to expand)

3 PrevalentThemes in the Discussion

Theme Summary Representative Quotations
1. Skepticism about the project’s novelty & LLM origins Many commenters dismiss the post as “vibe‑coded slop” that rode the HN front page thanks to an LLM hype boost, rather than offering a genuine breakthrough. > "I don't even feel bad saying this because clearly OP is just the front for Claude here." — slopinthebag
> "Anyone and their mother can vibecode something like this in eight hours." — fao_
2. Interest in a Rust‑flavoured Lisp syntax Several users see value in an s‑expression front‑end that maps directly to Rust, highlighting the appeal of “Rust semantics with LISP syntax” and noting that it isn’t a full Scheme replacement but an alternative way to write Rust. > "Rust semantics with LISP syntax. A transparent s‑expression frontend that compiles directly to Rust — no runtime, no GC." — noosphr
> "this is not a replacement for scheme, it's simply an alternative syntax for rust." — zem
3. Technical hopes & concerns (errors, lifetimes, LSP, macros) The conversation pivots to practical questions: can error messages be mapped back to source s‑expressions? How will lifetimes and turbofish syntax be handled? Can the language coexist with Rust macros and IDE support? > "I'm adding error messages + spans ala ariadne now." — thatxliner
> "If you already have the ability to express the grammar productions in Rust … you have the ability to express lifetimes and the turbofish." — kibwen

These three themes capture the main sentiment: doubt about the project’s merit, curiosity about a Rust‑centric Lisp syntax, and a focus on the concrete engineering challenges that remain.

🚀 Project Ideas

Generating project ideas…

MacroBridge

Summary

  • Provides a hygienic Rust macro DSL written in S‑expr syntax, eliminating the need for LLM‑generated macro replacements.
  • Lets Lisp programmers write compile‑time metaprogramming with full Rust semantics and integrated testing support.

Details| Key | Value |

|-----|-------| | Target Audience | Rust developers seeking expressive macros and Lisp users wanting familiar syntax | | Core Feature | S‑expr macro compiler that emits Rust proc‑macros with hygiene and test hooks | | Tech Stack | Rust (proc‑macro crate), LALRPOP, serde | | Difficulty | Medium | | Monetization | Hobby |

Notes

  • HN commenters asked “To get proper macros.” and “Why would you vibecode a poorer replacement.”
  • Could spark discussion on macro hygiene and open a path for Lisp‑style metaprogramming in Rust ecosystems.

ErrorSpanKit

Summary

  • Adds span‑aware diagnostics and auto‑suggested fixes for S‑expr → Rust transpilation errors.
  • Integrates with rust‑analyzer to deliver IDE‑level feedback without leaving the Lisp workflow.

Details| Key | Value |

|-----|-------| | Target Audience | Users of S‑expr‑to‑Rust transpilers and hobbyist Rust learners | | Core Feature | Error formatter that maps compiler messages back to original S‑expr positions and offers fixes | | Tech Stack | Rust, syn, tracing, eframe UI | | Difficulty | High | | Monetization | Revenue-ready: Freemium |

Notes

  • Directly answers “will it show me nice error message?” concerns from the discussion.
  • Potential for a useful CLI/GUI combo that could become a paid plugin for richer IDE integration.

OwnershipLisp

Summary

  • A minimal Lisp interpreter that enforces Rust‑style ownership and borrowing rules at evaluation time.
  • Performs compile‑time lifetime and borrowing checks, turning Lisp code into safe Rust behind the scenes.

Details

Key Value
Target Audience Lispers curious about Rust ownership and educators teaching ownership concepts
Core Feature Ownership checker that validates moves/borrows on S‑expr trees before Rust code generation
Tech Stack Rust, tree‑sitter, Wasm sandbox
Difficulty Medium
Monetization Hobby

Notes

  • Addresses “How does ownership work within the Lisp tree structure?” and the ARC vs. ownership confusion raised in comments.
  • Could generate valuable discussion on blending Lisp’s macro power with Rust’s safety guarantees.

Read Later