Recto — a truly 2D language
Masato Hagiwara Open in Recto Pad Google Colab Github Recto Pad TL;DR Recto is a 2D programming language that uses nested rectangles as its core syntax, encoding structure and recursion directly in space instead of a linear stream of text. Recto explores new ways to write, parse, and reason about code—and even natural language—spatially. Introduction Open in Recto Pad Virtually all the languages w
q
The Q Programming Language Q is a minimal, dependency-free programming language and compiler targeting x86-64 and arm64 with ultra-fast builds and tiny binaries. Features High performance (ssa and asm optimizations) Fast compilation (<100 μs for simple programs) Tiny executables ("Hello World" is ~600 bytes) Multiple platforms (Linux, Mac and Windows) Zero dependencies (no llvm, no libc) Installat
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
- 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. 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, this ends up
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 ability to achieve both of the above without additional type annotations Neut doesn't use a GC. Instead, it takes a type-directed approach for memory management. What Does it Look Like? Like the following: /
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
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
superfly
GitHub - Beariish/bolt: High-performance, real-time optimized, and statically typed embedded language implemented in C.
Yalep / Yalep · GitLab
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
GitHub - jamii/zest
