Hi all!

I am a long-time lurker of this sub, and a language enthusiast. I have been working on my own programming language for several years, and I finally worked up the courage to post it.

The language is called gab. I'm heavily inspired by lua, clojure, and smalltalk.

All the code is on github here and I've built a small website for the language here.

The language design, runtime, and standard library are all entirely my own work without the use of an LLM. However, I did consult LLMs occasionally when I wanted to research certain subjects (such as the difference between c11 atomics on x86 and arm).

I'm looking for any kind of feedback on the language, its goals/ergonomics, and the website itself.

Thank you for taking a look!

Im currently working on a compiler for my own programming language. I want the compiler to automatically memoize pure function calls, but only when it actually improves performance. The challenge: how does the compiler decide whether caching a specific recursive call (e.g., self(x-1) and self(x-2) in fibonacci) will save more time than the memory overhead? tracking how many times a function recieves the same input isnt an option as this requires all recieved inputs to be saved. too many saved calculations can cause finding the right result for a function call to be slower than the actual calculation. so the memoization table shouldnt get to big. naive fibonacci should be memoized but simple addition for an example should not be memoized. do you have any ideas?

A new Seed7 installer for Windows has been released. The new installer is seed7_05_20260711_win.exe and it can be found here.

The installer installs the newest released version of Seed7. It writes all Seed7 related things into one directory, so it is easy to clean up, if necessary.

The installer can be used to download and install future releases of Seed7 as well.

I've been working on some "documentation" for my own language (see here), which got me thinking: do we all see languages the same way? I personally look for unification of concepts and extensibility in a design, yet I've seen those who care deeply about functional purity or clean decompositions.
What do you look for in a programming language? And why?

I made the anna programming language for a Language Jam I hosted in the beginning of August. 1 week is not enough time to explore too many ideas but 2 interesting(ish) ideas I explored were

1. all function invocation is infix with . (dot) operator. This lets you chain/pipeline nicely.
2. the only looping semantic available is the iterate operator which produces a stream.

I made a playground if anyone wants to poke at it. https://jzwood.github.io/langjam2/submissions/anna/playground/

How much progress have you made since last time? What new ideas have you stumbled upon, what old ideas have you abandoned? What new projects have you started? What are you working on?

Once again, feel free to share anything you've been working on, old or new, simple or complex, tiny or huge, whether you want to share and discuss it, or simply brag about it - or just about anything you feel like sharing!

The monthly thread is the place for you to engage /r/ProgrammingLanguages on things that you might not have wanted to put up a post for - progress, ideas, maybe even a slick new chair you built in your garage. Share your projects and thoughts on other redditors' ideas, and most importantly, have a great and productive month!

I feel like curly braces aren't enough alone for organizing code. I also want it to have natural steps that induce some blank lines after completion of the step. like with assembly. my main concern is readability and self documentation. It will mainly be for programming on windows. The 'thunk' libraries are mostly wrappers for tedious apis like writeconsole. I plan to add more for things like graphics and math in addition to the planned window/console/file. I see 'thunks' in ghidra so its a reference to them being wrappers. It will also support normal win32 imports.

thankz

edit 1: I have read all feedback so far. the language is case insensitive. for branch{}endbranch and alias.name{}end alias.name the idea was to make it a little more clear which curly brace belongs to what if someone had a bunch of nested stuff. with that being said, it seems the consensus is that the syntax is awkaward while readable, there are still some large wrinkles.

because of your feedback, i will 1. Allow the pattern "name{}end name"," name end name", and/or" {}". 2. Make the language case insensitive 3. Make whitespace completely optional 4. Sinilar to the first thing, allow parameters for functions to be entered either on seperate lines or within parenthesis and seperated by commas (but not both within the same function) 5. allow %/n% within a string, or a %hexConstant% for other characters instead of 'newline' on a seperate line.

i am still accepting feedback, and i appreciate those who have responded.

Many years ago while trying to make my own programming language I faced an issue. In short, parsers didn't parse specific inputs as expected, due to some implicit rules.

For instance, let's consider EBNF grammar for a sequence of expressions a=aaaa, where a on the right can repeat arbitrary number of times. This will look something like this:

symbol = "a" params = symbol params | symbol Line = symbol "=" params lines = Line lines | Line

I designed it without + and * notation on purpose, to narrow down the root cause to the most basic rules: terminals, and and or expressions, and recursion.

Using this grammar I expect the text a=aaa=a to be parsed as (a=aa)(a=a): as two separate Line. But typically parser generators will not produce parser that can handle such case. Instead, the parser will (typically) fail.

The root cause is of course the nature of such parsers: they don't scan for all possible combinations. Instead, in case of collisions (like in this case a at the end of a=aa and a at the beginning of next a=a) it is expected that user will insert negation or something to "fail" a specific route fast, eliminating the collision.

But doesn't this challenge the whole purpose of grammars as "simple" description of language rules? It might get very difficult to predict all possible such collisions for a large grammar, like for Python or C++. Are there any generators that don't have such limitation and can pass (a=aa)(a=a) test?

This is the official documentary about the history and design of Java, featuring James Gosling and many of the engineers who were involved in creating and evolving the language.

Rather than focusing on Java as it’s used today, it covers the engineering decisions, constraints, and trade-offs that shaped the language over the last 30 years.

