forge

terminal
code ide
documentation generated for custom language

Inspiration

Most ideas don’t fit neatly into existing languages. We wanted a way to invent a new programming language per problem, with the right primitives baked in, from portfolio rebalancing ops to AST surgery, without drowning in boilerplate. Forge turns natural language into a real, first-class interpreted language.

What it does

Forge synthesizes a new language from a short natural language brief and gives you:

Documentation, clean pretty-printed docs with:
- Grammar and operator precedence
- “Hello, world” + domain-specific examples
- Lint rules and capability notes
Personal Sandbox, a dark-mode terminal to:
- Run programs
- Inspect traces

How we built it

We built a custom pipeline: Intent → Specification: A short description is converted into a structured language spec. Specification → Parser: We synthesize grammar + precedence tables and generate a parser. Parser → Interpreter: The spec becomes a typed core language executed by our VM. Docs + Sandbox: We auto-generate documentation and spin up an REPL with tracing and safe execution.

Challenges we ran into

One of the hardest parts was getting the parsers to work correctly. The lack of smooth interoperability between the host language (doing the generation) and the target language (being generated) made the process tricky and error-prone.

Accomplishments that we're proud of

We built a deterministic parser generator that reliably produces fast, correct, and fully working parsers every time. It automatically handles grammar normalization, conflict resolution, and precedence, so once a spec is written, the generated parser “just works.” This was a major breakthrough for us, since getting the parser pipeline stable and reproducible was one of the toughest parts of the project. Since this entire project hinged on the parser, we weren't fully confident that such a parser could be created in such a short time, so this breakthrough really accelerated our productivity and boosted our morale.

What we learned

Lead with the IR: once the intermediate representation is clear, everything else, parsing, type checking, documentation, and regeneration, becomes simpler.