Encrypted Compilation and Execution


SCRAMBLECODE is a programming language, which protects each compiled instruction to the core to generate confidential tamper-resistant code. It can work with encrypted variables in memory during execution.

It is designed to address:
Application Integrity
IP Confidentiality
Reverse Engineering
Memory Attacks

Typical use include: License and digital rights management, cryptography, authentication, feature unlocking etc.

Right out of the box SCRAMBLECODE allows to:
  • Custom create VM engines
  • Compile with private instructions
  • Encrypt opcodes and operands
  • Protect classes as a block
  • Bundle routines to avoid bypassing
  • Use RSA signature authentication
  • Work with encrypted variables
  • Overwrite released memory with zero-bytes
  • Distribute protected code as base64 text
  • Deploy private VMs royalty free

SCRAMBLECODE VMs can only execute compiled code from its rightful owner -- preventing malicious exploitation.



SCRAMBLECODE allows the programmer to add self-defense capabilities to any type of software application or service. The flexibility of the language combined with the ability to provide trusted execution makes the possibilities limitless.

Protect confidential code using encrypted compilation and execution
SCRAMBLECODE protected code is easy to integrate with projects using C/C++, .NET, Python etc.
Strongly protected code can
  • securely access confidential material
  • verify the integrity of files and applications
  • be safely distributed via insecure channels
Security functions rooted in strongly protected bytecode can't be removed or bypassed by a third party, if ordinary functions essential for the application are mixed and bundled within.

Technical Summary: 

Intellectual Properties: 
SCRAMBLECODE can turn highly confidential code into strongly protected bytecode instructions, which are only executable by a custom created virtual machine (VM).
Note: The VM is a DLL that does not contain any valuable secrets. Confidential code should never exist as native machine code or in a similar easy attackable format.
Each VM targets a unique instruction set. It allows the compiler to generate different instructions for every development project.

The compiler also eliminates all meta-data and runtime information, and it generates instructions where each opcode and operand are encrypted individually to the core.

The compiler bundles and encrypts all instructions on multiple levels to ensure, that if a cracker tries to modify just one instruction, it will invalidate perhaps thousands of others. The generated block of encrypted code is also sealed using an RSA signature.

Secure Execution: 
When the compiled code is launched for execution, the VM engine loads the unique instructions while keeping vital encryption layers intact. At no point can multiple decrypted instructions be scraped from memory.

Each VM can create and execute many others within the same thread, but VMs can also be working in parallel (multi-threading).

Memory Protection: 
While the instructions are executed, they work with encrypted variables in memory. The location and encryption of a given item may differ on each execution. Instructions to push, pop, move and many others do not require decryption of the involved content. If an operation requires one or more items to be decrypted, their values are short-lived and quickly erased due to the memory management design.

Having as little information decrypted at any given moment minimizes the risk of memory dumps. If a memory attack is performed on recorded memory events, the task can easily involve millions of items, which may differ significantly on the next execution as a constantly moving target.

Is It Safe?       The online documentation has more details about VM Security and How to Attack and Defend
Download and test SCRAMBLECODE

Quick Facts: 

1. Private Instructions: 
Compiler can use a unique set of virtual assembler instructions for every project.
2. Encrypted Memory: 
Variables are stored encrypted in memory. Many instructions work without decryption.
3. Strong Protection: 
Uses multi-layered encryption and RSA key pairs of size 2048, 3072, 4096 or 8192 bit.
4. Personal VM: 
Creates a custom virtual machine for each key pair which only you can use.
5. All-In-One IDE:  
The editor, compiler, test bench, debugger and documentation are fully integrated.
6. Simple API: 
Free source code for C# .NET class included to demonstrate all API functions.
7. Free Deployment: 
Royalty free xcopy deployment of your compiled code and personal VM.
8. Free Download: 
Test full version on any machine. Internet not required. All functionality is available off-line.


Test Before You Buy: 
Download and test the full version for as long as you need on any number of machines.

The Documentation is fully integrated with the development environment.

Read the Introduction for a one page technical presentation.