VxLang logo VxLang Docs Developer documentation
GitHub ↗

Getting Started

Getting Started with VxLang — From downloading VxLang to protecting your first Windows executable

This guide is intended for first-time VxLang users. It explains how to prepare VxLang, select an EXE file, create a protected executable, and verify that it runs correctly.

VxLang can protect already compiled Windows binaries, so you do not need to integrate an SDK or modify source code for your first test. Function-level obfuscation, virtualization, and Runtime Code Encryption are covered in subsequent guides.

Contents

  1. Download & Purchase — Purchasing and downloading VxLang
  2. Installation & File Structure — Installation and file layout
  3. License Setup — Preparing your license
  4. Quick Start — Protecting your first EXE
  5. Project Configuration (JSON) — Project file structure and settings

1. Download & Purchase

VxLang is distributed through Patreon. You can purchase and download the product from the following page.

Official purchase page: VxLang Patreon Shop

Purchase and Download Steps

  1. Open the VxLang Shop using the link above.
  2. Select the product or license type you need.
  3. Review the terms and included items on the product page before purchasing.
  4. Follow the instructions for your purchased product to obtain the VxLang distribution files and relevant license materials.
  5. Save the downloaded files in your working directory.

Note: License duration, update availability, license type, and delivery methods may differ by product. Check the specific product page before purchasing. Do not assume that Patreon memberships and individual Shop purchases are identical products.


2. Installation & File Structure

To get started, extract the distributed files into your preferred working directory. VxLang is a Windows application and should be run in a Windows environment.

Main Components

Component Description
VxLang.exe Applies protection such as packing, code obfuscation, and code virtualization to executables.
Obscurion.exe GUI tool used to configure projects and protection regions.
vxlang.vxm Example license filename (based on the earlier official guide).
Extensions VxLang-Core extension code that may be included in the distribution.
Plugins Plugin modules used by the GUI and VxLang.
SDKs SDK resources used to mark protection regions in source code.

Actual file and directory contents may vary depending on the purchased product and distribution version. Not every distribution necessarily includes all the components listed above.

Example Working Directory

TEXT
C:\VxLang\
├── VxLang.exe
├── Obscurion.exe
├── vxlang.vxm          (if a separate license file is supplied)
├── Extensions\         (if included)
├── Plugins\            (if included)
├── SDKs\               (if included)
└── samples\
    └── sample.exe      (a test file provided by the user)

This directory layout is illustrative. You do not need to rearrange the original distribution to match it.

Recommendation: For your first test, use a simple executable that you created or have already verified works correctly. Keep a backup of the original file and use a distinct filename for the protected output.


3. License Setup

A valid license compatible with your distribution is required to run VxLang.

The earlier official user guide refers to the license file as vxlang.vxm and instructs users to place it in the same directory as VxLang.exe and Obscurion.exe.

TEXT
C:\VxLang\
├── VxLang.exe
├── Obscurion.exe
└── vxlang.vxm

If your purchased product specifies a different license filename or delivery method, follow the instructions supplied with that product.

Verify Startup

Open Command Prompt (cmd) and run the following commands from the VxLang directory:

BAT
cd /d "C:\VxLang"
VxLang.exe

If the program starts successfully, it may display version information and the available command-line syntax. The exact output varies by version.

If you encounter a license error, verify the license filename, location, validity period, and compatibility with your distribution.


4. Quick Start — Protecting Your First EXE

VxLang can protect compiled EXE files directly from the command line. The following example demonstrates a simple workflow that protects sample.exe and generates sample.vxm.exe.

4.1. Prepare a Test File

First, prepare a working Windows executable:

TEXT
C:\VxLang\samples\sample.exe

Confirm that the original sample.exe runs correctly before applying protection.

4.2. Run Protection from the Command Line

Open Command Prompt and run:

BAT
cd /d "C:\VxLang"
VxLang.exe "C:\VxLang\samples\sample.exe" --out "C:\VxLang\samples\sample.vxm.exe"
Argument Description
VxLang.exe The program that performs the protection operation.
sample.exe Path to the input binary.
--out Specifies the output path for the protected file.

This command format is based on the earlier official CLI guide. Refer to your program's help output and documentation for the options and default behavior supported by your version.

4.3. Check the Output

After a successful protection operation, verify that the output file exists at the specified location:

TEXT
C:\VxLang\samples\
├── sample.exe
└── sample.vxm.exe

When no output path is provided, the generated filename may append .vxm to the original name. Since this behavior may depend on the version and settings, explicitly specifying the output path with --out is recommended for your first test.

4.4. Run the Protected Executable

Run sample.vxm.exe and check that its basic functionality behaves the same as the original.

For an initial test, it is best to complete basic protection and runtime verification first, rather than enabling multiple advanced obfuscation or virtualization settings at once.


5. Project Configuration (JSON)

VxLang uses JSON files as project files. A project file stores the input binary path, output settings, virtualization and obfuscation regions, packing options, and other protection settings.

The example below preserves the structure of the provided temp.json file, with input changed to an empty string ("") as requested. Before running a protection operation, specify the target binary path in input.

5.1. Example Project JSON

