Brainrot Programming Language

Brainrot is a meme-inspired programming language that translates common programming keywords into internet slang and meme references. It's built using Flex (lexical analyzer) and Bison (parser generator), making it a fun way to learn about language processing and compiler design.

History

The TRUE history behind the Brainrot programming language can be found here.

🤔 What is Brainrot?

Brainrot is a C-like programming language where traditional keywords are replaced with popular internet slang. For example:

• void → skibidi
• int → rizz
• for → flex
• return → bussin

📋 Requirements

To build and run the Brainrot compiler, you'll need:

• GCC (GNU Compiler Collection)
• Flex (Fast Lexical Analyzer)
• Bison (Parser Generator)

Installation on Different Platforms

Ubuntu/Debian

sudo apt-get update
sudo apt-get install gcc flex bison libfl-dev

Arch Linux

sudo pacman -S gcc flex bison

macOS (using Homebrew)

brew install gcc flex bison

Some macOS users are experiencing an error related to libfl. First, check if libfl is installed at:

/opt/homebrew/lib/libfl.dylib  # For Apple Silicon
/usr/local/lib/libfl.dylib  # For Intel Macs

And if not, you have to find it and symlink to it. Find it using:

find /opt/homebrew -name "libfl.*"  # For Apple Silicon
find /usr/local -name "libfl.*"  # For Intel Macs

And link it with:

sudo ln -s /path/to/libfl.dylib /opt/homebrew/lib/libfl.dylib  # For Apple Silicon
sudo ln -s /path/to/libfl.dylib /usr/local/lib/libfl.dylib  # For Intel Macs

For NixOS

git clone https://github.com/Brainrotlang/brainrot.git
cd brainrot
nix develop
# then create your .brainrot file
./result/bin/brainrot filename.brainrot

Or via a flake-based NixOS config (/etc/nixos/flake.nix), which always tracks the latest version:

# /etc/nixos/flake.nix
{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    brainrot.url = "github:Brainrotlang/brainrot";
  };

  outputs = { nixpkgs, brainrot, ... }: {
    nixosConfigurations.your-hostname = nixpkgs.lib.nixosSystem {
      modules = [
        ./configuration.nix
        {
          # For a specific user
          users.users.username = {
            packages = [ brainrot.packages.x86_64-linux.default ];
          };
          # For system-wide installation
          environment.systemPackages = [
            brainrot.packages.x86_64-linux.default
          ];
        }
      ];
    };
  };
}

Run nix flake update whenever you want to pull the latest version, then rebuild with sudo nixos-rebuild switch.

🚀 Building the Compiler

1. Clone this repository:

git clone https://github.com/Brainrotlang/brainrot.git
cd brainrot

2. Generate the parser and lexer:

bison -d -Wcounterexamples lang.y -o lang.tab.c
flex -o lang.lex.c lang.l

3. Compile the compiler:

make

NOTE: The gcc version we use to test is v13 if you get any warnings remove -Werror flag from the Makefile

Installation

sudo make install

Uninstall

sudo make uninstall

🌐 WebAssembly build

make wasm builds brainrot.wasm + brainrot.mjs using Emscripten — this is what powers the in-browser playground. Requires emcc on your PATH (install via emsdk):

make wasm

The interpreter is statically linked for this target (no libstdrot.so, no dlopen — see stdrot.c's STDROT_STATIC path), and takes its source file the same way the native binary does, via argv[1] written into Emscripten's in-memory filesystem before calling callMain.

Known platform-specific difference from the native build: sizeof(giga) is 4, not 8 — wasm32 uses the ILP32 data model (long = 4 bytes) instead of native's LP64 (#177). Everything else, including stderr, matches native exactly.

node tests/run_wasm_tests.mjs runs the same fixtures as the native pytest suite against the wasm build (checking the one difference above against its wasm-correct value instead of native's), and node tests/run_wasm_examples_check.mjs diffs every examples/*.brainrot program's stdout against a real native run. Run both after make && make wasm to sanity-check a build.

chill() calls sleep() under the hood, which blocks the JS thread it runs on rather than yielding — fine in a short-lived CLI run, but something a browser embedder (e.g. a playground) should account for (run in a Worker, expect the tab to be unresponsive for the duration) rather than assume it behaves like an async delay.

💻 Usage

1. Create a Brainrot source file (e.g., hello.brainrot):

 skibidi main {
    yapping("Hello, World!");
    bussin 0;
}

2. Run your Brainrot program:

./brainrot hello.brainrot

Check out the examples:

• Hello world
• Fizz Buzz
• Bubble Sort
• One-dimensional Heat Equation Solver
• Fibonacci Sequence
• Modules (#cooked)

🗪 Community

Join our community on:

• Discord
• Reddit

📚 Language Reference

Keywords

Brainrot	C Equivalent	Implemented?
skibidi	void	✅
rizz	int	✅
cap	bool	✅
flex	for	✅
bussin	return	✅
edgy	if	✅
amogus	else	✅
goon	while	✅
bruh	break	✅
grind	continue	✅
chad	float	✅
gigachad	double	✅
yap	char	✅
deadass	const	✅
sigma rule	case	✅
based	default	✅
mewing	do	✅
gyatt	enum	✅
whopper	extern	❌
cringe	goto	❌
giga	long	✅
smol	short	✅
nut	signed	✅
maxxing	sizeof	✅
salty	static	✅
gang	struct	✅
ohio	switch	✅
chungus	union	✅
nonut	unsigned	✅
schizo	volatile	✅
W	true	✅
L	false	✅
thicc	long long	✅
rant	string type	✅
lit	typedef	❌

Preprocessor directives

Brainrot	C Equivalent	Implemented?
#cooked	#include	✅
#edgydef	#ifdef	❌
#edgyndef	#ifndef	❌
#endedgy	#endif	❌
#slaps	#define	❌
#aura	#pragma	❌

#cooked "path/to/file.brainrot" splices another Brainrot file's functions and structs into the current one, resolved relative to the including file's directory. See the language reference for details (path resolution, include-once behavior, circular-include detection).

Builtin functions

Check the user documentation.

Operators

The language supports basic arithmetic operators:

• + Addition
• - Subtraction
• * Multiplication
• / Division
• = Assignment
• < Less than
• > Greater than
• && Logical AND
• || Logical OR

⚠️ Limitations

Current limitations include:

• Limited support for complex expressions
• Basic error reporting
• Struct/union function parameters and return values must be a plain struct/union variable of the exact declared type (no sub-expressions, e.g. a chained call or a member access) — arguments and return values are deep-copied, not aliased
• Arrays cannot be passed or returned by value (only via a pointer parameter, which aliases the caller's array like in C)
• ohio/based (switch/default): based fires as soon as the interpreter's scan reaches it, so its position among the sigma rule cases matters — placing it before a case that would otherwise match currently pre-empts that match (#179)

🗺️ Roadmap

Where Brainrot is headed — a native C ABI, generated library bindings (raylib first), threads, hashmaps and sockets — is documented in the roadmap.

🔌 VSCode Extension

Brainrot has a Visual Studio Code extension to enhance your development experience with syntax highlighting and support for the Brainrot programming language. You can find it here:

Brainrot VSCode Extension

🤝 Contributing

Feel free to contribute to this project by:

1. Forking the repository
2. Creating a new branch for your feature
3. Submitting a pull request

📝 License

This project is licensed under the GPL License - see the LICENSE file for details.

🙏 Acknowledgments

• This project is created for educational purposes
• Inspired by meme culture and internet slang
• Built using Flex and Bison tools

🐛 Issues

Please report any additional issues in the GitHub Issues section.