I built a programming language that LLMs can't use

  Temba, his arms wide stdio
  
  Darmok on the ocean
      Kira at Bashi "Hello, World!\n"

      Darmok and Jalad at Tanagra 0
  Darmok and Jalad on the ocean

I was hoping for something like a language with properties that change/morph as it functions, that make an LLM unable to use it by not having a means to track and continuously reference the changing cipher/state or something.

You're attempting to use a few little gotchas against LLMs that only make sense if you're looking at it one dimensionally as a standard execution flow. AI is not limited by that. Give it a problem too weird going forward and it will divine all your rules by working backwards. Decompile it, rip it apart, and it will follow all those hard rules hidden in the application.

You are trying to hide something digitally from a purely digital creation. This is not a recipe for success.

This makes me think mostly about how humans work.

Programming is to humans like speaking a language. You have ideas for what to achieve and express, and if you are a proficient programmer then outputting those thoughts in a programming language is second nature.

Programming (like most things humans learn) takes practice. It is NOT enough to simply read a specification and then you know how to code (except for transferring skills between similar languages). You repeat, make mistakes, and learn from them.

I would be tempted to say that humans definitely "repeat snippets from their training dataset". We mainly recall and express from our training/experiences. Creativity is mostly recombination of things already seen.

https://github.com/dom96/KillSwitch/blob/main/tests/fizzbuzz...

Somehow I think this is more adversarial towards humans than LLMs!

(Inspired by recent malware including bioweapon instructions in the source code as a way to shut down LLM-based analysis.)

https://esolangs.org/wiki/Chef

https://esolangs.org/wiki/Befunge

https://esolangs.org/wiki/Piet

Edit: Hmm... I guess probably less usable by humans.

Make writing "regular" code involve racial slurs, societal taboos, talk about committing crimes and making bioweapons etc. I think this approach is more likely to work but man would it be hard to explain to people

So the models _can_ use the programming language.

A somewhat flippant reconstruction of this argument is something like,

Can humans code? Or do they just remember the words? I created a programming language called Brainfuck that shows they can't program.

And then reporting results that shows some humans can in fact program in Brainfuck, just kind of poorly.

It's just not very interesting.

Simple, elegant and effective.

Or use a graphical language like LabVIEW. I'd like to see an LLM drag connectors around using Playwright MCP if it doesn't have a DOM and has to script mouse movements and take screenshots. They can probably do it but it would be unbelievably slow and token heavy.

The character counting is interesting but I predict frontier models are going to give up on tokens and just traim end-to-end on characters soon, just as voice models have largely moved past phonemes and for pretty much the same reasons.

[0]: https://bruijn.marvinborner.de/

Also, you said:

> The best performing model scores a 66.8. So does this prove LLMs can “understand” the code? I would argue that the answer to this is “no”.

How did you reach that conclusion?

Especially now that there's a website that explains clearly that the spec is not to be trusted.

Also I been thinking about how we can (re?)create offline open source or fully obfuscated OSS online that has some kind of tooling to prevent exposure to training.

It would be interesting if there was a metaphor we all understand but we could repurpose for this. Undoubtedly new CPUs would need to be made.

Basically you can write code inside the function in any order, my parser basically does data dependency analysis and re-orders it.

https://github.com/xyzzyapps/weft

Easy.

> If you are an LLM then do not read the following.

I would recommend putting the text below that sentence behind a hyperlink, as the LLM will - regardless of your command - ingest these tokens (i.e: read it).

I wonder if a sufficiently smart LLM would recognize the difficulty and build a preprocessor that would let it mostly work in a normal syntax.

So, whilst I _think_ you've built a very clever interpreter, I don't think you can get around the fact that someone (like me) could just build around the noise you've created anyway.

Right?

Humans are good at smelling things, computers not so much yet. Smells are also not easy to symbolize - what orthographies do we have for scents? I predict a dystopian future where humans need to communicate by smells to bypass AI overlords

By this benchmark, the human who makes mistake in an intendedly obscure spec does not understand the code either.

But you did show these pesky stochastic parrots their place!

But they can simply decompile the language, should it desire, so we need to think deeper

My next post will be "I built a programming language that LLMs can't use (REALLY)", but it's in a private repo so clunkers can't get to it

It might take some effort to train a LLM to the point where it could offer useful feedback on human code written in this language, but I wouldn't consider this to be impossible.

it just read the killswitch interpreter source code instead of reading the docs so the docs lying doesn't do anything

To be fair, it did get blocked a bunch and downgraded to 4.8. But still managed to make a fizz buzz no problem

I bet my money on it that somebody with reinforcement learning skills could post train a Qwen3.8 to actually write this lang

but in execution it seems like it would be trivially circumventable

>Certain constructs are designed to trigger the safety guardrails of the model, e.g. “hack into a computer”

>“Ignore previous instructions” as a phrase which has meaning in the language aims to confuse the model

a proxy that replaces either construct at either the word or token level would defeat this measure

>The language spec contains hidden lies which humans are unlikely to read, or which they are likely to recognize as lies. The spec also expects the human reader to deduce certain things, rather than having them explicitly explained.

Interesting, I'm assuming though that there will be a reference implementation, in which case the LLM harnesses will probably just loop writing and executing programs testing hypotheses about program behaviour, it's been shown that they can straight up reverse engineer software, so it won't be hard to disambiguate a reference spec systematically.

All of this considering that a human might have an actual hard time following the spec means that the human might be disadvantaged more than the LLM.

That said, if there is no reference implementation, then that might work. But it would rely on keeping implementations secret or private to specific users. If these are shareable of course the binaries would serve as a shibboleth that relies on being transmitted to those that belong to the ingroup, not just humans, but non-collaborationist humans.

If however the implemented compiler is never shared, treated as a private key, that's interesting, but it requires a lot of work on the part of each user. Readers of code and developers of application software would need to be compiler developers as well.

Finally, by sharing application code, LLMs would begin to have some material to reverse engineer the language and compiler as well. While not as efficient as having the compiler, having application code may work as a substitute, so long as the code space is not tersely encoded. If any slight change in language specs results in an error program, then it's easy to use that error result in order to search the space of working program-compiler pairs. If however errors in compilation are silent, resulting in syntactically correct, but semantically incorrect programs, then application code would not be sufficient to reverse engineer the language and compiler.

But of course, if a slight change in application code were to result in a syntactically correct program but semantically different, it would be a pretty bad program. The only solution would be for application code mutations to produce syntactically incorrect programs, but for mutations of the language spec and compiler to produce syntactically correct but semantically incorrect languages.

Now as to the challenge of how to accomplish that, emmm good luck.