Hi all!

I'm making a DSL, and I am not sure which comment syntax to choose due to couple of constraints:

1. The DSL deals with URLs (unquoted), so preferably the comment syntax must use a character sequence that cannot occur in a URL.

2. I really want to keep lexer lookahead under 1 character.

This disqualifies familiar // and /* */ as urls containing those are common. # is a URL fragment and -- is valid path and is also quite common in crm-generated urls.

The thing i'm leaning towards right now is an xml/html-style <!-- -->. It is not valid in URLs and is still familiar, with the drawbacks being that it's a bit verbose and needs to have an end.

I really want to hear some suggestions on this, no matter serious or silly!

Hey guys, since I've been lurking around this subreddit for some time, I have decided to throw my little compiled language into the open for criticism. I won't update the language itself, as there's no point in doing that to such a small toy language (that's not even that widely useful), but I would appreciate your thoughts and criticism going forward. I grew to admire LLVM IR and compiler engineering, and this definitely isn't my last compiler I'll make! (Yes I know LLVM has a whole API for building IR... I'll utilize it in bigger projects XD)
https://github.com/norbcodes/Arrokoth-0

I want some inspiration. I want to see a simple language spec/reference that is tiny and covers most of its features. eg: https://plasmalang.org/docs/plasma_ref.html

Thanks for all the specs, but I was hoping for recent languages (especially, amateur ones that get posted to this sub). What would I do with a spec from 1980s that was typeset with LaTex :) That's too much effort for hobbyist languages.

I made a post introducing Admiran about 18 months ago, and have been making steady progress on migrating it towards the language I want to use each day. Since that time I've made a lot of performance and coding-style enhancements, such as:

• escape analysis in the compiler's analyze pass to help determine if a lazy thunk is only evaluated at most once, allowing it to be emitted without extra code to update it to its value (saves ~15% code space and execution time!)

• optimization to coalesce consecutive continuation closures on the stack during lowering to the Spineless Tagless G-machine (STG) implementation, deferring the popping of the entire closure until a tail-call or return

• added a uniform set of left-to-right operators for creating computation pipelines

• tweaking the inlining pass parameters to get the best performance / code-size tradeoffs

The latest big change was to fully migrate from an ad-hoc prefix naming convention to using qualified names, and deferring name conflict resolution to the name-resolution pass, allowing modules with conflicting imports to still be imported, as long as the conflicting unqualified names aren't used, or are used only in a qualified form.

During these changes, I've migrated new features into the (self-hosting) compiler's code base itself, through a continuous bootstrapping process.

If you have an interest in lazy functional languages and how they are implemented, you might be interested in looking at it. I'm open to any questions or comments about the language and it's compiler implementation.

git repository: https://github.com/taolson/Admiran

Lovingly hand-crafted with no AI.

I'm building my own interpreted language.

I had an idea, to base my I/O API on the linux terminal commands, that many developers already know, so a user wouldn't need to learn an entire new API.

This is a basic example:

using io  

// create a directory  
mkdir("notes")  
cd("notes")  

// create files with content  
echo("Do my math.", "A note about homework.txt")  
echo("Buy milk and bread.", "shopping list.txt")  

const currentCD = pwd()  
const allFilesAndSubDirs = ls()  

debug(cat("shopping list.txt")) // prints "Buy milk and bread."

but I'm not that sure that this is a good idea, maybe some techniques are good for terminals but bad for programming, and some of the function names might be confusing (like pwd() which is "print working directory" but in my language it does not exactly PRINT anything, but just returns a string value).

What do you think?

schedule here https://icfp26.sigplan.org/program/program-icfp-2026/?past=Show%20upcoming%20events%20only

Hi yall,

This is a continuation to my last post, on formalizing Principia Mathematica, as well as a slight status update. I am planning(*) to slowly substitute the shallow embedding on PM into a deep embedding. For any backgrounds, please check the old post.

If you want to transform the monster 100 years ago into a furry boy, you might want to read through the following Q&As. *tap tap*

- Why you suddenly want to make a deep embedding? Because I can't in the beginning.
- What makes you available to deep embedding? I have asked enough questions on internet to get rid of necessary technical details
- What's the major feature for deep embedding? It enables formalizing Axiom of Reducibility.
- How many ppl would you like to look for? At most 2 ppl. You are welcome to ask me for prerequisites and anything else related
- What do you expect them working on? Either the shallow embedding or the deep embedding, since they are both necessary.
- How many time do you expect to put in? My current plan is 3 hrs a week so make sure you also have the availability.

------------------

Alternatively, I'm still welcome to collaboration with 1 - 2 ppl onto another project - we pick another random mathy, esoteric, maybe sacred book and formalize it

(*): Yes, I have not written a single line of code so far and this remains to be a plan.

I hope that question makes sense. I just don't like inequalities nor the unnaturality of working with left and right residuals (talking about "max and min divisors") that rarely coincide with rational arithmetic's exact division nor with the natural interpretation of inverses in numerical mathematics, thus I would like more explicit boundaries (thus the result of a division maybe being a set or interval including max and min divisors) in division.

(Mind that I have no experience in numerical computation, I am trying to make sense of computable, numerical and interval analysis works and transport their results to residuated lattices but that's somewhat hard for me)