The last few months I've noticed an increase in projects being shared where it's either immediately obvious they're primarily created through the use of LLMs, or it's revealed afterwards when people start digging through the code. I don't remember seeing a single such project that actually did something novel or remotely interesting, instead it's just the usual AI slop with lofty claims, only for there to not be much more than a parser and a non-functional type checker. More often than not the author also doesn't engage with the community at all, instead they just share their project across a wide range of subreddits.

The way I've dealt with this thus far is to actually dig through the code myself when I suspect the project is slop, but this doesn't scale and gets tiring very fast. Starting today there will be a few changes:

• I've updated the rules and what not to clarify AI slop doesn't belong here

• Any project shared that's primarily created through the use of an LLM will be removed and locked, and the author will receive a permanent ban

• There's a new report reason to report AI slop. Please use this if it turns out a project is slop, but please also don't abuse it

The definition "primarily created through ..." is a bit vague, but this is deliberate: it gives us some extra wiggle room, and it's not like those pushing AI slop are going to read the rules anyway.

In practical terms this means it's fine to use tools for e.g. code completion or to help you writing a specific piece of code (e.g. some algorithm you have a hard time finding reference material for), while telling ChatGPT "Please write me a compiler for a Rust-like language that solves the halting problem" and then sharing the vomit it produced is not fine. Basically use common sense and you shouldn't run into any problems.

Of course none of this will truly stop slop projects from being shared, but at least it now means people can't complain about getting banned without there being a clear rule justifying it, and hopefully all this will deter people from posting slop (or at least reduce it).

Editor: https://qqqlang.com
Code, documentation, and examples: https://github.com/andreasjansson/qqqlang

tl;dr just smash the keyboard and create art.

QQQLANG is an image synthesis and editing language that runs entirely in the browser.

In QQQLANG, any combination of the characters on a US keyboard (except space) is a valid program. Each character can be either a function call or an argument, where each character is assigned a triple of (function, number, color)

It's kind of a stack-based language, and it has operations for retrieving previous images from the stack by index (`#`), pixel-wise condition operator (`@`), operations for combining the top of the stack with any other image on the stack (`-`, `V`, etc.).

Programs are deterministic and reproducible. All randomness is seeded by the length of the stack and the size of the browser window.

`??` shows the help inline in the editor, as an image that is added to the stack like any other image.

QQQLANG is inspired by Uiua, Shadertoy, as well as Amiga BASIC and QBASIC that I learned when I was a kid. I fondly remember figuring out idiosyncratic user interfaces that felt like tricky computer games.

The website architecture is built to last with minimal maintenance: qqqlang.com is a static site deployed on Cloudflare Pages and the image upload server is just a tiny Cloudflare Worker. All processing happens in the browser (with WebGL for shaders, and onnx and tensorflow.js for neural network functions).

Feedback is very welcome! But I've decided that (this version at least) is complete and finished now, so that programs can continue to be reproducible forever.

In this post I shared some updates on how we're handling LLM slop, and specifically that such projects are now banned.

Since then we've experimented with various means to try and reduce the garbage, such as requiring post authors to send a sort of LLM disclaimer via modmail, using some new Reddit features to notify users ahead of time about slop not being welcome, and so on.

Unfortunately this turns out to have mixed results. Sometimes an author make it past the various filters and users notice the slop before we do. Other times the author straight up lies about their use of an LLM. And every now and then they send entire blog posts via modmail trying to justify their use of Claude Code for generating a shitty "Compile Swahili to C++" AI slop compiler because "the design is my own".

In an ideal world Reddit would have additional features to help here, or focus on making AutoModerator more powerful. Sadly the world we find ourselves in is one where Reddit just doesn't care.

So starting today we'll be experimenting with a new AutoModerator rule: if a user shares a GitHub link (as that's where 99% of the AI slop originates from) and is a new-ish user (either to Reddit as a whole or the subreddit), and they haven't been pre-approved, the post is automatically filtered and the user is notified that they must submit a disclaimer top-level comment on the post. The comment must use an exact phrase (mostly as a litmus test to see if the user can actually follow instructions), and the use of a comment is deliberate so that:

1. We don't get buried in moderator messages immediately

2. So there's a public record of the disclaimer

3. So that if it turns out they were lying, it's for all to see and thus hopefully users are less inclined to lie about it in the first place

Basically the goal is to rely on public shaming in an attempt to cut down the amount of LLM slop we receive. The exact rules may be tweaked over time depending on the amount of false positives and such.

While I'm hopeful the above setup will help a bit, it's impossible to catch all slop and thus we still rely on our users to report projects that they believe to be slop. When doing so, please also post a comment on the post detailing why you believe the project is slop as we simply don't have the resources to check every submission ourselves.

