r/ProgrammingLanguages • • 21d ago

Discussion November 2026 monthly "What are you working on?" thread

21 Upvotes

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!

NOTE: AI built/assisted projects are against the rules and this applies to this thread. If you share a link to a project that makes use of AI (Claude Code) for anything, you will be banned permanently without warning.


r/ProgrammingLanguages • • Oct 19 '26

To further combat AI/LLM slop, code dumps are now disallowed

273 Upvotes

About 6 months ago I shared an update on our attempt at handling the endless tide of AI slop. Most notably this post introduced a new approval flow for links to GitHub projects.

While this process has mostly helped reduce the amount of slop visible to readers (by virtue of GitHub links being filtered out by default until they are approved), it still requires manual work from moderators. In some instances there are also enough signals to strongly suggest the project is slop, but not so many that it's obvious, requiring more time from moderators to reach a decision.

Starting today we'll be trying something new and different, inspired by /r/rust and the new rules on lobste.rs:

Sharing links (in text or link submissions) to repositories on GitHub, GitLab and other code forges is no longer allowed and such posts are removed automatically and won't be approved, even after contacting moderators. Sharing links in comments is still fine. There are a few reasons for this:

  • 99% of AI slop submissions are GitHub links
  • When the post is a text post it pretty much always includes a GitHub link somewhere, sometimes even "cleverly" hidden in a code block
  • Even if the link is legitimate, just dumping a link rarely invites for a discussion or the transfer of knowledge, instead it's just "Hey look at this, please like and subscribe!" so to speak
  • It's unfortunately the only approach we can fully automate without wearing down our sanity. You can thank Reddit for enshittifying their API over the years for this.

Note that it's still perfectly fine to share a link to say a blog post about the project and then link to it from there. It's also still fine to share a text post and then include additional links in a comment. In fact, we suggest that those without a dedicated blog of sorts do exactly that.

In all cases, the no AI/LLM rule still applies and sharing AI/LLM projects will still get you banned.

Of course AI slop bros can generate a website and share a link to that, but it requires slightly more effort, and fortunately for us AI bros are as lazy as they are boring. Ultimately the goal is not to reduce slop making it past our filters to zero, but rather to get rid of say 99% of it without wearing down both moderators and subscribers.

I suspect some will disagree heavily with this change, but this change is ultimately another experiment in a line (and probably a growing one) of experiments to try and maintain a certain quality standard. If it turns out this doesn't work as well as hoped, we'll of course reevaluate it and try something else.

