A pause in the active development of the Vexon

 

An Important Update on the Vexon Language Project

It is with a heavy heart that we are announcing a pause in the active development of the Vexon programming language, effective immediately.

---

Our Project is Taking a Hiatus

Over the last few months, the development team has been facing unforeseen personal and professional challenges that require our full attention. As a passion project, Vexon requires a significant amount of focus and sustained energy to build the stable, feature-rich language we envisioned. Unfortunately, we can no longer dedicate the necessary time and resources to the project to maintain the quality and development pace you deserve.

Therefore, we have made the difficult decision to put Vexon development on an indefinite hiatus. This is a pause, not a cancellation.

---

What This Means for You

1. The Code Remains Available

The existing Vexon compiler and virtual machine (VM) source code (which you may know as vexon_core.js and vexon_cli.js) will remain publicly available on our repository. It is a complete, functioning language toolchain built on Node.js, and you can continue to use it, experiment with it, and compile standalone executables with the compileToExe feature.

2. No Active Maintenance

During this pause, we will not be actively reviewing pull requests, responding to issues, or planning new features. The core team will be stepping away from daily development for a while.

3. A Return is Possible

We are taking this time to regroup and address our current challenges. We remain immensely proud of what we created with Vexon and believe in its potential. We hope to return to the project in the future when we can commit to it fully and reignite the development effort with the energy it deserves. We simply cannot provide a timeline for that return right now.

---

Thank You

To everyone who has run a Vexon script, checked out the code, or engaged with us in any way—thank you. Your enthusiasm and support for this project meant the world to us.

We are sorry to deliver this news, but prioritizing the well-being of the team is essential. We hope you understand our decision.

We look forward to a day when we can return and pick up where we left off.

Until then, keep coding!

— The Vexon Development Team

A Major Update (0.2)

 

Vexon's New Chapter: A Major Update Focused on Stability, Diagnostics, and Modern Features

We are thrilled to announce a significant new update to the Vexon language! This release marks a pivotal moment in Vexon's development, moving beyond core functionality to deliver a vastly more stable, diagnosable, and feature-rich platform for all your projects.

The theme of this update is Reliability Redefined. By introducing structured exception handling and critical fixes to the module system, we’ve made Vexon programs more robust and easier to maintain than ever before.

Here is a deep dive into the most exciting features and core improvements in the latest Vexon update.

---

1. Stability Redefined: Introducing try/catch/throw

The most impactful change for production-ready Vexon code is the long-awaited arrival of Structured Exception Handling. You can now use try, catch, and throw statements to gracefully manage runtime errors.

This feature allows developers to:

• Prevent Crashes: Wrap risky operations in a try block to ensure a controlled shutdown.

• Handle Errors Locally: Use the catch block to recover from predictable errors without stopping the entire program.

• Custom Exceptions: Use throw to signal specific error conditions within your own functions and libraries.

This addition instantly elevates the professional quality and reliability of any Vexon application.

2. A Solid Foundation: Module System Fixes

We've resolved a critical issue in the Vexon module system related to circular dependencies and debugging, significantly improving the experience of creating and consuming Vexon libraries.

• No More Circular References in Debugging: We implemented a fix that prevents imported functions from causing circular reference errors when inspected or logged (e.g., during a JSON.stringify call). This makes debugging and logging much cleaner.

• Correct Global Scope: Imported functions now correctly resolve their global variables within the context of their defining module, ensuring that module-level constants and functions are always accessible.

This fix makes the Vexon module system safer and more predictable, especially for complex projects that rely heavily on imports.

3. Debugging is Now a Breeze: Enhanced Diagnostics

A key focus of this release was improving the developer experience when things go wrong. Previously, Vexon error messages could sometimes be vague about where an error occurred. That changes now.

• Line and Column Numbers: Syntax errors and runtime exceptions will now provide precise line and column numbers in the source file. No more guessing the location of a missing semicolon or an unexpected token!

This simple but powerful enhancement drastically cuts down on debugging time and makes the compiler your best assistant.

4. A More Complete Language: New Features

The update also includes several quality-of-life improvements and essential utilities:

