Vexon: What Building a Small Bytecode Language Taught Me About Runtime Design

Vexon is an experimental programming language I’ve been building to better understand how languages work end to end — from parsing and compilation to execution on a virtual machine.

Rather than focusing on features or syntax novelty, Vexon is designed as a learning-driven language: small, readable, and complete enough to run real programs without hiding behind host-language abstractions.

This post explains what Vexon is, how it’s built, and what kinds of design lessons have come from actually using it.

---

What Is Vexon?

Vexon is a lightweight scripting language with:

• a custom lexer

• a hand-written parser

• a compiler that emits bytecode

• a stack-based virtual machine that executes that bytecode

Everything is implemented from scratch. There is no transpilation to another language’s AST or runtime.

At a high level, the pipeline looks like this:

Source (.vx)
   ↓
Lexer → Tokens
   ↓
Parser → AST
   ↓
Compiler → Bytecode
   ↓
VM → Execution

The goal is not performance parity with production languages, but clarity of behavior and control over execution.

---

Why a Custom VM?

Building a VM forces you to answer questions that are easy to ignore when embedding into an existing runtime:

• How are stack frames created and destroyed?

• What invariants must hold before and after each instruction?

• How are errors propagated without corrupting state?

• What happens when a program doesn’t exit?

Vexon’s VM is intentionally simple:

• stack-based execution

• explicit call frames

• predictable instruction flow

• no hidden background behavior

This simplicity makes bugs visible instead of mysterious.

---

Long-Running Programs Expose Real Problems

Early Vexon programs were short scripts — arithmetic, conditionals, functions. Everything appeared correct.

That changed once I started writing programs that run continuously, such as:

• simulation loops

• timer-driven logic

• simple game-style updates (e.g. Pong-like logic)

These programs exposed issues that never appeared in short scripts:

• stack growth due to missed cleanup paths

• state not being restored correctly after errors

• instruction pointer drift across iterations

This was a key lesson: programs that don’t exit are a better test of a runtime than programs that do.

---

Debugging at the VM Level

Traditional source-level debugging wasn’t very helpful. The real problems lived below the language syntax.

What worked instead:

• dumping VM state (stack, frames, instruction pointer)

• logging execution at instruction boundaries

• comparing dumps across iterations to detect drift

Seeing what the VM thought was happening made bugs obvious — especially mismatched push/pop paths and incorrect frame teardown.

This led directly to improvements in Vexon’s runtime consistency.

---

Tooling Before Features

One of the most important outcomes of Vexon so far is a shift in priorities.

Instead of adding more language features, the focus moved to:

• better internal visibility

• structured runtime dumps

• deterministic error handling

• tooling that explains why something broke

These improvements made the language easier to extend safely later.

---

Where Vexon Is Headed

Vexon is still experimental, but it’s already useful as:

• a language design playground

• a VM and compiler learning project

• a testbed for tooling ideas (dump formats, debuggers, GUIs)

Future work is focused on:

• better introspection tooling

• optional GUI frontends

• richer diagnostics

• more real programs to stress-test the design

---

Closing Thoughts

Vexon exists because building a language forces you to confront details most programmers never need to think about — and that’s exactly the point.

If you’re interested in:

• how languages are built

• how bytecode VMs behave

• or why tooling matters as much as syntax

then following Vexon’s development might be useful.

Building a Proper Windows Installer

 

Building a Proper Windows Installer for Vexon (Behind the Scenes)

When software starts to grow beyond simple scripts and into something users rely on, packaging becomes just as important as the code itself. For Vexon, we wanted an installer that felt native, behaved consistently, and required zero configuration from the user. That’s exactly what the Vexon Installer achieves.

In this post, we explore what the installer does, why it’s built this way, and how it makes Vexon feel like a real, first–class programming language on Windows.

---

Why Vexon Needed a Real Installer

Originally, running Vexon meant manually placing files somewhere and typing out long Node commands like:

node vexon_cli.js run example.vx

That works for development — not for users.

We needed:

• A fixed installation directory (C:\Vexon)

• Automatic PATH support so you can run vx from any terminal