Finally, there are some existing projects that are genuine but adopted a more permissive stance towards the use of AI. Usually this is phrased something along the lines of "If you do X, Y, Z then AI is allowed". While I personally believe this is incredibly naive (developers can't be bothered writing documentation, yet you think they will review 10 000 lines written by Claude? Please), I don't yet know how to best deal with these cases. As such we'll tolerate this as long as it's within reason, i.e. "moderator discretion" applies here.

FAQ

What?

  • Link submissions to repositories or text submissions containing repository links will be removed
  • Links to articles or websites about the project is fine
  • Unless it's an AI built article/website
  • Including a link to your repository in a comment is fine

I don't have a website/blog/etc, now what?

Create a text post, then share a link in a comment. Don't use this as just a way of advertising though, we want discussions and sharing of knowledge, not a bunch of people screaming into a room "HEY LOOK AT MY PROJECT".

What about projects hosted on a non-standard forge?

These will make it past the filter, at least until we adjust it to also filter for these forges.

What about AI generated websites?

This falls under the "No LLM/AI" rule and sharing links to such sites will get you banned faster than Sam Altman can say "AI". We'll generally err on the side of "if it looks enough like an AI website, it's probably an AI website".

Will you update the rules/sidebar accordingly?

Once we're satisfied with the new system, yes.

But this is literally an AI pogrom!!11

Go away.

This is bad for the subreddit!

If this drives away a few AI slop enjoyers, then great! The other 130 000 subscribers will be happier for it.

Can I still share my project in the monthly "What are you working on" sticky?

Yes, provided it meets the rules (i.e. doesn't make use of LLM/AI output).


r/ProgrammingLanguages • • 1d ago

Discussion What do you do with your language when finished?

35 Upvotes

This question applies to any solo language developer, either as a personal learning project or to try out some features or unique syntax. What happens when your language is finished? Do you end up incorporating it as a scripting language in your other projects? Use it stand alone as a daily driver? Does it get put on a shelf and part of your personal portfolio? Do you try to make it general purpose, put it out there and hope it finds some niche for others?

Or does it never really reach a state of done, where you hack in it madly for a while then gradually slow down as it gets harder and harder to add the features you want. I'm trying to gauge what I'm in for on my second attempt after a 20 year break.


r/ProgrammingLanguages • • 1d ago

Discussion For interpreted languages, how much of your standard library is written in your language vs. lowered into the runtime?

21 Upvotes

I'm working on a self-hosted language that compiles to Wasm. It runs inside of a Rust project.

Part of my standard library is serialization and deserialization into common forms like json, toml, ron that other systems already use - it's how I'm interoperating with other services. So far, I've been writing these in the language itself, and it was decently fast.

Then I encountered the actually-deployed code of other services that often produced out-of-spec stuff. So I go back and write handling for all these edge cases and stuff, and suddenly it's a lot slower. I check out what's taking so long and it's all the edge cases.

So the language has FFI into the Rust runtime for certain things that it has to have. I'm thinking of having the library functions just call out to Rust code that does the heavy lifting. The interface adds a little lag, sure, but if I do the entire parsing into objects at the rust level, I think it'll be faster.

When is it worth it? The Rust application takes ages to compile, which is why my language project exists in the first place. I want to be able to write business logic and swap it out really quickly. But I don't think I'm going to be revising the library functions very frequently.

What do you all do?


r/ProgrammingLanguages • • 1d ago

Evolving the Java Language: An Inside Perspective

Thumbnail youtube.com
0 Upvotes

r/ProgrammingLanguages • • 2d ago

Hoisting explosive code out of loops

Thumbnail futhark-lang.org
19 Upvotes

r/ProgrammingLanguages • • 1d ago

Programming in English

Thumbnail pvs-studio.com
5 Upvotes

Some thoughts on why natural language still can't replace code


r/ProgrammingLanguages • • 2d ago

Requesting criticism Working on a Type System, Thoughts?

5 Upvotes

Hello, I spent a little bit of time throwing together a README for a programming language that I am working on after repeatedly abandoning previous projects. For this project, I really wanted to start by focusing on the type system and I thought of some cool ideas. I have a lot of the implementation details worked out, but I wanted to know if anyone had thoughts!

(repost because I didn't know I couldn't upload GitHub links)

Below is the README pasted from my GitHub, you can also view it at ephf/boxc for better Markdown parsing.

boxc

boxc is a C-like language transpiled into C.

Development

[!IMPORTANT] This language is in active development and has no current releases, below are some ideas / dev logs and current progress. Below code examples, you will see checklists on what is implemented and what is not.

Although it may not look like I have done much in the development of this language, I have made a couple of other unfinished languages that I have learned from. See,

Tuples

The main idea for this first round of development is focusing on the type system, generics, and overloading. In order to do this, I am trying to build out a tuple type, similar to C++.

struct tuple<...>;

This code declares a tuple structure without a body, it cannot be used in this state to define a variable,

tuple<> x; // error: tuple<> has no body

The tuple struct will have two main overloads that will create a linked-list structure in compile time.

struct tuple<<First, Items...>> {
    First value;
    tuple<Items> next;
}

struct tuple<> {}

[!NOTE] Defining a tuple using <<>> instead of <> is a shorthand which will create an overload. Normally overloading requires type arguments and a generics declaration, like the following:

This can also be used to mix and match type arguments and generics,

Below is an example of what the compiled code would look like,

tuple<i32, char, usize> x;

struct tuple {};

struct tuple0 {
    size_t value;
    struct tuple next;
};

struct tuple1 {
    char value;
    struct tuple0 next;
};

struct tuple2 {
    int32_t value;
    struct tuple1 next;
};

struct tuple2 x;

You could implement a function similar to std::get<size_t> in C++, however there are a couple of things I wanted to implement that would make this easier.

Here I have defined a trait for the field_access operation or .

namespace std::operator {
    trait field_access<Accessor> {
        Field field_access<Field>(self, Accessor);
        Field field_access<Field, Accessor accessor>(self);
    }
}

The field_access trait has two functions that can be overridden. The first one accepts any expression, and the second one, which takes precedence, takes any compiler constant expression.

We can implement this trait in the tuple type to make it easier to select specific tuple values.

struct tuple<First, Items><Index : usize, First, Items...> 
    : std::operator::field_access<Index> 
{
    First value;
    tuple<Items> next;
    
    inline auto field_access<First, index><Index index>(self)
        index ? next.field_access<auto, index - 1>() : value;
}

This will allow us to use the . operator to get a specific element in our tuples at compile-time,

tuple<i32, u32> x;

auto y = x.0;
auto z = z.1;

assert typeof y == i32;
assert typeof z == u32;

Overall, I think one of the main things I want in this language is for a lot of the language features to be implementable from within the language itself instead of relying on syntactic sugar.

Optionals

Similar to JavaScript's ?. operator, I wanted to create an easy way to interface with nullable values and optionals. Below is a definition for an operator override using ? as an operator.

namespace std {
    trait nullable_coalesce<NonNull> {
        std::tuple<bool, NonNull> nullable_coalesce(self);
    }
}

If we have a value that implements this trait, we can use the ? operator to conditionally search through a hierarchy of values.

[!NOTE] You can differentiate the ? nullish coalescing operator from the ? ternary operator because the nullish coalescing operator needs to be followed by a postfix operator like . or ().

struct MyStruct {
    int field;
}

int? get_field<T : std::nullable_coalesce<MyStruct>>(T maybe) {
    return maybe?.field;
}

MyStruct* not_null = &{5};  // referencing an rvalue will stack allocate its value
auto x = get_field(not_null);
auto y = get_field(null);   // null is a keyword similar to nullptr, but it can also be used as a type

assert *x == 5;
assert !y;

int? is syntactic sugar for std::option<int>. Before we write option, there are a couple of traits it needs to override,

namespace std::operator {
    trait dereference<Type> {
        Type dereference(self);
    }
}

namespace std::trans {
    trait from {
        Self from<From>(From);
    }
    
    trait into {
        Into into<Into>(self);
    }
}

Now we can write option,

namespace std {
    struct option<Type> 
        : operator::dereference<Type>, trans::from, trans::into
    {
        Type || null data;
        
        inline Type dereference(self) 
            self.data.(Type);
        
        inline Self from<Type>(Type data)
            Self { data };
        
        inline Self from<null>(null)
            Self { null };
        
        inline bool into(self)
            self.data.is<Type>();
    };
}

Overall, even for syntactic sugar, there will be definitions inside of std that are being referenced.


r/ProgrammingLanguages • • 3d ago

optimistic or pessimistic compiler?

8 Upvotes

for those that compose and craft compilers, do you find the results better and more satisfying for you if the compiler you work on is permissive/optimistic or strict/pessimistic?

permissive/optimistic here means that the starting point is the compiler assumes the line of code that it is parsing/evaluating is probably ok but needs to pass some checks before translating to the target backend? (this is “the compiler is your friend” approach)

strict/pessimistic here means that the starting point is the compiler assumes the line of code that it is parsing/evaluating has something wrong and its job is to discover that wrong thing, and it is disappointed when the line passes all checks before translating to the target backend? (this is “the compiler is the teacher we’ve all had at one point in our life where they assume you’re going to do something bad as soon as they’re not looking” - and they’re not wrong)

obviously there has to be some balance here, but i’m curious, what has been your experience with these two approaches?


r/ProgrammingLanguages • • 3d ago

Is there any other compiler backend other than LLVM, MLIR?

Thumbnail reddit.com
10 Upvotes

r/ProgrammingLanguages • • 4d ago

Tiny BASIC: The People's Language for the People's Computer

Thumbnail youtube.com
11 Upvotes

r/ProgrammingLanguages • • 4d ago

A question about handling bad typecasts in dynamically-typed language

7 Upvotes

Hello everyone,

Im developing a small hobby scripting language, for embedded applications. It was started as a PHP8 clone, but now it is not fully compatible with Zend PHP.

I would like to get a feedback on language feature Im experimenting with.

It is about type conversions (type casts)

The basic idea is to allow any conversions, but track conversions that may indicate a programming mistake (allowing a bad input to reach calculations is considered a programmer mistake).

I.e.:

$x = "123";      // Valid numeric string (is_reliable($x) == true)
$a = (int)$x;    // 123, reliable (is_reliable($a) == false)


$y = "123abc";   // Partially numeric string (is_reliable($x) == true)
$b = (int)$y;    // 123, but UNRELIABLE (is_reliable($x) == false)

Instead of immideately throwing an error or silently accepting the conversion, we can mark the resulting value as unreliable.

This metadata (a flag) belongs to the value itself (not to the variable). Copying a value preserves the flag, and operations consuming an unreliable value propagate it to their results. 'Consuming' means using the value.

Example of the unreliable flag propagation:

$x = "123abc";
$a = (int)$x;    // UNRELIABLE
$b = $a + 10;    // Also UNRELIABLE
$c = $b * 2;     // Also UNRELIABLE

Values can be tested with built-in language construct is_reliable(...); There are pseudo-types unreliable and reliable which allow this flag manipulation:

$a = (int)"123abc";  //123, unreliable
$a = (reliable)$a;   //123
$a = (unreliable)1;  //1, unreliable

Normally program continues executing regardless unreliability of values used.

However, you can explicitely require reliable values in a particular code section:

reliable {
    ...
    $result = $b * 2;
    ...
} catch (UnreliableException $e) {
    echo "Unreliable value detected!";
}

Reading an UNRELIABLE value inside a reliable block throws an exception.

The idea is to combine the idea of dynamic typing with the ability to enforce stricter guarantees where needed.

I'm aware that propagating unreliability through subsequent calculations is not the best way to detect a programming error at the exact point where it originally occurred :).

By the time the value is consumed, the actual source of the problem may be far away, yes.

I'm interested in whether the benefits outweight this drawback.

A fast-fail mode is also allowed: we want exception but we do not want to catch it:

reliable on;
...
$a = '123abc';
$a = (int)$a;  // <-- Uncaught exception here
...
reliable off;

Examples above are all about strings and numbers, but this mechanism is suggested for all types (hashmaps aka php arrays, float, boolean values, class instances):

$a = [1, 2];
$b = (int)$a;       // 1, unreliable (more than 1 element in the array)
$b = (int)[1];      // 1, reliable
$b = (int)[[[1]]];  // 1, reliable

What do you think about this approach?

In particular:

  1. Dose propagating reliability flags through values and operations makes any sense?
  2. Are there any problems with this model?
  3. Have you seen similar approaches in other languages or runtimes?

Thank you!


r/ProgrammingLanguages • • 4d ago

What’s going on with program verification?

Thumbnail blog.sigplan.org
41 Upvotes

r/ProgrammingLanguages • • 4d ago

Owning the Truth: Undecidability, unsound kernels, and the forging of proof

Thumbnail phrack.org
3 Upvotes

r/ProgrammingLanguages • • 6d ago

Ring programming language version 1.28 is released!

Thumbnail ring-lang.github.io
19 Upvotes

Hello

I have already released Ring 1.28

Ring is a dynamic language with lightweight implementation like Lua but with more features like Python/Ruby. I created it because I was looking for a Visual FoxPro replacement but was not satisfied with many other languages that I tried. The development started in Sept. 2013, and Ring 1.0 is released in January 2016, and I continued developing it as open-source project for over 10 years. I used to get feedback about the language through this group which contains over 3,000 topics.

So, here is what Ring is trying to do

(1) Keeping the implementation simple and small (The KISS Principle) that one programmer can study/understand in short time, but still a powerful and practical dynamic language with many useful programming paradigms.

The motivation behind this principle: Lua comes with small and fast implementation, but it misses many features provided by default in Python/Ruby. on the other hand, both of Python/Ruby requires different implementation to be used in places where Lua can be used directly, that's why there are projects like MicroPython and mRuby.

In Ring it's the same implementation everywhere. To be able to achieve this we used a custom implementation way and design decisions explained in this paper. So, In Ring, we have extreme portability, it's written in ANSI C (26 KLOC includes the Compiler, The Virtual Machine and 228 standard function), where the same implementation works on Desktop (MS-DOS, Windows, Linux, macOS), Mobile (Android, iOS) & Microcontroller (Raspberry Pi Pico).

(2) Syntax Customization: I am not a native English speaker, and I started programming at 10 years old (Three decades ago), It was a difficult journey for me at that time, I was studying English and Programming at the same time, I used to do translation from English to Arabic using a printed dictionary where I have to search for words meaning and used to spend a complete day just to read one page from my CA-Clipper programming book (for MS-DOS). Ring allows dynamic translation of language keywords/operators and supports multiple syntax styles (Similar to C, Ruby & Basic). For large/serious projects using a code formatter we force a specific style, but the point from this feature is to give each programmer the ability to write code in his native language.

(3) Declarative/Natural Language Programming (Developing Domain-Specific Languages): Ring extend OOP with new simple features that enable designing DSLs that looks like QML, SQL, COBOL, Supernova, etc. in short time. such a feature if used correctly provides advanced abstraction levels that are fun to work with.

(4) Batteries Included + Simple IDE + Form Designer: Something like VB6 era because I am coming from a Visual FoxPro background, but in Ring we can use Qt (We have packages for Qt5 and Qt6 too), and Ring supports Qt for Desktop/Android/WebAssembly, So you can open Ring IDE, design a form, run you app on Desktop, export it as Qt project for WebAssembly and run it in the browser or export it for Mobile and run it on Android. Compared to Python, Ring supports Qt for Android/WebAssembly many years before Qt company do this for Python. The reason is the principle (1), being a lightweight language with simple implementation.

(5) A love message to Visual Programming Languages: Ring Compiler/VM code is generated using my PWCT visual programming tool that I developed starting from Dec 2005. So, one of the goals was a practical project that I can develop using PWCT. After using PWCT to develop Ring, I developed PWCT2 using Ring as an example about what Ring can do. This research paper explains PWCT2 and its improvement over PWCT.

(6) Memory Management: It utilizes a deterministic, safe, and flexible scope-based memory management system that incorporates escape analysis and optional reference counting with cycle detection.

Thanks


r/ProgrammingLanguages • • 6d ago

Requesting criticism I’m writing a game engine and an RPG in Duck, my own programming language

12 Upvotes

I’m building Duck, a statically typed, compiled language for game development. I’m using it to write Quaxel, my game engine, and Hellfeather, a Diablo II-inspired action RPG prototype. One of the more contentious ideas in Duck is letting the compiler infer which operations can run concurrently. I lean toward giving it that freedom, and I’d like criticism of that choice.

Here’s a small example from a Quaxel test. Each session has its own frame counter and running flag.

QuaxelSession first()
QuaxelSession second()

first.Begin()
second.Begin()
first.Advance()
first.Stop()

Begin() resets a session’s frame counter and marks it as running. Advance() increments the counter if the session is running. The order of first.Advance() and first.Stop() matters. Swap them and you get a different frame count. But suppose the compiler can prove that second.Begin() touches only the second session. My instinct is that writing it on the line above first.Advance() shouldn’t, by itself, require one to finish before the other starts.

These calls are tiny. I’m using them because the dependency is easy to see. The case I care about is two expensive updates in the same frame. Even if overlapping them preserves the result, it can still change frame time and make a performance problem harder to reproduce.

If you think concurrency should require an explicit opt-in, what’s a case where you’d want that guarantee even though the compiler could prove the work independent? That’s the kind of example I’d like to test Duck’s design against.


r/ProgrammingLanguages • • 7d ago

Help Should I choose 1-based indexing or 0-based indexing for my programming language?

29 Upvotes

I'm creating a host-embedded, minimal, beginner-friendly programming language as a replacement for Lua. This language is really human readable, English-like and beginner friendly, with automatic memory management, automatic parallelism, a fantastic and helpful compiler inspired by Rust, and other things. The biggest question I have is whether I should choose 1-based indexing or 0-based indexing?


r/ProgrammingLanguages • • 5d ago

Help Is generating C++ instead or C or assembly bad?

0 Upvotes

.


r/ProgrammingLanguages • • 8d ago

Fixing failure handling in parallel code

Thumbnail futhark-lang.org
13 Upvotes

r/ProgrammingLanguages • • 7d ago

Serialization unit tests for a Crafting Interpreters clox bytecode vm?

Thumbnail reddit.com
2 Upvotes

r/ProgrammingLanguages • • 9d ago

ML Modules for Mere Mortals

Thumbnail thunderseethe.dev
62 Upvotes

r/ProgrammingLanguages • • 9d ago

Proof Assistant as Platform: Building the Next Generation of Verifiers

Thumbnail pirlea.net
15 Upvotes

r/ProgrammingLanguages • • 9d ago

Discussion Adding actual generics to c

18 Upvotes

I was watching tsoding's crust stream and I thought it would be so funny if I extended c to have generics.

The way I did this was by extending the syntax of c with the classic rust angle brackets to define generics and then during transpilation do some name mangling to monomorphize the generic code.

Here is the result of that abomination:

#include <stdio.h>

// you can define your own operator in fortran .op. style with a trait
trait<T> DotP {
    // for parsing reasons any dot-op must have whitespaces around it in any context
    T .dot. (Self self, Self other);
}

// using a very similar syntax to rust, you can add generics to structs
typedef<T> struct {
    T x;
    T y;
    T z;
} Vector<T>;

// and by appling the trait to your struct (with generic parameters)
// you can define what your operator should do.
impl<T> DotP<T> for Vector<T> {
    T .dot. (Self self, Self other){
        return self.x * other.x + self.y * other.y + self.z * other.z;
    }
}

int main(void) {
    // by concretly defining which type you want to use as the generic
    // a c struct with that/those type(s) is genenerated 
    Vector<float> fv = {1.0, 2.0, 3.0};
    printf("Dot product of fv^2: %f\n", fv .dot. fv);
    Vector<int> iv = {1, 2, 3};
    printf("Dot product of iv^2: %d\n", iv .dot. iv);
}

The generated c code looks something like this (I have actually implemented this transpiler, perhaps a true indicator of joblessness):

/* Generated by typedc. */
#ifndef TYPEDC_SIMPLE_GENERICS_H
#define TYPEDC_SIMPLE_GENERICS_H

#include <stdio.h>

typedef struct float_Vector float_Vector;
typedef struct int_Vector int_Vector;

struct float_Vector {
    float x;
    float y;
    float z;
};

struct int_Vector {
    int x;
    int y;
    int z;
};

int main(void);
static inline float float_dot(float_Vector self, float_Vector other);
static inline int int_dot(int_Vector self, int_Vector other);

int main(void) {
    float_Vector fv = {1.0, 2.0, 3.0};
    printf("Dot product of fv^2: %f\n", float_dot(fv, fv));
    int_Vector iv = {1, 2, 3};
    printf("Dot product of iv^2: %d\n", int_dot(iv, iv));
}

static inline float float_dot(float_Vector self, float_Vector other) {
    return self.x * other.x + self.y * other.y + self.z * other.z;
}

static inline int int_dot(int_Vector self, int_Vector other) {
    return self.x * other.x + self.y * other.y + self.z * other.z;
}
    
#endif /* TYPEDC_SIMPLE_GENERICS_H */

r/ProgrammingLanguages • • 9d ago

Discussion church pair - why do we even need to represent the first eliminator as λp. p true

14 Upvotes

This might sound like a super dumb question, but I did not want to ask Chat gpt and I wanted to ask an actual human,

but why if the first for a church pair , like has this abstraction

λp. p true 

and not just true.

Is it because its supposed to like take a pair as an argument and spit out the first , and thats it? cause if it were just true it would still behave the same

sry for the dumb question lol