Stop customers and competitors copying, cracking or reselling the software you sell. Python, JavaScript, PHP, .NET/C#, Java and Go — SHIELD detects the language and applies the strongest protection that language honestly allows. Every engine and its toolchain ships inside the installer, so it runs on a bare machine with nothing installed and nothing ever leaves your computer. We publish exactly what each language gets, and what it can't.
Prefer the Store? Get it from the Microsoft Store — Microsoft-verified, no security warning on install.
One command, four languages. SHIELD detects each file and applies the protection that language honestly allows — and states plainly when a compiled binary can't be source-obfuscated.
Interpreted code (Python, JavaScript, PHP) travels as readable source. Compiled binaries (.NET, Java, Go) travel as decompilable IL or a strippable native image. Either way, it is now on a machine you don't control — and the tools to read it back are good.
A JavaScript bundle is your logic in plain text. A PHP file is its own
source. A Python app decompiles almost perfectly — PyLingual
(IEEE S&P 2025) recovers 95.9% of Python 3.11 source. A .NET DLL
opens cleanly in a decompiler; a Java .jar the same. A Go
binary hides the source but a licence check inside it can be patched
out without recovering anything.
SHIELD does not pretend any of this is unbreakable. The machine has to run the code, so it has to be able to decrypt it. Obfuscation raises the cost of copying — it is not encryption. We say that on the tin.
What SHIELD does is apply, per language, the strongest defence that language honestly supports — heavy source obfuscation where the source ships, binary sealing where it doesn't — and, for Python only, it can move crown-jewel logic off the client entirely so that part is never present to recover.
We measure what we sell in time — cost in hours — and we publish the method for every language so a sceptic can check it. And SHIELD protects its own code with its own engine: a protector that can't protect itself sells nothing.
The honest part: protection is bounded by what each language allows. Interpreted languages get heavy source obfuscation; already-compiled binaries get binary sealing, not fake source hiding. We label which is which — ● source-level, ● binary-level.
.pyd compile (Cython + bundled mingw), fully offline
Ceiling: the local stack is a cost-raiser, not a wall — but a
@shield.remote body is genuinely absent from the client.
AV-clean native runtime.
Honest limit: there is no offline machine-code path for JavaScript, so it is not native-compiled — this is strong obfuscation, which raises copying cost, not encryption.
Honest limit: obfuscation raises the cost of reading the source; it is not encryption. PHP stays PHP — the runtime must still execute it.
Be explicit: .NET is already compiled to IL, so SHIELD does not re-obfuscate your source. This is binary protection (seal + anti-debug), not source hiding — a straightforward alternative to .NET / C# DLL obfuscation when what you need is to stop the assembly being copied and run elsewhere.
Be explicit: Java is already compiled to bytecode, so SHIELD does not re-obfuscate your source. This is binary protection (seal + anti-debug), not source hiding — an alternative to Java / JAR obfuscation when the goal is to stop the artifact being copied and run on another machine.
go build — a native, symbol-stripped binary
Honest: go build already compiles the source away,
so SHIELD does not "obfuscate Go source" — it ships it stripped
and sealed. For Go binary protection, that binding-to-one-machine is
the protection that actually matters.
Every install ships all six engines. Your licence unlocks what you bought, and the per-language entitlement is Ed25519-signed — it cannot be forged by editing a file. Buy one language, add more later, or take the full suite.
Python is the flagship because it supports things the other languages can't: moving logic off the client, and compiling to native machine code. Only the first may be called uncrackable — because it is not present to crack.
Mark a crown-jewel function @shield.remote. At build time
SHIELD carves its body out and runs it on your server. The customer's
copy has a literal hole where the logic was.
Truth: an AST pass extracts each remote body to a server-only
artefact and replaces it with a stub calling
__shield_call(). The body appears nowhere in the client.
This is the one layer we call uncrackable — it is not present to crack.
A crown-jewel function that must stay local — offline, or on a hot path
— is compiled to C and shipped as a native .pyd. No Python
source or bytecode of it exists in the app.
Truth: numeric functions go Python → C → MSVC .pyd
with per-build variance. A decompiler gets x86, not liftable Python. On
ineligible code the build skips it safely — it never breaks.
Nuitka keeps names readable; SHIELD emits opaque mangled C.
Sealed to decrypt and run only on the licensed machine. Copy it elsewhere and it refuses cleanly — an honest error, not plausible garbage. This layer is shared: it protects every language, and is the whole story for the already-compiled ones.
Truth: the key is derived from the machine fingerprint via PBKDF2-HMAC-SHA256 (200k rounds), AES-256-GCM. The honest limit, stated in the code: this defeats distribution (useless elsewhere), not inspection on the licensed box. The claim is “you cannot share it”, never “the owner cannot read it”.
No “unbreakable” for anything that runs on the attacker's machine. That claim is falsifiable in an afternoon, so we do not make it. Here is the honest ceiling instead.
A skilled attacker on the licensed machine can dump decrypted code objects from live memory. The layers share that one exit, so they fall together, not one by one. These figures are for the Python stack, red-teamed against our own design — the same honesty (cost in hours, not "unbreakable") governs every language:
local code-object dump · under 1 day full licence crack · 1–3 days lift the whole VM · 1–2 weeks
Before SHIELD, the “before” number is seconds — unpack, then PyLingual. Every layer we add is a measured jump in that number.
And for a @shield.remote function the number is infinite,
because the code is on your server, not the pirate's. That is exactly why the
headline is “move the secret off the client” rather than “make the
client unbreakable”.
Honesty as a feature, not a hedge. SHIELD's risk analyser flags when moving a function server-side gives false security: a function with a small, enumerable input/output space can be learned by watching its answers even when its body is hidden — so it warns you at build time instead of letting you ship false confidence. Anti-debug, likewise, is a cost-raiser, not a wall.
All six engines ship in one app, and the shared machinery below serves every language. Where it can, each layer ships zero-dependency, and every “safe” behaviour — skip-not-break, refuse-not-fake — is tested, not asserted. The Python-specific layers are marked.
Node, PHP, Go and mingw ship inside the installer, so every language protects on a bare machine with nothing installed — proven to run with an empty PATH.
100% offline after licensing
Your licence carries a signed languages field. Editing a
file to unlock a language you didn't buy fails the signature check — it
cannot be forged.
tampered licence → rejected
SHIELD native-compiles its own Python modules with its own engine, so only machine code ships. A protector that can't protect itself sells nothing.
dogfood · no third-party obfuscator
Warns when moving a function gives false security instead of protection.
analyse_risk() flags no-arg / boolean-gate fns
Under a debugger the result is silently corrupted, not cleanly disabled. A clean run is bit-exact. A cost-raiser, not a wall.
native is_debugged() + guard()
Logic shape becomes an unreadable state machine. Loops and try-blocks are skipped, never mis-flattened.
body → dispatch loop
Grep, hex and disassembly find no readable keys or endpoints. Python source-to-source; JavaScript via string-array encryption.
lazy decryptor · 4/4 secrets hidden
Per-licence auth, one-key-one-machine binding, rate-limited. Provably isolated from the other live ARIA products.
ShieldServer.call()
Issue, list, revoke and release keys. Bound on first use.
secrets.token_hex(16)
The whole pipeline runs from a single command, and it is included in CI/CD with no cap on build machines.
shield build app.py [--seal-this-machine]
The .pyd scanned clean by Windows Defender — where
PyArmor's runtime is flagged Trojan.Python.
MpCmdRun · “found no threats” · 2026-08-14
Artifacts are signed when a real cert is present and verified after — never a fabricated signature. The build report says exactly what each file got, per language.
pkg/sign.py · no cert → honestly unsigned
Offline, stated before you buy: after a one-time activation, protection is
100% offline — nothing leaves your computer, because every toolchain ships
in the installer. The single exception is Python functions you deliberately
mark @shield.remote, whose bodies run on your own server by
design. You decide which functions go remote.
Python is the most-contested engine, so here's the head-to-head with PyArmor and Nuitka — not where the math is weakest, but where a customer actually gets burned. The one thing a competitor structurally cannot copy is this honesty.
| The crown-jewel logic | PyArmor / Nuitka hand it to CPython as a real code object — dump it there, recover it. SHIELD: Split-Brain, it isn't shipped at all, so there is nothing to dump. |
|---|---|
| Antivirus | PyArmor's runtime has been flagged Trojan.Python.
SHIELD: signed, AV-clean runtime, Defender-verified. |
| Release day | A build-time online licence check can fail mid-release. SHIELD: never phones home on release day. |
| CI/CD | Pro and Group tiers forbid it — the jump from roughly $90 to $1,900. SHIELD: included in the base price, unlimited build machines. |
| Symbol names | Nuitka keeps them — strings works; Cython leaks
docstrings and signatures. SHIELD: native .pyd
is opaque mangled C. |
| Copying the build | The blob is identical on every host — dump once, share everywhere. SHIELD: hardware-keyed; a copy runs only on the licensed machine. |
| Upgrades | Per-major-version re-purchase (v8 → v9). SHIELD: annual, all-inclusive, no re-buy. |
| Marketing | Sells “unbreakable” — can't publish crack-times without admitting it. SHIELD: publishes the method and the measured cost. |
Counts a sceptic can check.
The deployment is isolated: the SHIELD licensing server runs behind nginx with an auto-renewing Let's Encrypt certificate, iptables-firewalled, and provably separate from the other live products on the same box — both of which stayed up through every step of the deploy.
Every install ships all six engines; you pay to unlock what you need — one language, any few, or the whole suite. The more you add, the less each costs. On sale now; run the free trial on a real file in your own pipeline first if you like. Prices shown are the India band; checkout detects your region and shows the right currency.
Any one of Python, JS, PHP, .NET/C#, Java or Go
All six languages, one licence
The flagship engine can be bought for longer terms:
1 year · ₹6,999 / $99 2 years · ₹11,999 / $169 3 years · ₹15,999 / $239
Annual, not perpetual — a perpetual licence is meaningless when runtimes and toolchains move under you. A free trial lets you protect a real file in your own pipeline before paying, and you pick which language to trial.
Try free first. Run the trial on a real file in your own pipeline — you pick which language — before you pay. Payment is by Razorpay (UPI · card · net banking); your licence key is emailed on purchase. Questions? support@myaria.in.
Six: Python, JavaScript, PHP, .NET/C#, Java and Go. Every install ships all six engines; your licence unlocks what you bought. What each language gets differs by what is honestly possible — Python and JS/PHP get source-level protection, while .NET, Java and Go are already compiled, so they get binary sealing plus a native anti-debug guard, not source obfuscation. The full breakdown is above.
No. A protected build behaves identically to your original — a clean run produces the same output, bit for bit. SHIELD is conservative by design: any function or file it can't protect safely is skipped and reported, never mis-compiled, so one awkward piece of code can't break your build. You get a plain report of exactly what was protected and what was left as-is, and you can run the free trial on a real file in your own pipeline before you buy.
No — and we will not say it is. The machine has to run the code, so it has to be able to decrypt it; anything that runs on a machine you don't control can eventually be recovered there. Obfuscation raises the cost of copying — it is not encryption. What SHIELD changes is time: seconds become far longer. And for Python specifically, it can move crown-jewel logic off the client entirely, so that part is not there to crack. This honesty is the positioning, not a weakness.
No. After a one-time licence activation, protection is 100%
offline — nothing leaves your computer. Every language's toolchain
(Node, PHP, Go, mingw) ships inside the installer, so it works on a
bare machine with nothing installed. The one exception is Python
functions you deliberately mark @shield.remote, whose
bodies run on your own server by design.
No, and we say so plainly. .NET/C# and Java are already compiled to
IL/bytecode, so SHIELD does not re-obfuscate their source — it applies
a hardware seal (the binary opens only on the licensed machine) plus a
native anti-debug guard. Go's own go build compiles the
source away; SHIELD ships it stripped and sealed with a debugger-aware
launcher. This is binary protection, not source hiding.
The Python native runtime scanned clean by Windows Defender on
2026-08-14 — a measured advantage, since PyArmor's runtime has been
flagged Trojan.Python. When we have a real code-signing
certificate, artifacts are signed and verified; without one they are
left honestly unsigned rather than faking a signature.
Yes. SHIELD native-compiles its own Python modules with its own engine, so only machine code ships — no third-party obfuscator involved. A code protector that cannot protect itself proves nothing, so we dogfood it.
Windows 10 and 11, 64-bit. SHIELD is on sale now: ₹6,999 / $99 a year per language, or ₹19,999 / $279 a year for the six-language Suite — buy either from the pricing section above. Payment is by Razorpay (UPI, card, net banking); your licence key is emailed on purchase. A free trial lets you protect a real file in your own pipeline first, and you pick which language to trial. Questions? support@myaria.in.
Python, JavaScript, PHP, .NET/C#, Java or Go — harden what ships, seal it to the licensed machine, and do it all 100% offline with every toolchain already inside the installer. Honest about the ceiling, for every one.
On sale now — one language ₹6,999 / $99 a year, or all six for ₹19,999 / $279. Buy above, or run the free trial on a real file first.