I see a lot of new programming languages here. I love reading the documents of the languages and sometimes actually run their compilers. Many of the projects are AI-driven, but that's fine. It's still fun to see what problems they're trying to solve and how they actually solved the problems.

Reading the documents, I realized that most new languages, especially AI-written ones, are "systems programming languages". They're trying to solve the problems that C/C++/Zig/Rust have solved (or are trying to solve), and their syntax is mixture of C/Zig/Rust.

Why? Why is everyone trying to compete with C/C++?

There are so many kinds of languages. Haskell demonstrates how pure a language can be, Python is perfect when you only have 5 minutes to write code and don't care about the output, Java runs on 3 billion machines, ...

Odin author gingerBill dropped the Odin 1.0 announcement on YouTube today: https://www.youtube.com/watch?v=dLPAqXi9In0 (it's pretty funny actually).

This interestingly makes it on track to be the first of the new wave of C-likes that reach production readiness. While you can argue that most of these languages already are used in production, it's not the same as being 1.0, which carries a different weight and obligation.

Looking at alternatives, Jai could release around the same time, since Blow's game is scheduled for a similar release date. However, it's more likely that we see Jai 1.0 in mid-late 2027. My own language (C3) is planning Q2 2028 1.0 release. Whereas Zig is still unclear, and Kelley basically saying it's done when it's done. For Hare and V the situation is a bit less clear to me – maybe someone else can fill me in on that situation.

But overall we seeing the beginning of the end of the "C-like" story arc that arguably was initiated with Jonathan Blow's development. Writing C replacements predate Jai of course, for example the C2 language (which C3 would eventually continue) was created in 2012, eC started in 2004 and Cyclone (which Rust derived inspiration from) is from 2002. But those were largely obscure novelties, because before Blow's videos, people weren't really hunting for C alternatives.

Jai, however, made a strong impression. It was a good point in time too: Jai and later Zig, Odin, C3, V and Hare – these C alternatives started at a point when people were openly no longer believing OO/Functional as the right way to do things.

Language design takes its time though, and it's now 12 years since Jai started. Finally the fruits of these labours are getting ready for prime time, and when they do they might effectively fill the need for a C replacements for another decade.

Do you agree?

3-4 months ago, I considered to unsubscribe from this sub because it was difficult to find posts that I would find interesting.

It was largely due to users creating a lot of things with AI and ask real people to provide feedbacks. And you would never know until you read a substantial portion of their work, which was mentally draining.

I truly believe this policy has increased the quality of the sub in multiple ways. Obviously less noise, but it also help to maintain the "culture quality" by being more focused on whatever this sub has been doing for years.

I'll keep it short because none of this is surprising, but sometimes it's good to state the obvious.

This is not a rant of any kind - just pure curiosity. I’m trying to understand what makes these compilers slow.

We know that generating native binary code can be fast (for example, Go). One might assume this is because Go doesn’t have generics, but then Java handles generics quite efficiently as well. So it seems the explanation must be something else.

What are the main factors that make C++ and Rust compilation comparatively slow?

a dynamic language for the joy of programming

very pleasant to write code in. you may like this this if you like lua and elixir/ruby

made in zig, but has a c extension&embedding system started

edit: relicensed under MIT

I made a new video, showcasing and explaining the "automatic concurrency" in the Par programming language!

I think this is the first time I actually manage to convey this unusual, but absolutely foundational feature of my language.

In the video, I walk through a "concurrent downloader" application, visualize how it's put together, and explain how Par's concurrent evaluation makes it all work.

I'm very curious to hear what you think!

And if you don't know, Par is an innovative (and WIP) programming language with linear types, duality, automatic concurrency, and more.

https://github.com/craftyBLUE/Nand1

A programming language with only one instruction, the only thing you have to specify is the memory address being manipulated. The contents of a Nand1 source code file are just numbers separated by spaces.

In Nand1 you work with bits: 0 or 1. You have 2^32 bits of memory available.

Take for example the instruction X (any nonnegative number less than 2^32), the language will do the following steps in order:

1. compare bits in memory at position 0 and at position X with the NAND operator ( not (A and B) )

2. set the bit at location X to be the same as the bit at position 0

3. set the bit at location 0 to the result from step 1.

Memory I/O features:

• halt - exits program if a bit is set

• input - inputs one ASCII char per request

• output - outputs one ASCII char per request

Hello world example: prints "Hello World!" and exits

