DEV Community: ECMA-King87

ArachnoScript Runtime v0.2.1 Released 🚀 - Major Improvements & New Features

ECMA-King87 — Sun, 10 May 2026 19:43:12 +0000

ArachnoScript Runtime v0.2.1 Released 🚀 - Major Improvements & New Features

Hey Dev.to!

It's been an exciting journey since I first introduced ArachnoScript. Today, I'm happy to announce the release of ArachnoScript Runtime v0.2.1.

This version brings a lot of under-the-hood improvements, bug fixes, and exciting new features.

What's New in v0.2.1

Improved For Loop Syntax

// Old syntax
for (i = 0; i < 10; i++) {}

// New syntax
for (spawn i = 0; i < 10; i++) {}

Improved CLI

Bash

# Old way
are ./path/to/script.as

# New way
are run ./path/to/script.as

Quick evaluation

are -e "Console.log('Hello World!');"

Major Changes

Optimized lexer + fixed string lexing bugs
Many parser fixes and improvements (constructor logic, object literals, if statements, class properties, etc.)
Significant Runtime improvements
New macros: #_http_listen, #_http_serve, #_real_path, #_path_relative_to_file, etc.
Removed old #_http_listen_and_serve macro
Added new http and regexp standard library modules
Updated many existing standard library modules (strings, arrays, io, fs, math, etc.)
Fixed several bugs (including await, macros, and path handling)
Many stability and performance improvements

How to Install (Windows)

Go to the GitHub repository: https://github.com/ECMA-King87/ArachnoScript-Runtime-Engine-ARE-
Go to the Releases section
Download the latest v0.2.1 assets
Run the installer (or extract the zip)
Start using the are command

Note: Currently focused on Windows. macOS and Linux support will arrive by the v1.0 release.

Join the community

GitHub: https://github.com/ECMA-King87/ArachnoScript-Runtime-Engine-ARE-
Official Discord: https://discord.gg/nQm7v2eXWt

What do you think about this direction? Feedback and ideas are very welcome!
Thanks for reading 🚀

ArachnoScript #ProgrammingLanguages #ShowDev #JavaScript

[Boost]

ECMA-King87 — Sun, 11 Jan 2026 11:12:18 +0000

ECMA-King87

Jan 3

I built my own JavaScript-inspired programming language — ArachnoScript

#showdev #javascript #programming

1 min read

I built my own JavaScript-inspired programming language — ArachnoScript

ECMA-King87 — Sat, 03 Jan 2026 20:01:11 +0000

Introducing ArachnoScript

ArachnoScript (AS) is a general-purpose programming language currently under active development. It is accompanied by the ArachnoScript Runtime Environment (ARE), the execution platform responsible for loading, executing, and managing ArachnoScript applications.

Rather than viewing the runtime as a separate implementation detail, ArachnoScript is designed around it. The language defines the syntax, semantics, and programming model, while ARE provides the infrastructure required to execute programs, manage application state, load modules, expose standard library functionality, and support the tooling that surrounds the language. Together, they form a complete development and execution platform.

The project is implemented in Go and is organized into a collection of independent components, each responsible for a specific stage of program execution. The current implementation includes a lexer, parser, runtime, module system, standard library infrastructure, and supporting utilities that collectively provide the foundation for the language. This modular architecture allows individual components to evolve without introducing unnecessary complexity into the rest of the system.

The ArachnoScript Runtime Environment

The ArachnoScript Runtime Environment, commonly referred to as ARE, is responsible for executing every ArachnoScript program. It provides the services required by applications during execution while maintaining a clear separation between language implementation and platform-specific functionality.

ARE is designed as a long-term platform rather than a simple interpreter. As the language evolves, the runtime will continue to serve as the stable execution environment regardless of the underlying execution strategy. Whether a program is interpreted, executed as bytecode, or eventually compiled to native machine code, the runtime remains the component responsible for coordinating execution and exposing the services available to applications.

Beyond program execution, ARE provides facilities for module loading, package integration, runtime services, memory management, error reporting, diagnostics, and interaction with the operating system. The runtime is also designed to accommodate future capabilities without requiring significant changes to user code, allowing the language ecosystem to grow while maintaining compatibility.

Architecture

ArachnoScript follows a modular architecture in which each subsystem is responsible for a well-defined task. Source code is processed through lexical analysis and parsing before being handed to the runtime for execution. This separation of responsibilities keeps the implementation maintainable while making it easier to improve or replace individual components as the language evolves.

The project is currently progressing toward a bytecode-based execution model that will provide a more efficient and extensible foundation for future releases. This transition also establishes the groundwork for advanced tooling, improved diagnostics, optimization opportunities, and additional execution targets without fundamentally changing the language itself.

Project Goals

The primary objective of ArachnoScript is to build a language with a predictable execution model, a maintainable implementation, and a runtime capable of supporting applications beyond simple scripting. Development is focused not only on the language itself, but also on the surrounding ecosystem, including developer tooling, libraries, package management, debugging facilities, and runtime capabilities.

ArachnoScript is an actively evolving project, and both the language and ARE will continue to expand through incremental releases. Future articles will explore individual components of the implementation, design decisions, runtime internals, language features, and the engineering challenges involved in building and maintaining a programming language from scratch.