• A .vx file association so you can double-click Vexon source files

• A proper uninstall entry in Control Panel

• A minimal, stable installer with no external dependencies

The final result is a small, fast, reliable installer that behaves exactly like installers for mainstream languages and tools.

---

What the Installer Does (Step by Step)

1. Installs Everything in C:\Vexon

The installer places all core files in a single clean directory:

• vexon_cli.js

• vexon_core.js

• version.txt

• Vexon icon

• A small vx.bat launcher

Because the install path is constant, support tools and scripts can rely on it.

---

2. Creates a vx Command You Can Run Anywhere

To run Vexon easily, the installer writes a simple launcher:

vx example.vx

Under the hood this just calls:

node C:\Vexon\vexon_cli.js run <file>

Then the installer appends C:\Vexon to your system PATH.
After a reboot, any terminal can use the vx command instantly.

---

3. Adds File Association for .vx Files

Double-clicking a .vx file automatically runs:

vx "<file>"

This means Vexon behaves like a true scripting language on Windows — opening a source file isn’t just editing it, but actually running it.

---

4. Registers a Full Uninstaller

The installer adds a clean entry in:

Control Panel → Programs and Features

Uninstalling will:

• remove file associations

• remove Vexon from PATH

• delete all installed files

• remove the installation directory

• remove the uninstall entry itself

This ensures Windows does not keep stale paths or registry keys.

---

5. Cleans Up PATH Safely on Uninstall

Most installers append paths, but few properly remove them.

The Vexon Installer includes a safe mechanism to remove C:\Vexon from the PATH even if users edited PATH manually or the directory appears more than once.

The result:
No broken PATH entries.
No polluted environment variables.
No leftover clutter.

---

Why This Installer Is Special

Most simple installers only copy files. The Vexon installer does a lot more:

Feature	Included
Custom installation directory	✔ (C:\Vexon)
Global PATH integration	✔
.vx file association	✔
Clean uninstaller	✔
Safe PATH cleanup	✔
Small file size (lzma compression)	✔
Works on all modern Windows versions	✔

The goal was reliability above all else — nothing fancy, nothing unstable.
Just a professional-grade installer for a professional-grade tool.

---

The User Experience

Here’s what installing Vexon feels like:

1. Run the installer .exe

2. Choose the installation directory (or accept C:\Vexon)

3. Click Install

4. Reboot (Windows requires this to update PATH)

5. Open any terminal and type:

vx

You’re ready to code.

---

Why We Didn’t Use MSI or Electron Installers

Many modern installers are bloated. MSI is complex, and Electron-based installers can exceed 100 MB.

NSIS (the technology behind this installer):

• is tiny

• is proven and stable

• supports full scripting

• works even on older Windows

• gives total control over registry, PATH, and file associations

For a programming language like Vexon, lightweight and predictable behavior is more important than fancy UI.

---

Final Thoughts

The Vexon Installer is part of a bigger goal: making Vexon feel like a serious, accessible, and user-friendly language. Small touches — PATH integration, file associations, clean uninstall — go a long way in making a tool feel professional.

This installer ensures that anyone can get up and running with Vexon in seconds, without friction, confusion, or technical setup.

Get the full pack here.

How to Publish Your Own Vexon Packages to VXPM

 

📦 How to Publish Your Own Vexon Packages to VXPM (The Complete Guide)

VXPM (Vexon Package Manager) is a simple but powerful way to share Vexon scripts, tools, and extensions with the community.
But how do you publish your own package so others can install it through VXPM?

This guide walks you through step-by-step:

• How to structure your package

• How to create the required files

• How to zip it correctly

• How to publish it by sending an email

• What happens after publishing

Let’s get started! 🚀

---

✅ 1. What Counts as a VXPM Package?

A VXPM package is simply a ZIP file that contains two files:

mycoolpackage.vx
mycoolpackage-example.vx

These two files let VXPM know how to install and run your script.
Alongside these, you must include an about.txt file:

about.txt

This is displayed when users run:

vxpm> look-up mycoolpackage

---

📁 2. Required Folder Structure

Before creating the ZIP, your folder must look like this:

