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
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
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
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