JSON
{
    "input": "",
    "output": "",
    "backup": false,
    "use-data-section": false,
    "base-section-name": "",
    "map-file-path": "",
    "pdb-file-path": "",
    "core-name-list": [
        "vxlang",
        "phobos",
        "deimos"
    ],
    "core-name": "phobos",
    "use-cet-mode": false,
    "virtualizer": {
        "entry-point": false,
        "machine-count": 3,
        "virtualization": [],
        "dual-mode": []
    },
    "obfuscator": {
        "entry-point": false,
        "function-entry": false,
        "obfuscation": [],
        "flattening": []
    },
    "protector": {
        "compress": true,
        "symbol-data": false,
        "mutate-import-table": true,
        "remove-import-table": true,
        "allow-wine-system": false,
        "extension": [],
        "raw-data": [],
        "anti-tamper": {
            "enable": false,
            "enable-integrity-check": false,
            "message": ""
        },
        "reflection": {
            "enable": false,
            "ldr-update": false
        }
    },
    "address-range": []
}

Note: This example illustrates the project configuration structure. Arrays such as virtualization, obfuscation, extension, and address-range are empty in the supplied source file, so their individual item schemas cannot be determined from this example alone. Follow the configuration specifications for your VxLang version.

5.2. General Project Settings

Setting Type Description
input String Path to the input binary to protect. Left empty ("") in this example as requested.
output String Output path for the protected binary. Confirm the automatic naming rules for an empty value ("") in your version.
backup Boolean Option related to backing up the original file. Accepts true or false.
use-data-section Boolean Controls whether a data section is used. Exact placement behavior depends on the version.
base-section-name String Specifies the base name of sections being generated or processed.
map-file-path String Path to a MAP symbol file.
pdb-file-path String Path to a PDB debug-symbol file.
core-name-list Array of strings Names of available cores for the project. This example contains vxlang, phobos, and deimos.
core-name String Name of the selected obfuscation core. This example uses phobos.
use-cet-mode Boolean Enables a CET-compatible execution mode. Actual support depends on the environment and version.

About core-name: In the current VxLang configuration, core-name selects the core for general code obfuscation and obfuscation APIs. It does not select the entire packer shell or virtualization VM handlers. phobos is recommended for general use. Depending on the version, deimos may have compatibility or performance limitations.

5.3. virtualizer — Code Virtualization Settings

Setting Type Description
virtualizer.entry-point Boolean Controls whether virtualization is applied to the program entry point.
virtualizer.machine-count Number Specifies the number of VM configurations used by the project. The example value is 3.
virtualizer.virtualization Array List of regions configured for standard code virtualization.
virtualizer.dual-mode Array List of regions configured for Dual-Mode protection.

The item formats of these two arrays (for example, how addresses, functions, or ranges are specified) are not established here because temp.json provides no populated examples.

5.4. obfuscator — Code Obfuscation Settings

Setting Type Description
obfuscator.entry-point Boolean Controls obfuscation of the program entry point.
obfuscator.function-entry Boolean Controls obfuscation of function entry regions.
obfuscator.obfuscation Array List of regions targeted for general code obfuscation.
obfuscator.flattening Array List of regions targeted for control flow flattening.

5.5. protector — Packer and Executable Protection Settings

Setting Type Description
protector.compress Boolean Enables or disables compression during protection.
protector.symbol-data Boolean Option related to symbol-data processing. Refer to the version-specific specification for details.
protector.mutate-import-table Boolean Enables or disables Import Table mutation.
protector.remove-import-table Boolean Configures processing related to Import Table removal.
protector.allow-wine-system Boolean Controls whether the Wine execution environment is allowed.
protector.extension Array Configuration list for protection extensions or modules.
protector.raw-data Array Configuration list for additional raw data.

mutate-import-table and remove-import-table are separate settings. Verify their availability and combined behavior in your version.

Anti-Tamper Settings

Setting Type Description
protector.anti-tamper.enable Boolean Enables or disables Anti-Tamper protection.
protector.anti-tamper.enable-integrity-check Boolean Enables or disables integrity checking.
protector.anti-tamper.message String Specifies an Anti-Tamper-related message. Display conditions depend on the implementation.

Reflection Settings

Setting Type Description
protector.reflection.enable Boolean Enables or disables the Reflection feature.
protector.reflection.ldr-update Boolean Configures LDR-update behavior associated with Reflection. Refer to the dedicated feature specifications for exact behavior and prerequisites.

5.6. address-range — Address Range Settings

Setting Type Description
address-range Array Configuration list for address ranges specified in the project.

In the supplied JSON, address-range is an empty array ([]). Since the file does not define the fields or precedence rules for individual address-range objects, no speculative item format is added here.

5.7. Project File Guidelines

  1. Enter the actual target binary path in input before using the project. The example in this guide leaves it empty.
  2. In JSON, enclose strings in double quotes (") and write Boolean values as true or false.
  3. Escape backslashes (\) when entering Windows paths directly in JSON strings. Example: "C:\\VxLang\\sample.exe".
  4. An empty array ([]) means no items are specified in that array. It does not necessarily mean other related settings are automatically disabled.
  5. Consider backing up your JSON file before modifying the project configuration so you can compare or restore settings.

VxLang Documentation · Generated from Markdown