C3 | Blog | An evolution, not a revolution
Forget Borrow Checkers: C3 Solved Memory Lifetimes With Scopes 2025-07-11 Modern languages offer a variety of techniques to help with dynamic memory management, each one a different tradeoff in terms of performance, control and complexity. In this post we’ll look at an old idea, memory allocation regions or arenas, implemented via the C3 Temp allocator, which is the new default for C3. The Temp al
Effekt Language: Home
Effekt Language A language with lexical effect handlers and lightweight effect polymorphism Try it yourself! def eager[R] { p: => R / { flip, fail, error } } = try { Success(p()) } with flip { resume(true) match { case Failure(msg) => resume(false) case Success(res) => Success(res) case ParseError(msg) => ParseError(msg) } } with fail { msg => Failure(msg) } with error { msg => ParseError(msg) } F
Teal
About Teal Teal is a statically-typed dialect of Lua. It extends Lua with type annotations, allowing you to specify arrays, maps and records, as well as interfaces, union types and generics. It aims to fill a niche similar to that of TypeScript in the JavaScript world, but adhering to Lua's spirit of minimalism, portability and embeddability. Is it implemented as a compiler, tl, which compiles .tl
the penultimate conditional syntax – Tony Finch
About half a year ago I encountered a paper bombastically titled “the ultimate conditional syntax”. It has the attractive goal of unifying pattern match with boolean if tests, and its solution is in some ways very nice. But it seems over-complicated to me, especially for something that’s a basic work-horse of programming. I couldn’t immediately see how to cut it down to manageable proportions, but
Writing that changed how I think about PL
Every so often I come across a paper, blog post, or (occasionally) video that completely changes how I think about a topic in programming languages and compilers. For some of these posts, I can’t even remember how I thought about the idea before reading it—it was that impactful. Here are some of those posts in no particular order: a simple semi-space collector by Andy Wingo brought the concept of
GitHub - jamii/zest
Zest is a (very wip) programming language for building systems that are both malleable and legible. The goal is to: Support the interactivity and liveness of systems like emacs without giving up on civilized luxuries like static typing, early binding, jump-to-definition, load-order independence etc. Support the kinds of interactions I explored in research prototypes like eve and imp but from the w
- Curry Programming Language
-- Returns the last number of a list. last :: [Int] -> Int last (_ ++ [x]) = x -- Returns some permutation of a list. perm :: [a] -> [a] perm [] = [] perm (x:xs) = insert (perm xs) where insert ys = x : ys insert (y:ys) = y : insert ys Curry is a declarative multi-paradigm programming language which combines in a seamless way features from functional programming (nested expressions, higher-order f
zinc: the zinc systems programming language
#Zinc, a systems programming language prototype Zinc is my attempt at a low-level systems programming language prototype. I found this parser, called Owl mirrored here, that generates parsers for visibly pushdown languages. Visibly pushdown languages are those where recursion to other grammar productions must be guarded by tokens which can only be used for that purpose. While somewhat limiting, th
Overview - Neut Programming Language
Neut Programming Language Neut is a functional programming language with static memory management. Its key features include: Full λ-calculus support Predictable automatic memory management The absence of annotations to the type system when achieving both of the above Neut doesn't use GCs or regions. Instead, it takes a type-directed approach to handle resources. What Does it Look Like? Like the fo
GitHub - faiface/par-lang: Toy process language with an interactive playground for exploring concurrency
Par (⅋) is an experimental concurrent programming language. It's an attempt to bring the expressive power of linear logic into practice. 📚 Don't worry if you don't know anything about logic, you might have interacted with it without knowing anyway. Functional programming is based on intuitionistic logic. Rust's ownership system is based on affine logic, which is very similar to linear logic. The
The Dusa Programming Language
Dusa is a logic programming language designed by Rob Simmons and Chris Martens, the first implementation of finite-choice logic programming. If you’ve heard of Datalog (as implemented in systems like Soufflé), you may want to start by reading about how Dusa is datalog. If you’ve heard of answer set programming (as implemented in systems like Potassco), you may want to start by reading about how Du
Eve
Eve: Programming designed for humans Eve is a programming language and IDE based on years of research into building a human-first programming platform. From code embedded in documents to a language without order, it presents an alternative take on what programming could be - one that focuses on us instead of the machine. This is Eve: Eve is about humans, not computers We've made tremendous advance
Wiki - TheStateOfGarnet2025
Garnet is my attempt at making a programming language that could be summed up as “What if Rust was simple?” The goal is to make a small, borrow-checked language aimed at lower-level programming, designed for portability and robustness. Last updated Jan 2025. What got done in 2024 Comic from https://www.webtoons.com/en/canvas/shen-comix/donk/viewer?title_no=129357&episode_no=52 I made monomorphizat
The jank programming language
Intro Hi everyone! I’m Jeaye Wilkerson, creator of the jank programming language. jank is a dialect of Clojure which I’ve been working on for around eight years now. To start with, jank was an exploration of what my ideal programming language would be. Coming from a background of systems programming and game development, I was very comfortable with C++, but I also was exploring the world of functi
GitHub - rochus-keller/Luon: A compiler and IDE for the Luon programming language - a liaison beween Lua and Oberon+ - targeting LuaJIT
Luon is a high-level programming language with a syntax similar to Oberon+, Oberon-07 and Oberon-2, integrating concepts from Lua, and targeting the LuaJIT VM. Luon can be regarded as a statically typed version of Lua. The name is thus a combination of "Lua" and "Oberon". Luon procedures can be declared "external" and be implemented in Lua. This allows the re-use of libraries written in Lua, and a
Lush: my favorite small programming language
I meant to write about this when I started my blog in 2009. Eventually Lush kind of faded out of my consciousness, as it was a lot easier to get work doing stuff in R or Matlab or whatever. The guy who was maintaining the code moved on to other things. The guys who wrote most of the code were getting famous because of the German Traffic Sign results. I moved on to other things. I had a thought bu
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
GitHub - aartaka/lamber: A functional scripting language compiling to pure Lambda Calculus
GitHub - pallene-lang/pallene: Pallene Compiler
Writing that changed how I think about programming languages | Hacker News
Caelum, the hyper-functional programming language