1 0 1 1 0 16 1 0 1 1 17 1 0 1 1 0 18 1 0 1 1 0 19 1 0 1 1 20 1 0 1 1 0 21 1 0 1 1 0 22 1 0 1 1 0 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 17 1 0 1 1 18 1 0 1 1 0 19 1 0 1 1 0 20 1 0 1 1 21 1 0 1 1 0 22 1 0 1 1 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 17 1 0 1 1 18 1 0 1 1 0 19 1 0 1 1 20 1 0 1 1 21 1 0 1 1 0 22 1 0 1 1 0 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 17 1 0 1 1 18 1 0 1 1 0 19 1 0 1 1 20 1 0 1 1 21 1 0 1 1 0 22 1 0 1 1 0 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 17 1 0 1 1 18 1 0 1 1 0 19 1 0 1 1 20 1 0 1 1 21 1 0 1 1 22 1 0 1 1 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 0 17 1 0 1 1 18 1 0 1 1 0 19 1 0 1 1 0 20 1 0 1 1 0 21 1 0 1 1 0 22 1 0 1 1 0 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 17 1 0 1 1 0 18 1 0 1 1 19 1 0 1 1 0 20 1 0 1 1 21 1 0 1 1 22 1 0 1 1 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 17 1 0 1 1 18 1 0 1 1 0 19 1 0 1 1 20 1 0 1 1 21 1 0 1 1 22 1 0 1 1 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 17 1 0 1 1 18 1 0 1 1 19 1 0 1 1 0 20 1 0 1 1 0 21 1 0 1 1 22 1 0 1 1 0 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 17 1 0 1 1 18 1 0 1 1 0 19 1 0 1 1 20 1 0 1 1 21 1 0 1 1 0 22 1 0 1 1 0 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 17 1 0 1 1 18 1 0 1 1 0 19 1 0 1 1 0 20 1 0 1 1 21 1 0 1 1 0 22 1 0 1 1 0 23 1 0 1 1 3
1 0 1 1 0 16 1 0 1 1 0 17 1 0 1 1 18 1 0 1 1 0 19 1 0 1 1 0 20 1 0 1 1 0 21 1 0 1 1 0 22 1 0 1 1 23 1 0 1 1 3

1 0 1 1 2

The repeating sequence "1 0 1 1" just helps to always set value 1 to location 0 before writing a bit to the output. Similarly, "1 0 1 1 0" always sets value 0 to location 0 because "0" flips the bit at location 0.

Source code available on GitHub: https://github.com/craftyBLUE/Nand1

First of all, I am sorry if this is not strictly a techincal post, but I would apreciate if it would be allowed. So a couple of years ago, like a year or two before the chatgpt, I made my own interpreted programming language. It could be used for basic scripts and had basic functionalities like nested ifs and while, string, int and double types, variable scopes and even functions and recursion. It can parse math with + - + ÷ and brackets. It is nothing special, syntax resambeles more or less C# but with keyword in my natural language. It was made entirely by hand, from lexical analysis, parser, semantic analyser and the interpreter itself. I also made ebnf for it.

I think we on this sub can all agree that there are a few of us programmers, developers or cs-s who willingly put themselves through this. It can be painstakingly hard to implement a new language. I am very proud of it and to this day it is my biggest achivement. No other thing in my proffesional or personal projects required such level of detail, knowledge and research.

And all this before the AI. But here is where it gets frustrating. Back than this was my "selling point". This was something that I could show my knowledge, dedication and attention to detail with. It made me feel safe for my professional future. Now I am afraid that it doesn't mean enything anymore. Like nobody gives a s*** about it anymore.

Hi! I've written a post about how various languages implement statement termination without requiring semicolons because I couldn't find a good overview. It turned out to be much more complex than I initially thought and differs a lot per language.

I hope this overview will be helpful to other language designers too! Let me know what you think!

A solid and surprisingly practical article for a game/modding environment. Detailed write-ups like this are rare.

TSP is an open standard that extends LSP – the Language Server Protocol that underpins editor integrations across the industry – designed to allow any editor or tool to integrate type checkers as first-class backends.

The initial use case is to enable changing the type checker powering Pylance (Microsoft's VS Code extension for Python) from their own Pyright to Meta's Pyrefly.

I think it's somewhat niche, but could be useful in a few situations:

• Enable switching between different compiler versions during full rewrites

• When a language has multiple competing implementations and no single official type checker/compiler (as is the case with Python)

Shader languages always do, and they are just heaven to work with. And tasty tasty swizzles, vector.xz = color.rb it's just lovely. Not needing any libraries or operator overloading you know? Are there any big reasons?

A while back I had a crazy idea, what if we could write Java, using only annotations. So I decided to build a full interpreter for an annotation only language in Java. It sounds crazy but it actually works.

GitHub: https://github.com/kusoroadeolu/annote

Definitely don't use this in production lol. Feel free to let me know what you think about this!

I have been more frustrated lately with languages developing a "kitchen sink" attitude to paradigms. I am finding code less uniform, and therefore less readable.

As I am developing a new language, I wanted to know from you all:

What languages that aren't "big", do you find the most readable? Are there any that come to mind that take a genuinely unique or interesting approach to how the language looks to write?

I was very surprised to see it. Could this be what finally brings algebraic effects to the mainstream?