New Feature	Description
Strict Equality (===, !==)	Vexon now supports strict comparison operators, encouraging best practices by avoiding type coercion surprises when comparing values.
fetch Built-in	A new standard function for making asynchronous network requests, making it simple to interact with web APIs and external services.
input Built-in	A new standard function for synchronous user input from the command line, perfect for CLI tools, interactive scripts, and testing.

Conclusion

The new Vexon update is a testament to the language's commitment to maturity and developer experience. The combination of structured error handling, module system stability, and precise diagnostics makes this the most robust version of Vexon yet.

We encourage all developers to update and begin exploring these features today. Happy coding!

Vexon Language Extension Update

 

Vexon Language Extension Update

A new release of the Vexon Language extension is ready. This update brings a self‑contained runtime and CLI into the extension package, streamlined Run and Compile workflows, and an easier developer experience for anyone building or using Vexon projects in VS Code. Below I walk through what changed, why it matters, how to use it, and what comes next.

What Changed

• Vendored runtime and CLI: vexon_core.js and vexon_cli.js are now included inside the extension under vendor/. The extension will use this vendored CLI by default when present.

• Smart CLI resolution: The extension searches for vexon_cli.js in this order: user setting vexon.cliPath, vendored vendor/vexon_cli.js, workspace root, and then by walking up parent folders from the active file.

• Run and Compile commands: Two commands — Run Vexon and Compile Vexon — are exposed as status bar buttons and commands. They launch the CLI in the integrated terminal so you can see compiler and runtime output directly.

• Packaging ready: The .vsix packaging now includes the vendor/ folder so users who install the extension get the runtime and CLI out of the box.

• Graceful fallback: If you later switch to a shared package or local link, the extension will still work; it prefers the vendored copy but accepts workspace or configured CLI paths.

Why This Matters

• Zero setup for users — New users no longer need to copy runtime files into every project. Install the extension and you can run .vx files immediately.

• Consistent behavior — Vendoring ensures the extension uses a known runtime version, reducing “works on my machine” problems.

• Flexible for developers — If you prefer to keep a project‑specific CLI, the extension still supports that. If you want to iterate on the core, you can use npm link, a file: dependency, or replace the vendored files.

• Better UX — Running and compiling from the integrated terminal keeps output, errors, and interactive prompts in one place, improving debugging and iteration speed.

How to Use It

Install the extension

• Build the .vsix with vsce package or install the published extension from the Marketplace.

• Confirm vendor/vexon_core.js and vendor/vexon_cli.js are present in the extension folder or in the packaged .vsix.

Run a file

1. Open a .vx file in VS Code.

2. Click the Run Vexon status bar button or run the command Vexon: Run File.

3. The integrated terminal will run a command like:

bash

node "<path-to-extension>/vendor/vexon_cli.js" run "<path-to-file>.vx"

Compile to EXE

1. Click Compile Vexon or run Vexon: Compile File.

2. The CLI will compile the file and generate a JS runner and optionally an EXE using pkg if available.

Custom CLI location

• Set the absolute path in workspace settings:

json

"vexon.cliPath": "C:\\tools\\vexon\\vexon_cli.js"

• Or place vexon_cli.js in your project root; the extension will detect it automatically.

Developer Notes

• Vendored files are tracked: vendor/ is included in the extension package. If you update the core, commit the changes so users receive the update.

• Fallback require pattern: The extension and CLI use local requires so you can later replace the vendored core with a package without changing extension code.

• Packaging: Ensure package.json includes "vendor/" in the files array before running vsce package.

• Testing: Use the Extension Development Host (F5) to validate Run/Compile flows and terminal output.

• Future migration: When you’re ready, you can move the core into a local package (file:), a monorepo workspace, or publish it to a private registry. The extension already supports those workflows via vexon.cliPath and workspace detection.

What’s Next

• Improved grammar and snippets — richer syntax highlighting and code snippets for common Vexon patterns.

• Integrated debugging — explore adding a debug adapter so you can set breakpoints and step through Vexon code.

• Automated CI packaging — a GitHub Actions workflow to build and publish .vsix artifacts automatically.

• Optional installer CLI — make vexon available as a global CLI via a local package for users who prefer a system tool.

Closing

This update focuses on making Vexon easier to use and maintain. Vendoring the runtime inside the extension removes friction for new users while keeping flexibility for power users and contributors. If you want, I can generate a sample .vx file for testing, a GitHub Actions workflow to build the .vsix, or a short README you can include in vendor/ describing how to switch to a package-based setup.

