# Computing with just one instruction alternatives

Computing with just one instruction: 16-bit SUBLEQ CPU running eForth - just for fun.

24 products that do a similar job, closest first. 4 have pricing checked on their own site; 4 of those are free or have a free tier.

Page: https://nowfound.app/alternatives/computing-with-just-one-instruction-forth-on-subleq
About Computing with just one instruction: https://nowfound.app/launch/computing-with-just-one-instruction-forth-on-subleq.md

- [Single-Instruction (Subleq) Programming Game](https://nowfound.app/launch/single-instruction-subleq-programming-game): Single-Instruction (Subleq) Programming Game is an educational game where players learn to program using only one instruction: subtract and branch if less than or equal to zero. (2023-07-30, 86 votes, jaredkrinke.itch.io)
- [H2 Forth CPU](https://nowfound.app/launch/h2-forth-cpu): A Forth CPU and System on a Chip, based on the J1, written in VHDL (2019-03-19, 120 votes, github.com)
- [I'm 17 and I created a Forth interpreter for](https://nowfound.app/launch/i-m-17-and-i-created-a-forth-interpreter-for-the-ti-84-calcu): This is a Forth interpreter written in Z80 assembly for the TI-84+ calculator. (2018-12-05, 56 votes)
- [PlanckForth](https://nowfound.app/launch/planckforth-bootstrapping-an-interpreter-from-handwritten-1k): Bootstrapping a Forth interpreter from hand-written tiny ELF binary. Just for fun. - GitHub - nineties/planckforth: Bootstrapping a Forth interpreter from hand-written tiny ELF binary. Just for fun. (2021-12-06, 132 votes, github.com)
- [A 16-bit Forth machine written in VHDL](https://nowfound.app/launch/a-16-bit-forth-machine-written-in-vhdl): Yet Another Forth Core... (2014-08-04, 80 votes, github.com)
- [forthy2](https://nowfound.app/launch/forthy2-a-higher-level-forth-remix-in-c): a Forth (for you) too. (2019-10-27, 65 votes, github.com)
- [A minimal Forth-like stack interpreter library in C](https://nowfound.app/launch/i-built-a-minimal-forth-like-stack-interpreter-library-in-c): Stacklib.h is a single-header C library that implements a minimal Forth-like stack interpreter. (2025-09-11, 47 votes)
- [A compiler for a small language into x86-64](https://nowfound.app/launch/a-compiler-for-a-small-language-into-x86-64-assembly): Compiler for a small language into x86-64 Assembly (2020-04-29, 74 votes, github.com)
- [Easy Forth](https://nowfound.app/launch/easy-forth): Easy Forth is a small ebook that teaches the Forth programming language, a stack-based language from the 1970s still used in specialized applications today. (2015-11-26, 122 votes, skilldrick.github.io)
- [Phorth](https://nowfound.app/launch/phorth-a-forth-like-language-on-the-python-vm): A small forth-like language that targets the CPython VM. (2017-01-20, 62 votes, github.com)
- [Subth.ink](https://nowfound.app/launch/subth-ink-write-something-and-see-how-many-others-wrote-the): Subth.ink is a website where users can submit text and discover how many other people have written the exact same thing. (2026-01-19, 92 votes, subth.ink)
- [Pipelex](https://nowfound.app/launch/pipelex-declarative-language-for-repeatable-ai-workflows): We’re Robin, Louis, and Thomas. Pipelex is a DSL and a Python runtime for repeatable AI workflows. Think Dockerfile/SQL for multi-step LLM pipelines: you declare steps and interfaces; any model/provi… (2025-10-28, 122 votes, free, github.com)
- [Going into freshman year, figured I should](https://nowfound.app/launch/going-into-freshman-year-figured-i-should-build-an-interpret): Crumb is a garbage-collected, dynamically typed functional programming language implemented in C. (2023-08-26, 138 votes)
- [Dependently typed language for proofs that you](https://nowfound.app/launch/dependently-typed-language-for-proofs-that-you-can-implement): The cuteness implementation of a dependently typed language. (2021-10-02, 138 votes, github.com)
- [A Forth-Based OS for the TI-84+ Calculator](https://nowfound.app/launch/i-made-a-forth-based-os-for-the-ti-84-calculator): The idea is to have a kernel + the Forth interpreter and compiler, then users can modify how their operating system works through the Forth files. (2019-01-15, 6 votes)
- [A work-in-progress C compiler from scratch](https://nowfound.app/launch/a-work-in-progress-c-compiler-from-scratch): Programming language that compiles into a x86 ELF executable. (2021-08-03, 159 votes, github.com)
- [TutoriaLLM](https://nowfound.app/launch/tutoriallm-ai-integrated-programming-tutorials): TutoriaLLM is a self-hosted application that integrates AI-powered tutorials into Blockly, a block-based code editor. (2024-11-07, 128 votes, free, github.com)
- [A Lispy, embedded Forth](https://nowfound.app/launch/a-lispy-embedded-forth): A Lispy is an embedded Forth interpreter designed for integration into other applications. (2017-02-01, 61 votes, github.com)
- [Maybe Haskell](https://nowfound.app/launch/maybe-haskell): See what it’s like to program in a language without null. (2015-07-27, 60 votes, books.thoughtbot.com)
- [Ternary Computer System](https://nowfound.app/launch/ternary-computer-system): The Ternary Computer System is an experimental CPU architecture using three logical states instead of traditional binary, designed to implement dataflow computing principles where instructions… (2024-12-09, 145 votes, ternary-computing.com)
- [A RISC-V core in Racket](https://nowfound.app/launch/a-risc-v-core-in-racket): This project is a RISC-V processor core implemented in Racket, a Lisp-based programming language. (2021-04-30, 122 votes, guillaume.baierouge.fr)
- [monkey-giggle](https://nowfound.app/launch/i-wrote-a-vm-and-compiler-for-a-small-language-in-go): My implementation of Thorsten Bell's book (Writing an Interpreter in Go) (2020-05-04, 37 votes, github.com)
- [R3forth](https://nowfound.app/launch/r3forth-a-colorforth-inspired-language-with-a-tiny-vm): r3 programing language - ColorForth inspired. (2026-02-06, 92 votes, free, github.com)
- [SHDL](https://nowfound.app/launch/shdl-a-minimal-hardware-description-language-built-from-logi): SHDL is a minimal hardware description language that removes abstractions and requires builders to construct digital circuits explicitly from logic gates and wires. (2026-01-28, 48 votes, free, github.com)
