AVavgcorrection·Jul 17, 2022
Author ended up doing a lot of work on Kitten https://github.com/evincarofautumn/kitten
In Why concatenative programming matters (2012)evincarofautumn
kitten
Haskell2012–2022
evincarofautumn / kitten
kitten
A statically typed concatenative systems programming language.
10Distinct people
25Mentions
0Explicit recommenders
1.2KGitHub stars
What to know before exploring
What it is
A statically typed concatenative systems programming language.
GitHub
Where it is used
No documented product use has been verified yet.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 5:04:57 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year25 dated mentions
Observed mentions: 2012-07-18 01:09:39 UTC to 2022-07-17 13:11:19 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2012 | 2012-01-01 00:00:00 UTC | 2013-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 8 | 1 | 7 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 7 | 0 | 7 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 1 | 0 | 1 |
What Hacker News says
25 sourcesLike all other languages voted to the HN front page that claim that they have magically solved memory management, this project's website is simply lying.
Looking at https://github.com/evincarofautumn/kitten/issues/193: "Does kitten require garbage collection?" -- "Nope. [...] The plan is that boxed lists ([…], List<T>) and closures ({…}) are reference-counted" and https://github.com/evincarofautumn/kitten/issues/131: "Explore GC strategies" -- "The C backend currently uses naïve reference counting."
A quick skim of kitten.c confirms that objects have a reference count field and are only really released when it drops to zero. (I didn't find code that increments the reference count, but I find it hard to care.)
The project's website claims:
> Automatic management of memory and resources with no garbage collector.
One can weakly argue that m
Read the rest
any people mean tracing garbage collection when they speak of garbage collection, and that reference counting is not garbage collection in this narrow sense. This is unhelpful at best.
The FAQ has the claim I quoted above, of which the "when you drop a value from the stack, it gets deallocated" appears to be simply false.
I should add that I'm aware that this project is incomplete, but that doesn't excuse making wildly implausible claims.
You're right, oh boy!
https://github.com/evincarofautumn/kitten/blob/master/common...
In The Kitten Programming LanguageInteresting idea! It looks like the Git repo doesn't get many updates, at least not on the master branch. Is it "dead", or is it "stable"?
Edit: it looks like as of 2018, the author was taking time off of working in tech (https://github.com/evincarofautumn/kitten/issues/201#issueco...). Maybe lack of activity means they got another job, or maybe they left the programming/tech world entirely.
In The Kitten Programming LanguageHmm, interesting.
I just had a slow look through http://kittenlang.org/intro/. In all honesty my stupid ADHD decided to conk out precisely at the Lambdas section, I'm not sure why. Up to that point, the only thing that I'd note is that "match (xs head)" is not described anywhere (on the page at all).
But I think it's interesting you posit Kitten as a systems language. Huh. (What's a "traditional" tokenizer?! Ah; I assume you mean "not pure Forth" as opposed to "buy APL keycaps here" (heh).)
I guess the only advice I can think of right now is, offer batteries included, and include the batteries you're most passionate about, because it'll mean the implementations are complete and well-tested. If that's web templating (random top-of-my-head thought), do that; if it's image processing, do that. It'll raise the chances the language becomes $th
Read the rest
ing-heavy because nobody contributes other code, but you can always stop advertising and spend time rounding things out if that happens.
I meant to install Kitten, but that didn't quite work this time around due to problems on my end. (First git was silently segfaulting due to inconsistently-upgraded shared libraries on my Slackware box, then I realized I needed Haskell and switched to Arch, then I was reminded that pacman doesn't really know how to resolve dependencies properly ("if you install something that needs the newest version of glibc, maybe I shouldn't need to have to upgrade glibc (and reverse-resolve its dependencies) myself?!"), then after half-installing Haskell I discovered (/) only had 19MB free, so now I have to go figure out what caused that... (I argue it's my 80KB/s ADSL2+ upload speed :P))
I'll definitely be looking at Kitten at some point though. Thanks for the reply!
EDIT: Got past the previous issues, now Haskell is sad. https://github.com/evincarofautumn/kitten/issues/206
> ";" operator is more fun. The only problem is that this operator actually doesn't work on stacks but arrays. Oops.
It's suppose to work on arrays. He's creating a concatenative array processing language.
> This is basically a more sane version of forks and hooks in J
> I want to create my own little concatenative array language
> I'm not a fan of APL/J style one-liners, I prefer simple expressions with lots of `where`.
> So I started to think about design of a sane array programming language. And I contunued to dream about it until meeting a real problem
> A concatenative array programming language... I'd rather start from something simple. Like `;` operation, that brings the power of forks and hooks in J into concatenative programming
https://github.com/evincarofautumn/kitten/issues/174
https://github.com/suhr/esobsc/commit/809241a726f
Read the rest
This is likely borrowed from Haskell where functions starting with special characters are treated as infix. Parens and backticks allow for switching between the conventions
add a b = a + b
-- these are all the same
3 + 4
(+) 3 4
add 3 4
3 `add` 4
The article might also make slightly more sense in context, I think it was in part an idea for how to make infix notation more useful in Kitten: https://github.com/evincarofautumn/kitten/issues/174
In A Simply Arited Concatenative LanguageThis is from his HN profile:
I’m writing a stack-based functional programming language called Kitten: https://github.com/evincarofautumn/kitten
In Do Things That Don’t Scale (2013)It’s not the prettiest code, but here:
https://github.com/evincarofautumn/kitten/blob/8a7e949f1af71...
The key line is:
(term', t, tenvFinal) <- inferType dictionary tenvFinal' tenv term
In “inferType”, I just annotate each term with “Zonk.type_ tenvFinal type_” as I go, in the same pass as generating the type constraints. Since “tenvFinal” is the final type environment, and “zonking” substitutes all type variables with their solved types, everything gets lazily resolved when reading the annotated types later on, e.g., during analysis & codegen.
In I tried Haskell for 5 yearsI’ve been working on a statically typed concatenative programming language, Kitten[1], off and on for a few years now. I plan to do an early release this year.
I started working on the language to bring an elegant compositional style to low-level high-performance programming, in the form of a simple language that admits powerful tooling for program editing and visualisation. I also wanted to address usability concerns with stack-based languages (e.g., by allowing infix operators). As I’ve spent time in industry, I’ve begun to treat it as a way to address my gripes with C, C++, and Haskell; and as I’ve learned more type theory, I’ve begun to use it as a playground for type system research.
The goal is to allow pure functional programming that “feels imperative”, with a simple performance model (unboxed values by default, in-place updates,
Read the rest
no laziness) and minimal runtime support (no GC, eventually no libc).
The latest compiler is nearly complete, but not yet usable for real programming. Still, you may like to keep an eye on its development.
[1]: https://github.com/evincarofautumn/kitten
Author of Kitten here, happy to answer any questions.
The site is pretty far out of date—it describes an older version of the language/compiler, so it’s better to check out the GitHub repo[1]. I figure I’ll send a pre-release announcement to all the stargazers, when the time is right.
One of my new year’s resolutions is to work on Kitten every week this year, and release it before the end of the year. I’m also working on a short ebook (“Programming with Kitten”) to serve as the standard tutorial.
I could really use help with all this—building and marketing a language is no small task. If you’re interested in contributing, even if you’re not familiar with Haskell or compilers, I’d be glad to help you get involved. :)
[1]: https://github.com/evincarofautumn/kitten
In Kitten – A statically typed, stack-based functional programming languageNew: Rust, ATS; new to me: J, D. And working on the compiler for Kitten[1], which should be usable by the end of the year.
[1]: https://github.com/evincarofautumn/kitten
In Ask HN: What “new” programming languages will you be using in 2017I’ve been working sporadically on a strict stack-based functional language called Kitten, with the goals of avoiding GC and libc. No plans for dependent types, but you might like to keep an eye on it anyway: https://github.com/evincarofautumn/kitten
In Towards Idris Version 1.0I’m working on a statically typed concatenative (stack-based functional) language called Kitten, and it’s one of the eventual goals to use type information to enable better editing environments, including on touch devices as seen here. The language is still a research project at this point, but it might be something you’d like to keep an eye on.
https://github.com/evincarofautumn/kitten
In Show HN: A stack-based pure functional language for touch devicesThe practical consequences of these algebraic properties are numerous:
• It’s easy to write good tools for writing, editing, refactoring, analysing, and visualising programs, because the language is really simple. If it’s easy to write good tools, those tools are more likely to exist and be correct.
• Functions are good basic units of behaviour. This fact is used in most paradigms. The fact that is not used explicitly in most paradigms is that function composition is a good basic way to combine behaviours. (Functional programming being a notable exception.)
• Small, modular parts are generally easier to understand than monolithic wholes. Being able to really easily decompose things into small parts helps you write correct programs more easily.
• Naming is hard. You can choose to name your intermediate state when it makes your code clearer
Read the rest
, but concatenative languages are the only ones that never require named state. The intent is to use names mostly to describe behaviours and how they relate.
I have been working on a statically typed concatenative language, Kitten, for a little while now. It’s working in the same problem space as Rust and Nimrod—making low-level programming feel high-level by using type system features to make high-level constructs have low-to-no runtime cost. It’s still a research project, but you should keep an eye on it: https://github.com/evincarofautumn/kitten
Showing the 15 most recent of 25 sources. Enable JavaScript to search and browse every indexed mention.