MyCoolPackage/
│
├── mycoolpackage.vx
├── mycoolpackage-example.vx
└── about.txt

✔ mycoolpackage.vx

This is the main script.

✔ mycoolpackage-example.vx

This is a demo or usage example.
Include basic usage like:

import mycoolpackage;

print(runDemo());

✔ about.txt

This file describes your package. Example:

MyCoolPackage
A Vexon utility for generating adventure maps.

Author: YourName
Version: 1.0.0
Released: 2025-12-09

Includes:
 - Main script
 - Example script

Make this file clear and simple. VXPM will show this to users.

---

🔧 3. Packaging Your Files (Correctly)

Once your folder is ready:

Option A – Windows (Right click)

1. Select your 3 files (*.vx and about.txt)

2. Right-click → Send to → Compressed (zipped) folder

3. Name the ZIP file exactly as your package name:

mycoolpackage.zip

Option B – Using Python

import zipfile

files = ["mycoolpackage.vx", "mycoolpackage-example.vx", "about.txt"]

with zipfile.ZipFile("mycoolpackage.zip", "w") as z:
    for f in files:
        z.write(f)

IMPORTANT RULES

• ZIP name must match the package name

• No nested folders inside the ZIP

• Only these three files should be inside

---

✉️ 4. Publishing Your Package to VXPM

Once your ZIP file is ready:

✔ Send an email to:

📩 vexonlang+vxpm@outlook.com

---

Email Format Example

Subject:

VXPM Package: MyCoolPackage

Body:

Hello!  
I want to publish a new VXPM package.

Package Name: MyCoolPackage
Author: YourName
Description: A demo package that generates adventure maps.
Version: 1.0.0

Thanks!

Attach:

mycoolpackage.zip

---

📨 5. What Happens After You Email the ZIP?

1. The VXPM moderation checks:
   ✔ ZIP structure
   ✔ Required files
   ✔ No harmful content
   ✔ Proper naming

2. Once approved:

   • The package is uploaded to the official VXPM Discord channel.

   • It becomes instantly available to install with:

vxpm> install mycoolpackage

3. Users can now look it up:

vxpm> look-up mycoolpackage

Your about.txt is shown.

---

🚀 6. Best Practices for VXPM Packages

✔ Use lowercase names

mycoolpackage.vx

✔ Keep example simple

Show only the basic usage.

✔ Keep about.txt informative but short

Include:

• What it does

• Your name

• Version

• Requirements (if any)

✔ Test your ZIP before sending

Try installing it yourself in VXPM.

---

🎉 Conclusion

Publishing a VXPM package is extremely simple:

1. Create 3 files (.vx, -example.vx, about.txt)

2. Zip them into packagename.zip

3. Email it to vexonlang+vxpm@outlook.com

4. Wait for it to go live

You’re now officially contributing to the Vexon ecosystem!
Whether you’re building tools, game logic, libraries, or fun utilities, VXPM makes sharing easy.

Vexon 0.3 Is Here

 

🚀 Vexon 0.3 Is Here — The Biggest Stability & Networking Update Yet!

After intense development, debugging, and real-world testing, Vexon 0.3 is officially released!
This version focuses on what mattered most: stability, HTTP networking, safer execution, and proper VM control.

If you’ve been building games, tools, bots, or experiments in Vexon — this update changes everything.

---

🔥 What’s New in Vexon 0.3

🌐 1. Fully Working HTTP System (fetch)

You can now make real internet requests directly from Vexon:

✅ API requests
✅ Webhooks
✅ JSON endpoints
✅ POST & GET support
✅ Automatic JSON parsing
✅ Native Node fetch + HTTP fallback

Example:

let r = fetch("https://jsonplaceholder.typicode.com/todos/1")
print(r.status)
print(r.json.title)

This opens the door for:

• Discord bots

• Web dashboards

• Online games

• Cloud-based tools

---

🛑 2. VM HALT Bug — FIXED

In older versions, HALT inside a function could crash the entire program.
This was dangerous and unpredictable.

✅ In Vexon 0.3:

• HALT inside a function now acts like return

• Only the global HALT stops the program