Welcome to the Official Vexon Blog

 

We’re thrilled to announce the launch of the official Vexon blog! 🚀

The Vexon blog will serve as your go-to source for everything related to the Vexon programming language — from tutorials and coding tips to updates and developer insights.

Here’s what you can expect from the blog:

• In-Depth Guides: Step-by-step tutorials to help you master Vexon, whether you’re starting from scratch or diving into advanced features.

• Project Spotlights: Explore exciting projects built with Vexon and get inspired for your own creations.

• Developer Insights: Learn about the development process, behind-the-scenes stories, and upcoming features.

• Community Updates: Highlights from the Vexon community, including tips, discussions, and contributions from users like you.

This blog is for everyone who’s passionate about programming and innovation. Our mission is to make learning and using Vexon as easy, fun, and productive as possible.

Stay tuned for regular posts, coding challenges, and more! Make sure to bookmark the blog and join the conversation — we want to hear from you.

Welcome to the Vexon community, online and now in blog form. Let’s create the future of programming together!

Join the Official Vexon Community on Reddit!

 We’re excited to announce the launch of the official Vexon subreddit! 🎉

Reddit has long been the hub for developers, programmers, and tech enthusiasts to share ideas, get help, and showcase projects. With the Vexon subreddit, we now have a dedicated space for everyone interested in the Vexon programming language to come together.

What you can expect on the subreddit:

• Discussions & Tutorials: Share tips, tricks, and guides for writing Vexon programs.

• Project Showcases: Post your Vexon creations and get feedback from the community.

• Support & Troubleshooting: Ask questions and find answers about syntax, features, or libraries.

• News & Updates: Stay informed about new releases, features, and official announcements.

Whether you’re a beginner just exploring Vexon or a seasoned programmer experimenting with advanced projects, the subreddit is the perfect place to learn, collaborate, and grow.

👉 Join now at r/Vexoncoding and be part of shaping the future of Vexon!

Let’s build an amazing community together. Your ideas and projects deserve to be seen!

Vexon: A Beginner-Friendly Programming Language

 

Welcome to Vexon: A Beginner-Friendly Programming Language

We’re thrilled to introduce Vexon, a new programming language designed to make coding simple, intuitive, and fun—especially for beginners!

Vexon runs on Node.js and integrates seamlessly with your system via the Vexon CLI. It supports variables, loops, functions, arrays, and more, all with a clean, easy-to-read syntax.

---

Why Vexon?

1. Beginner-Friendly Syntax
   Vexon uses simple keywords like print for output and fn for functions, making it easy to write and read code.

2. Interactive Learning with IKP
   Alongside the language, we’ve created an interactive IKP tutorial called introduction.ikp. This tutorial guides learners step by step:

   • Hello World – Print text to the console.

   • Variables – Store and manipulate numbers, strings, and arrays.

   • Loops – Iterate over data efficiently using for.

   • Functions – Reuse code by defining fn blocks.

   • Arrays – Access, modify, and append elements easily.

   Each scene contains live examples you can modify and run instantly, making learning both interactive and practical.

---

Example: Basic Vexon Syntax

Here’s a simple example that demonstrates the core features:

// Variables
num = 42
name = "Alice"
arr = [1,2,3,4,5]
print(name, "has", num, "apples.")

// Loop
for i in arr:
    print("Number:", i)

// Function
fn greet(person):
    print("Hello,", person)

greet("Vexon User")

This snippet shows how to define variables, loops, arrays, and functions—all with minimal syntax.

---

Learn by Doing

The IKP tutorial is designed for hands-on learning:

• Each scene introduces a new concept.

• Live examples are editable and executable.

• Navigation buttons let you move forward or backward between lessons.

This approach encourages experimentation, which helps solidify understanding of programming basics in a fun and interactive way.

---

Getting Started

1. Download the Vexon CLI from the repository.

2. Open introduction.ikp in your IKP viewer.

3. Follow the tutorial: read explanations, modify examples, and run them.

4. Experiment on your own: once comfortable, try building small scripts like a number counter, text manipulator, or simple calculator.

Git hub repository here.