Show HN: Nibble

The creator of Nibble has released a new C-like systems programming language that demonstrates LLVM IR generation without relying on external dependencies or heap allocations, accompanied by graphical demos and system features.

Nibble is a systems programming language written in approximately 3,000 lines of C. It supports core features such as defer, recursion, various data types, structs, pointers, function pointers, branching, loops, and basic C interoperability. The language is designed to compile in a single top-down pass and allows allocas within loops, which simplifies code readability but can cause stack overflows under certain compiler optimizations.

Developed by its author as a demonstration of an approach to LLVM IR generation, Nibble operates independently of external dependencies, emphasizing minimalism and control. It includes four graphical demos, such as multithreaded shader renditions, a red-black tree implementation, and a basic game setup, all runnable with SDL2 and Clang installed. The build process involves compiling main.c with Clang to produce the Nibble compiler, which then compiles and runs the demos.

The creator notes that while the design simplifies front-end development, it encounters limitations with certain Clang back-end optimizations, particularly stack management, leading to potential stack overflows. The project is considered momentarily complete by its author, with some curiosity about exploring stack save/restore techniques in the future.

Why It Matters

This development matters because it showcases an experimental approach to systems programming language design focused on LLVM IR generation without external dependencies. It provides a minimal yet expressive environment for graphics, data structures, and system programming, potentially influencing future compiler design and educational tools. The project also highlights challenges in compiler optimization, especially regarding stack management, which are relevant for language designers and compiler developers.

Background

Nibble was created as a demonstration project to explore LLVM IR generation techniques within a minimal C-like language. Its development aligns with broader efforts in compiler research to reduce dependencies and improve control over code generation. The project’s graphical demos and system features reflect ongoing interest in combining low-level programming with visual and practical applications, echoing trends in graphics programming, embedded systems, and educational tools.

“I have been meaning to explore stacksave/stackrestore but my LLVM curiosity has more or less been satisfied, and I deem this compiler momentarily complete.”

— the creator of Nibble

What Remains Unclear

It is not yet clear whether the Nibble language will be further developed or adopted by others, or how it will perform under more complex or real-world workloads. The limitations with Clang’s back-end optimizations and potential stack overflow issues remain unresolved, and the long-term stability and usability of the language are still uncertain.

What’s Next

The author may explore stack management techniques like stacksave/stackrestore in future updates. There could also be efforts to improve the language’s robustness, add more features, or seek community feedback for broader adoption. Monitoring the project’s evolution and potential integration with other tools will be key.

Key Questions

What is Nibble?

Nibble is a C-like systems programming language designed to generate LLVM IR independently, supporting features like recursion, pointers, and graphical demos.

How can I try Nibble?

To run Nibble’s demos, install SDL2 and Clang, then compile main.c with Clang to produce the Nibble compiler, which can then compile and execute the demos.

What are the main features of Nibble?

Features include defer, recursion, various data types, structs, pointers, function pointers, branching, loops, and basic C interoperability, all designed for minimalism and control.

Are there any limitations or issues?

Yes, the language’s design can cause stack overflows under certain Clang optimizations due to allocas within loops, and its future development is uncertain.