LLM-Lang: A Minimalist Programming Language for Machine Communication

This article introduces LLM-Lang—a minimalist expression-based programming language designed specifically for large language models (LLMs) and inter-machine communication. Its core features include: using highly compressed prefix notation to maximize context window efficiency; implementing a complete compiler with only 592 lines of Python code, which can compile source code into C and generate native binaries; eliminating syntax that is human-friendly but redundant for machines, focusing on core logic expression.

Traditional programming languages are designed for humans, containing redundant features like syntactic sugar and complex indentation, which consume LLMs' precious context window space and affect reasoning capabilities. LLM-Lang emerged to address this pain point: optimized for machine communication, it eliminates human-oriented syntax decorations and retains core expression logic.

LLM-Lang is based on the 'everything is an expression' philosophy, with no statements, semicolons, or curly braces. Key features:

• Values and Bindings: Supports multi-type values; variable binding uses =(x,5), function definition uses f{name,p1,p2,body} (implicitly returns the last element).
• Control Flow: Ternary condition ?(cond,then,else), loop @(init,cond,step,body), sequence ;(e1,e2,e3) (returns the last result).
• I/O and Memory: Standard I/O (wr/wp/rd), file operations (rf/wf), and low-level memory operations (ma/mr/mw/mc) support hardware register access.
• List Operations: Higher-order functions map/flt/fld enable declarative data processing.

LLM-Lang's compilation process is efficient:

1. Parsing: llmc.py uses a recursive descent parser with 12 rules to build an Abstract Syntax Tree (AST).
2. Code Generation: Traverses the AST to generate equivalent C code, using tagged unions to implement dynamic typing.
3. Native Compilation: Calls GCC (with -O2 optimization) to generate target platform binaries. No complex toolchain is needed throughout the process—only Python3 and GCC are required.

Applicable scenarios for LLM-Lang:

• Inter-Machine Communication: Used as an intermediate representation when AI agents collaborate, reducing communication overhead.
• Embedded Programming: Direct memory operations support microcontroller firmware/driver development; compiled C code can be optimized for specific architectures.
• Code Generation: Serves as a metaprogramming intermediate layer—LLMs generate LLM-Lang which is then converted to the target language, offering more control.

Sample Code:

• Hello World: wr("Hello, World!")
• Read input until EOF: @(=(s,rd()),s,=(s,rd()),wr(s)) (loop to read and output)
• Read with counter: ;(=(n,0),@(=(s,rd()),s,=(s,rd()),;(=(n,+(n,1)),wr(cat(n,cat(": ",s))))),we(cat("total: ",n)))

Design Trade-offs: Proactively abandons comments, whitespace sensitivity, infix operators, and type declarations—all optimizations for inter-machine communication scenarios.

LLM-Lang is an experiment that challenges the assumption that 'programming languages must be designed for humans'. As AI agents interact autonomously more frequently in the future, such machine-optimized languages may become infrastructure for intelligent systems. The project demonstrates the power of minimalism with just 592 lines of code: the most powerful tools are often those focused on solving specific problems.