A New Language Where Everything is a Value

A developer has shared a personal programming language project designed around the concept that everything is a value. The implementation represents a multi-year exploration into how programming languages are built and executed.

What began as a learning exercise evolved into a unique system with its own architecture. The project demonstrates how modern tools like Rust and Cranelift can be combined to create a functional language from the ground up.

The language emerged from a desire to understand programming language implementation at a fundamental level. The developer started the project several years ago as a personal challenge to move beyond theoretical knowledge and into practical construction.

Initially, the work drew inspiration from Crafting Interpreters, a well-regarded resource for language creators. However, the implementation gradually diverged from that starting point, developing its own identity and structure.

Key aspects of the project's development include:

• Started as a hobby learning project
• Evolved independently from initial references
• Focus on value-based architecture
• Multi-year development timeline

The language is built on a modern tech stack that leverages contemporary systems programming tools. Rust serves as the foundation, providing memory safety and performance characteristics suitable for a language implementation.

For execution, the project employs Cranelift, a code generation library designed for JIT compilation. This allows the language to generate machine code dynamically at runtime, balancing flexibility with performance.

The parsing system uses LALRPOP, a parser generator that processes language grammars into efficient parsing code. This combination creates a pipeline from source code to executable output.

"It was created 95% without AI, although a few recent commits include code from Gemini CLI."

The project maintains a human-centric development approach, with the vast majority of code written without artificial intelligence assistance. This philosophy reflects a commitment to understanding the underlying mechanics of language design.

Recent updates have incorporated AI-assisted code from Gemini CLI, representing a pragmatic shift toward using available tools. The integration appears selective, focusing on specific commits rather than wholesale adoption of AI-generated code.

This hybrid approach demonstrates how modern developers can balance traditional learning methods with contemporary AI tools. The project remains primarily a human creation while selectively benefiting from AI assistance where appropriate.

The project was shared on Y Combinator's news platform, where it received attention from the programming community. The post generated 6 points and opened a channel for discussion about language design.

The sharing of hobby projects like this contributes to the broader conversation about programming language theory and practice. It provides a concrete example of how abstract concepts in language design can be implemented in practice.

Community engagement around such projects helps validate design choices and can inspire others to explore their own language implementations. The technical details shared offer a roadmap for similar learning journeys.

This hobby project illustrates how personal curiosity can drive technical innovation. By building a language from scratch, the developer has gained deep insights into the mechanics that power modern software.

The project's evolution from learning exercise to functional system shows the value of hands-on experimentation in mastering complex technical domains. It serves as both a personal achievement and a potential resource for others interested in language design.

As the language continues to develop, it may offer new perspectives on how programming languages can be structured and implemented using contemporary tools and techniques.