• Functions no longer accidentally kill the VM

This makes large projects and modules finally safe to run.

---

🧠 3. Smarter Math & Type Handling

The classic bug:

"5" + 3  →  "53" ❌

Now correctly becomes:

"5" + 3  →  8 ✅

Automatic numeric coercion now:

• Detects numeric strings

• Prevents silent math corruption

• Makes calculations far more reliable

---

🧱 4. Massive if / else Parser Upgrade

The broken:

else missing {

error is now largely eliminated.

Vexon 0.3 now supports:
✅ else if chaining
✅ Single-line if without braces
✅ Stray semicolon tolerance
✅ Nested condition blocks
✅ Cleaner error messages with line numbers

---

📦 5. Safer Imports & Module Isolation

Imports are now circular-safe and cached:

• Prevents recursive crashes

• Prevents duplicate re-execution

• Keeps module globals isolated

• Builtins are injected safely

---

⚙️ 6. Compiler Improvements

✅ Functions no longer auto-emit HALT
✅ Cleaner bytecode generation
✅ Better separation of global vs function execution
✅ Improved loop handling (break / continue stability)

---

🧪 7. Production-Ready CLI

Your CLI now supports:

• Stable .vx execution

• .exe compilation with pkg

• Debug tracing (--debug)

• Safer file resolution

---

🧩 What You Can Build Now

With Vexon 0.3, you can safely build:

✅ Webhook Senders
✅ API-powered games
✅ Online chatbots
✅ File sync tools
✅ Cloud-connected apps
✅ Multiplayer logic prototypes
✅ Package managers
✅ CLI tools
✅ Encrypted utilities
✅ Automation engines

---

🛠 Example: Vexon API Script (Now Fully Supported)

let payload = {
  title: "Hello Web",
  message: "Sent from Vexon 0.3"
}

fetch("https://example.com/webhook", {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: json_encode(payload)
})

---

🔮 What’s Coming in Vexon 0.4+

Planned features:

• 🧬 Native package manager expansion

• 🎮 Game engine helpers

• 🖥 GUI bindings

• 📁 Built-in encryption modules

• ⚡ JIT performance boosts

• 🛡 Sandbox mode

• 🧠 AI toolchains

---

❤️ Final Words

Vexon started as an experiment — Vexon 0.3 turns it into a real platform.

This update finally brings:

• Real networking

• True VM safety

• Proper function execution

• Stable parsing

• Production-level scripting

If you’re building with Vexon — now is the best time to go big.

repository here.

VXPM — The Vexon Package Manager

 

🚀 Introducing VXPM — The Vexon Package Manager Powered by Discord

The Vexon programming language has been growing rapidly as a creative, lightweight scripting platform for games, tools, and experiments. As the ecosystem grows, one major challenge appears:

How do we easily share and install Vexon .vx scripts?

That’s exactly where VXPM (Vexon Package Manager) comes in.

VXPM is a Discord-powered package manager that allows developers to publish, browse, and install .vx files instantly—right from the command line.

---

📦 What Is VXPM?

VXPM is a tool that:

• Connects to a Discord channel using a bot

• Reads .vx file attachments as packages

• Lets users list, install, and uninstall Vexon libraries instantly

• Installs packages directly into the same folder as your project

• Is distributed as a single Windows .exe file

In simple terms:

Upload a .vx file to Discord → Users can install it globally with one command.

No websites.
No ZIP files.
No manual downloads.

---

⚙️ How It Works

VXPM uses the Discord API to read messages from a dedicated package channel. Every .vx file uploaded to that channel automatically becomes a public package.

The Flow Looks Like This:

1. Developer uploads:

   mylibrary.vx
   

2. A user runs:

   vxpm> list
   

3. Then installs:

   vxpm> install mylibrary
   

4. The file is downloaded and saved instantly as:

   mylibrary.vx
   

That’s it. The package is now ready to be used inside any Vexon project.

---

🧠 Why Discord as a Package Server?

Using Discord as a package backend has powerful advantages:

✅ Free global hosting
✅ Instant updates
✅ Version control via message history
✅ permissions & access control
✅ No domain, no server costs
✅ Works behind firewalls & ISPs
✅ Easy moderation & package removal

Discord becomes your live app store for Vexon.

---

💻 VXPM Commands

Here’s what users can do with VXPM:

list            → Show all available packages
install <name>  → Download a package
uninstall <name>→ Remove a package
installed       → Show installed packages
exit            → Close VXPM

It’s simple by design — fast, clean, and powerful.

---

🔐 Security Upgrade: Python + EXE

Originally VXPM was prototyped in pure Vexon, but due to HTTP limitations, the system was upgraded to Python + EXE for:

• ✅ Secure bot authentication

• ✅ Access to private Discord channels

• ✅ Reliable downloads

• ✅ Better error handling

• ✅ Distribution as a real Windows program

• ✅ Custom icon + branding

Now VXPM runs as a real production-grade desktop tool.

---

🛠 How Developers Publish Packages

Publishing a Vexon package is incredibly simple:

1. Create your script:

   mystuff.vx
   

2. Upload it to the Discord package channel

3. Done ✅

Users instantly see it in:

vxpm> list

To update a package:

• Delete the old upload

• Upload the new version with the same filename

To remove a package:

• Delete the message

That’s your full package lifecycle.

---

🌍 What VXPM Unlocks for Vexon

With VXPM, the Vexon ecosystem can now support:

• 📚 Shared standard libraries

• 🎮 Game engines & UI frameworks

• 🤖 Bot frameworks

• 🧩 Plugin systems

• 📡 Network utilities

• 🛠 Dev tools

• 🎥 Media players

• 🧪 Experimental APIs

VXPM turns Vexon from a scripting language into a real ecosystem.

---

🔮 Planned Features

Future upgrades for VXPM may include:

• 🔄 Auto-updating packages

• ✅ Verified dev badges

• 📄 Package descriptions

• 🧩 Dependency resolution

• 📦 Package versioning

• 🖼 GUI-based VXPM App

• 🔐 Encrypted token storage

• 🌐 GitHub + Discord hybrid hosting

---

🎯 Final Thoughts

VXPM is more than a tool — it’s the foundation of the Vexon ecosystem.

It removes friction.
It speeds up development.
It connects creators.
It makes sharing effortless.

One Discord upload can now power thousands of Vexon projects.

And that’s powerful.

Download it here.

GVex 0.2 “Dawn Breaker”

 

GVex 0.2 “Dawn Breaker” — A New Era Begins

We’re thrilled to announce the release of GVex 0.2, codenamed “Dawn Breaker” — the next step in our journey to make GVex faster, smarter, and more versatile than ever. Following the success of GVex 0.1 “First Light”, this update brings a host of improvements and new features designed to make your experience smoother, more intuitive, and more powerful.

What’s New in Dawn Breaker

1. Complete File Bridge Overhaul

GVex 0.2 introduces a fully rebuilt File Bridge system, making file management faster and more reliable. Now, bridging files between GVex modules is seamless, reducing errors and improving stability.

2. Streamlined Command Interface

The command line interface has been refined for clarity and speed. Commands now execute more efficiently, with enhanced feedback and logging. Users will notice smoother navigation and reduced lag when performing batch operations.

3. Clean Slate Script Feature

Ever wanted a “start fresh” option? GVex 0.2 adds a Clear Everything function, letting you reset your environment without losing core configuration files. Perfect for testing or setting up new projects.

4. Extension System Foundation

We’ve laid the groundwork for a future extension system, where GVex scripts can be modular, shareable, and dynamically loaded. This is just the beginning — 0.2 paves the way for a fully expandable GVex ecosystem.

5. Enhanced Logging & Debugging

Debugging your projects has never been easier. GVex 0.2 improves event logging and provides more detailed runtime feedback, helping you pinpoint issues faster.

Why “Dawn Breaker”?

Just like its predecessor “First Light”, GVex 0.2 is about beginnings. “Dawn Breaker” symbolizes breaking through the horizon, illuminating new possibilities for developers, creators, and enthusiasts alike. It’s a step forward, a fresh start, and an invitation to explore the full potential of GVex.

Getting Started

Updating to GVex 0.2 is simple:

1. Download the latest release from the official repository.

2. Follow the installation instructions in the README.

3. Explore the new features, and don’t forget to try the Clear Everything function for a clean slate.

We can’t wait to see what you build with GVex 0.2 “Dawn Breaker”. Share your projects, scripts, and ideas with the community, and let’s continue breaking new ground together.

The release is stored here.

GVex 0.1 — “First Light”

 

🚀 Introducing GVex 0.1

The First Native GUI Bridge for the Vexon Programming Language

Today marks a huge milestone in the evolution of the Vexon programming language. After weeks of experimentation, debugging, and fighting through engine limitations, I’m excited to officially announce:

🟢 GVex 0.1 — The First Working GUI System for Vexon

GVex is a file-based GUI bridge that allows Vexon programs to create and control real desktop windows using Python + Tkinter.

And yes — it’s already working.

---

✨ What Is GVex?

GVex is a cross-language GUI backend that connects:

• 🧠 Vexon (frontend logic & command sender)

• 🖥️ Python + Tkinter (GUI renderer & event handler)

Instead of using HTTP, sockets, or threads, GVex uses a safe batch-based file IPC protocol. This makes it:

• ✅ Extremely stable

• ✅ Windows-friendly

• ✅ VM-safe

• ✅ No async/thread crashes

• ✅ No timing bugs

• ✅ No networking required

---

✅ What Works in GVex 0.1

Right now, GVex 0.1 officially supports:

• ✅ Window creation

• ✅ Window title control

• ✅ Text labels

• ✅ Buttons

• ✅ Batch GUI commands

• ✅ Live button interaction

• ✅ Label updates from button clicks

• ✅ Stable multi-command rendering

In simple terms:

Vexon can now build real desktop GUIs.

---

🧪 Example: GUI From Vexon

A full GUI can be created with a single batch command:

write("bridge_cmd.json", json_encode({
    "cmds": [
        { "cmd": "create_window", "title": "GVex Demo" },
        { "cmd": "create_label", "id": "status_lbl", "text": "Status: Ready" },
        { "cmd": "create_button", "id": "btn1", "text": "Click Me" }
    ]
}));

And on the Python side, Tkinter renders the entire window instantly.

---

🧠 Why GVex Exists

Vexon was originally designed as a lightweight scripting language. But as projects grew more complex, one big question kept coming up:

“Can Vexon have a real GUI?”

GVex is the first real, working answer to that question.

It proves that:

• Vexon can control native windows

• Vexon can drive real applications

• Vexon can serve as a frontend language

• Vexon can go beyond the terminal

---

⚙️ Technical Highlights

• Protocol: Batch-based JSON file IPC

• Backend: Python 3.14 + Tkinter

• Frontend: Vexon VM

• Architecture: Command → Render → Event

• No Dependencies: Outside Python’s standard library

• No HTTP. No Threads. No Race Conditions.

This design intentionally avoids:

• ❌ Broken async

• ❌ VM freezing

• ❌ Network instability

• ❌ Timestamp desync

• ❌ Socket edge cases

---

📦 Current Version: GVex 0.1

This is a foundational release.

Think of GVex 0.1 as:

“The kernel of a GUI system for Vexon.”

It’s stable, deterministic, and ready to be expanded with:

• 🔤 Text input (Entry)

• ✅ Checkboxes

• 🎚 Sliders

• 📋 Listboxes

• 🧱 Layout systems

• 🌙 Dark mode

• 🔁 Event return to Vexon

---

🔮 What’s Next?

The next versions of GVex will focus on:

• True two-way event flow (GUI → Vexon logic)

• Standard widget libraries

• Theme engines

• Native app packaging

• GUI-based Vexon applications

---

🏆 Final Thoughts

GVex 0.1 proves something important:

Even a small custom language like Vexon can drive real desktop software.

This release started as a simple experiment and evolved into a fully working GUI framework. It’s also a reminder that persistence beats limitation.

GVex isn’t just a feature — it’s a new chapter for Vexon.

Here is the link to the folder.