Every AZRA file opens with two lines that look almost like formalities — `Imvoke` and `World-type`. They aren't. Together, they define what's called the **Target System**: the specific source system, user, and environment a piece of AZRA code is currently running on and authorized to execute in.

 What Goes Into a Target System


At the top of every file, `Imvoke` must declare the source system — the system the code is actually running on — along with a user identity, something like:

Imvoke(:"system/64/user.001.alpha")


This tells the execution environment exactly which system this code is running on and for which user. Right beneath it, `World-type` must include that same system's IP address:

World-type(:Azra | [ip=127.0.0.1])


Together, these two lines tell the AZRA ecosystem something very specific: this exact configuration — this system, this user, this IP — is the environment this code is authorized to run in.

Why Bind Code to a System at All?


The point is simple: prevent code from being copied, moved, and executed somewhere it was never authorized to run. Without this binding, an AZRA file could be lifted off one machine and run anywhere, with no way to verify whether the execution environment was ever authorized in the first place.

By requiring the source system's identity up front, AZRA makes unauthorized redistribution and casual "system hacking" — running code on a system it was never authorized for — significantly harder. If a system other than the one specified attempts to execute the file, execution is denied outright. No `Imvoke`, no authorization, no run.

A note on where this is headed: right now, this syntax only defines the *source* system — the system the code is currently running on. A future addition to AZRA's syntax is planned that will allow a target/destination system to be defined as well — describing where the code is meant to be sent or moved to. This part of the syntax is still under development.

Is There Actually Going to Be Dedicated AZRA Hardware?


This is a question worth answering directly, because it sounds like a big claim: yes.

The Target System is officially defined as having two possible forms:

1. The system the code is currently written on and executed from.
2. A dedicated device built specifically to execute the AZRA language.

That second form isn't a hypothetical. Purpose-built AZRA hardware is a real, planned part of where this project is headed — a machine designed from the ground up to run AZRA natively, rather than emulating it on general-purpose hardware. It's an early-stage direction, and details will be shared as it develops, but the intent behind it is confirmed.

Why This Fits AZRA's Bigger Picture


This isn't a random feature bolted onto the language. It's consistent with everything AZRA has been built around: security starting at the syntax level, files that only trust other AZRA files, and a compiled, binary-first execution model built for real hardware speed. The Target System is the piece that ties code to its *specific* source system, not just *a kind* of system — and dedicated AZRA devices are the natural extension of that same idea.

What's Next

As more of AZRA's variable system and compiler capabilities take shape, expect the Target System concept to grow alongside them — particularly with the planned addition of destination-system syntax, which will offer richer ways to describe not just where code is currently authorized to run, but how it's meant to move through an AZRA-based ecosystem over time.