Show HN: I built a minimal Forth-like stack interpreter library in C

You've implemented a stack calculator, which misses the big picture: the stack is an implementation detail that enables a lot of the nifty stuff, but Forth is a "braided language" - the whole is more than the sum of the parts. Each part of it is just implementation, and the implementation is kept simple, but all of it needs to be there to make it completely usable. The distinction is important and non-trivial to the design of the interpreter.

To get there, please implement some of the metaprogramming words found in one of the standardized Forths(and if you aren't sure which one, use an earlier spec like Forth83 since the core wordset is smaller, so you run into the "hard stuff" faster).

Forth used in anger towards an application actually tends to resemble Fortran: procedural idioms flinging around lots of named temporary variables. The stack, being just implementation, doesn't give any assistance for everyday programming, unless you extend the system to do so. This is a point on which modern concatenative languages have diverged and tried to add some rigor into it.

1. You should add a URL when you you create a post on HN. You can indent code two spaces on HN, eg:

  Stack s;
  stack_init(&s);
  dict_init();
  exec(&s, "10 20 + ."); // Prints "30"
  exec(&s, "1 2 3 4 .s"); // Shows stack contents

2. Your readme mentions a repl but I don't see it in the source code.

3. I'm not an expert in C but I thought header files shouldn't have code in them. The code should be in a .c file

4. Maybe move the code from USAGE into its own .c file.

  #include "stacklib.h"
  
  int main() {
    Stack s;
    stack_init(&s);
    dict_init();
    exec(&s, "10 20 + .");
    printf("\n");
    return 0;
  }

If you're interested in learning more about how FORTH works I, I can recommend two very old books.

Starting FORTH https://archive.org/details/LeoBrodieStartingFORTHIntroducti...

Threaded Interpretive Languages https://archive.org/details/R.G.LoeligerThreadedInterpretive...

The latter doesn't even mention FORTH, and describes some very archaic CPU architectures, but I found it fascinating because it builds things from the ground up.

Interesting. I am currently in the process of writing an interpreter for a similar stack based language. I already wrote a compiler for this language to x86 assembly that can be compiled to an ELF. The language is used as an intermediate language for a C compiler that I am writing. It is maybe less Forth-like than your language. For more information see: https://github.com/FransFaase/MES-replacement For the interpreter have a look at: stack_c_interpreter.c

At WHY2025, I gave a talk about the reasons why am working on this. See: https://www.youtube.com/watch?v=akzyyO5wvm0

Your experiment is certainly a good tool to grok stack mechanics, but that is only one element of what makes a Forth what it is. You're missing out on other crucial ingredients: colon definition and immediateness.

I wrote a series of articles that can help in that kind of discovery: http://tumbleforth.hardcoded.net/

Another thread on small forth interpreters from just 15 days ago:

https://news.ycombinator.com/item?id=45039301

Forth can be beautifully and efficiently implemented in portable c++ using the using continuation passing style via the clang musttail attribute.

Have a look at Tails (not my project):

[1] https://github.com/snej/tails