Open the folder of any typical codebase and you'll see filenames like `main.py`, `index.js`, or `utils.cpp`. AZRA breaks from that completely: every file must be named using numbers only.

1.azr
561.azr

The reasoning behind this goes back to AZRA's underlying philosophy, its technical design, and how compilers and target devices read the file itself.

 Numbers Over Letters, By Design


If you look at how AZRA already works, it leans on numbers more than letters — the same way variable names are built. `-0x`, `-1y`, `-2z`: every variable carries a sequential numeric index before its name. Filenames follow that same logic. This was a deliberate choice to introduce a security layer that usually doesn't get much attention: the filename itself.

 A Familiar, Modern Example


Here's a simple, everyday example that connects directly to this.

When you hand a file to an AI tool, it often names the output for you. If you're not happy with the result, or want to keep developing it, the AI tends to add more words on top — things like `fixed`, `updated`, `final`, `full`. After a while, you're left confused about which file to upload, or which one was actually the latest version.

But when a file shares a common name and only a number changes in front of it, you instantly know which one is the latest — the versioning is obvious at a glance. Numbers, it turns out, can be easier for the human mind to track than an ever-growing string of descriptive words.

 It's Not Just About Human Readability


If that were the only reason, it would be a nice-to-have — not a rule. So here's more of what's actually behind it.

Compilation speed.AZRA compiles directly to binary. If files are numeric, that's one less thing the compiler has to parse and interpret as text — potentially shaving off even a few microseconds during execution. Small, but consistent with everything else in AZRA's design being built for raw hardware speed.

Security Characters in filenames can, in certain systems, open the door to real security issues — injection tricks, path manipulation, and other exploits that rely on parsing arbitrary text. Since AZRA is also designed with an eye toward being a Neuro-Level language — something we'll cover in a future post — it's safer, and more consistent with that direction, to work with numbers rather than letters wherever possible.

Tamper resistance. This is the most structural reason. A file's numeric name is meant to be called directly from within the code itself. If that number changes, the code simply won't run. If AZRA allowed character-based names instead, there would be known tricks to work around that binding — ways to spoof or bypass the connection between a file and the code that calls it. Numeric filenames close that door.

 The Bigger Picture

This is a genuinely new approach in the world of programming languages — trading the convenience of descriptive filenames for something faster, more precise, more secure, and, as it turns out, easier for a human to actually track over time.

Thanks for reading.