DEV Community: Lucas Guimarães

Running Classic ASP Without IIS: The Modern Cross-Platform Alternative

Lucas Guimarães — Mon, 25 May 2026 13:05:25 +0000

For decades, Internet Information Services (IIS) has been the undisputed home for Classic ASP applications. However, the landscape of web hosting is changing rapidly. With Microsoft officially announcing the deprecation of VBScript, many developers and system administrators are left wondering about the future of their legacy codebases. Migrating massive, business-critical Classic ASP applications to a new language is often too expensive and time-consuming.

Historically, when developers looked for an alternative to IIS, they turned to solutions like Sun ONE ASP (formerly ChiliSoft), Abyss Web Server, or the lightweight Baby Web Server. Today, these options are either long abandoned, proprietary, or lack the modern architecture required for contemporary cloud deployments.

If you are searching for a viable, actively maintained alternative to IIS to keep your Classic ASP applications running securely and efficiently, the solution is AxonASP.

What is AxonASP?

AxonASP is an open-source server environment built from the ground up to host Classic ASP applications on virtually any operating system. It completely removes the dependency on Windows Server and IIS, providing a bridge between legacy VBScript codebases and modern deployment infrastructure.

Instead of being a commercial product trying to lock you in, AxonASP is a community-driven project aimed at bringing Classic ASP into the modern era.

A True Cross-Platform Architecture

Because AxonASP is written in Go (Golang), it boasts true cross-platform compatibility. You are no longer tied to Windows environments. You can run your Classic ASP applications natively on:

Linux (Ubuntu, Debian, Alpine, CentOS, etc.)
macOS
Windows
ARM Architectures (Making it compatible with Raspberry Pi, Apple Silicon, and efficient cloud processors like AWS Graviton)

You can deploy AxonASP as a lightweight standalone executable application or run it as a Docker container. This containerization support is critical for teams wanting to integrate legacy ASP applications into modern CI/CD pipelines and Kubernetes clusters.

Performance: Low Footprint, High Speed

One of the biggest drawbacks of traditional IIS or older alternatives like Abyss Web Server was their resource consumption.

AxonASP leverages Go's highly efficient concurrency model and memory management. The result is a server with an incredibly low CPU and memory footprint. It can handle high-traffic workloads while consuming a fraction of the resources required by a full Windows Server installation.

Advanced Caching for VBScript

A common pain point in Classic ASP development was the performance hit associated with dynamic code execution. AxonASP tackles this by introducing a highly optimized, advanced caching system.

Under the hood, the engine intelligently caches parsed scripts and compiled states. This optimization means that traditionally expensive VBScript operations—specifically the Eval and Execute commands—run significantly faster than they did on legacy engines. AxonASP doesn't just run Classic ASP; it optimizes the execution of the code to meet modern speed expectations.

Why Choose AxonASP Over Legacy Alternatives?

Future-Proofing Against VBScript Deprecation: As Microsoft phases out native VBScript support in future Windows builds, AxonASP provides a self-contained runtime environment that ensures your code continues to work indefinitely.
Open-Source and Actively Maintained: Unlike Sun ONE ASP or Baby Web Server, AxonASP is open-source. It is actively developed, meaning bugs are patched, modern web standards are supported, and the community can audit the code.
Modern Deployment: By supporting Docker and Linux, you can finally move your ASP applications off expensive Windows Server licenses and onto cost-effective, scalable cloud Linux instances.

Conclusion

Finding a viable alternative to IIS for Classic ASP doesn't mean you have to rely on outdated, unsupported software like Sun ONE or Abyss. AxonASP proves that legacy code can thrive in modern environments. By combining the flexibility of GoLang, support for Docker and ARM, and advanced caching optimizations, AxonASP is ensuring that Classic ASP remains a fast, reliable, and deployable technology for years to come.

VBScript Still Lives: How a Custom Go VM Brought Classic ASP to Linux and Mac

Lucas Guimarães — Mon, 25 May 2026 01:45:40 +0000

When Microsoft officially announced the deprecation of VBScript, it signaled the end of an era. For decades, thousands of critical Line-of-Business (LoB) applications, internal ERPs, and legacy systems built on Classic ASP have been quietly powering corporate intranets, entirely tethered to Windows Server and IIS.

The conventional wisdom dictates that legacy platforms should be rewritten in modern stacks. But rewriting decades of perfectly functional business logic is expensive, risky, and often unnecessary. Instead of letting VBScript die, ** AxonASP ** took a radically different engineering approach: rewriting the entire execution engine from scratch in Go to bring Classic ASP to Linux, macOS, and Docker.

Here is a technical deep dive into how a language from the 90s was re-engineered for the modern cloud computing era.

Dropping the AST: The Shift to a Single-Pass Compiler

The original Microsoft VBScript interpreter relied heavily on older parsing technologies that suffered from repetitive string parsing and high memory allocation overhead under concurrent loads. To achieve modern performance, the AxonASP architecture completely discarded the traditional Abstract Syntax Tree (AST) approach for VBScript execution.

Instead, the runtime features a custom single-pass compiler. As the engine reads the legacy VBScript/VB6-style code, it emits bytecode directly to a highly optimized, stack-based Virtual Machine known as AxonVM. By aggressively avoiding reflection and minimizing dynamic heap allocations in Go, the VBScript execution achieves a virtually zero-allocation overhead.

To handle concurrency, the engine implements an "IIS-style VM pooling" mechanism that maps directly to Go's native goroutines. This means the server can handle high request concurrency with a drastically reduced memory footprint, often outperforming the original Windows Server ASP engine.

The Dual-Language Engine: Synchronous Server-Side JavaScript

While preserving VBScript was the primary goal, a modern runtime needs to speak the language of today's web. The engine implements an AST-based JavaScript runtime (derived from Goja) strictly compliant with ECMAScript 6+.

Because it operates as a dual-language engine, developers can actually mix modern JS (using Array.map, filter, and strict mode) with legacy VBScript in the exact same application environment.

More importantly, the latest architectural updates introduced Node.js compatibility, including support for CommonJS require and ECMAScript Modules (.mjs files). This brings an interesting paradigm shift: Synchronous Server-Side JavaScript.

Unlike Node.js, which forces an asynchronous, event-driven loop and continuous async/await chaining for I/O operations, AxonASP runs each request in its own preemptive goroutine. Developers can write traditional top-to-bottom synchronous JavaScript to fetch database records without blocking the entire web server, drastically lowering the cognitive friction for simple APIs and database-heavy admin panels.

Modern Tooling: CLI, WASM, and AI Integration

Taking ASP out of IIS unlocked completely new deployment and execution models that were previously impossible for VBScript:

CLI and TUI Execution: The runtime ships with a Text User Interface (TUI) and a Command-Line Interface, allowing VBScript and ASP code to be executed directly from a Linux terminal. This makes it possible to use legacy ASP logic for background cron jobs and system administration scripts.
Edge Computing via WebAssembly (WASM): In an experimental push, the engine can be compiled to WebAssembly. This allows legacy server-side ASP and VBScript to run directly inside the user's web browser, opening doors for offline-capable web applications just like Blazor, but using AxonLive.
Built-in MCP Server: Acknowledging the shift toward AI-assisted development, the runtime embeds a Model Context Protocol (MCP) server. AI agents (like those in VS Code) can connect directly to the runtime to understand the system's native libraries, and autonomously refactor or write new ASP code.

Conclusion

Software doesn't have to die just because a corporation stops supporting it. Released under the open-source MPL-2.0 license, this project proves that with the right architectural foundations (and the immense power of Go), even a language as maligned as VBScript can be modernized to run cleanly on modern Linux containers.

VBScript might be officially deprecated by Microsoft, but thanks to open-source engineering, it is very much alive.

What Happens When You Teach Old Scripting Languages New Runtime Tricks?

Lucas Guimarães — Mon, 25 May 2026 01:45:24 +0000

For a long time, Classic ASP, VBScript, VB6-style behavior, and server-side JavaScript were treated as technologies locked to a specific era and operating system. Our team started from a different question: what if these languages were not obsolete, just trapped by historical runtime dependencies? With AI-assisted development, we began rebuilding compatibility from the ground up so the same legacy logic can run consistently on Linux, Windows, and macOS without rewriting entire systems.

AxonASP is built around a custom execution engine in Go, with a stack-based virtual machine for VBScript/Classic ASP semantics and an internal JavaScript engine with full EcmaScript 6 compliant path for JScript compatibility. Instead of depending on external interpreters, we parse, compile, and execute code with explicit control over opcodes, coercion rules, error mapping, and ASP object behavior. This gives us room to preserve the quirks that matter in real production applications, including case-insensitive lookups, historical type conversions, and the runtime expectations found in old ASP codebases.

AI has been especially useful in accelerating difficult compatibility work: comparing edge-case behavior, generating focused test scenarios, and helping us inspect regressions quickly across multiple language features. That does not replace engineering judgment, but it shortens the distance between “we found a mismatch” and “we shipped a precise fix.” The practical result is a platform where legacy applications can be studied, maintained, and modernized incrementally rather than discarded because of infrastructure constraints.

If this interests you, take a look at AxonASP on GitHub: https://github.com/guimaraeslucas/axonasp. The project is open to people who care about runtime design, language compatibility, and long-term software preservation, and we would love thoughtful feedback from developers working with old ASP/VBScript/VB6-era systems today.

SSR with JavaScript: Escaping Node.js Clunkiness with AxonASP

Lucas Guimarães — Sun, 24 May 2026 22:55:11 +0000

Server-Side Rendering (SSR) is back in vogue, but let’s be honest: building dynamic, server-rendered HTML pages purely in JavaScript can often feel incredibly clunky.

If you are using Node.js, you usually have to choose between two extremes. You either adopt a massive, heavy-handed meta-framework, or you wrestle with templating engines (like EJS or Pug) that feel disconnected from your actual logic. Mixing HTML and JavaScript in a standard Node.js environment is awkward. It requires routing gymnastics, string concatenations, and a mental overhead that simply shouldn't be necessary for generating a webpage.

There is a better, much cleaner way to handle this interaction, and it takes inspiration from the classic web but runs on a seriously modern engine: AxonASP.

The Elegance of True Inline Server Logic

AxonASP re-introduces the elegance of the classic ASP routing and templating model, but supercharges it for the modern JavaScript ecosystem. Instead of setting up complex controllers just to pass a JSON object to a view engine, AxonASP lets you fluidly mix your HTML and your JavaScript logic in the same file, rendered seamlessly by the same engine.

Here is what it looks like to generate dynamic content without the Node.js boilerplate:

<%@ Language="JavaScript" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Dynamic User Roster</title>
</head>
<body>
    <h1>System Users</h1>
    <div class="user-list">
        <% 
            // Look ma, modern JavaScript!
            const fetchUsers = () => {
                return [
                    { id: 1, role: 'Admin', status: 'Active' },
                    { id: 2, role: 'Developer', status: 'Active' }
                ];
            };

            const users = fetchUsers();

            users.forEach(user => { 
        %>
            <div class="card">
                <h3>User ID: <%= user.id %></h3>
                <p>Role: <%= user.role %></p>
                <p>Status: <%= user.status %></p>
            </div>
        <% 
            }); 
        %>
    </div>
</body>
</html>

The syntax is immediately readable. The HTML remains front and center, while the JavaScript steps in exactly where it is needed to drive the dynamic data.

Separation of Concerns: APIs and HTML Under One Roof

AxonASP isn't just a templating engine; it's a robust execution environment. It allows you to serve your beautifully rendered HTML pages right alongside your JSON-based REST APIs.

You can write pure JavaScript endpoints for your frontend applications to consume, and standard HTML/JS pages for your web views. Everything is kept logically separated in your project structure, but fundamentally rendered and executed by the exact same underlying mechanism. No need to spin up separate microservices or configure reverse proxies just to serve an API and a webpage from the same domain.

Separation of Concerns: APIs and HTML Under One Roof
AxonASP isn't just a templating engine; it's a robust execution environment. It allows you to serve your beautifully rendered HTML pages right alongside your JSON-based REST APIs.

Modern JS, Node Modules, and the Power of the VM Pool

If you think a classic-style syntax means outdated JavaScript, think again. AxonASP fully supports ECMAScript 6 (ES6) and newer versions. You get all the modern syntactic sugar—destructuring, arrow functions, spread operators—right inside your server-rendered pages. Furthermore, for specific use cases, you can even leverage Node.js modules directly within your AxonASP environment.

But where AxonASP truly leaves standard Node.js in the dust is its execution architecture.

Node.js is notoriously built on a single-threaded Event Loop. This means to achieve concurrency, you are forced to write asynchronous, non-blocking code (async/await everywhere). If you execute a heavy synchronous task, you block the entire server for all users.

AxonASP solves this by utilizing a pool of Virtual Machines. When a request comes in, it is assigned to an available VM in the pool. This architectural choice is a game-changer:

True Concurrency: You do not need to rely on complex asynchronous code tied to a single thread to serve multiple users.
Simpler Code: You can write fast, synchronous, procedural JavaScript logic without worrying about blocking the main thread, because your script execution is isolated within its own VM.
High Performance: Built for high-performance server-side execution, the engine scales beautifully under load, spinning up and assigning VMs as needed.

Conclusion

Node.js revolutionized backend JavaScript, but it made rendering standard HTML pages unnecessarily complex. AxonASP brings back the joy and speed of rapid web development. By combining the straightforward nature of classic inline logic with modern ES6+ support, Node module compatibility, and a powerful VM pool architecture, it provides a superior developer experience for dynamic web generation.

Stop fighting with your templating engines. Give AxonASP a try and see how seamless server-side JavaScript can actually be.

Why I'm Writing Server-Side synchronous JavaScript (And Why It Beats Node.js for APIs)

Lucas Guimarães — Thu, 30 Apr 2026 01:26:57 +0000

If you tell a developer today that you are writing server-side JavaScript, they will immediately assume you are setting up Node.js, Deno, or Bun. They will picture package.json files, a massive node_modules folder, and a build pipeline just to get a simple API running.

What if I told you I am deploying highly concurrent, database-driven JavaScript APIs on Linux without a single npm install?

I am doing this using AxonASP, a runtime built in GoLang that executes Classic ASP. But instead of sticking exclusively to VBScript, I am utilizing its built-in JavaScript engine.

Before you dismiss this as retro-computing nostalgia, let's look at the architectural advantages of choosing this stack over a traditional Node.js environment.

The "Batteries Included" Philosophy vs. Dependency Hell

The biggest friction point in the Node.js ecosystem is the reliance on third-party packages for fundamental operations. Need to connect to a database? Download a driver. Need to process an image? Download a heavy wrapper around a C library. Need to send an email? That's another dependency.

AxonASP takes the opposite approach. It is distributed as a single, compiled Go binary[cite: 8]. Instead of relying on a fragmented package ecosystem, it injects zero-allocation native Go libraries directly into the runtime.

When writing JavaScript in AxonASP, you have immediate access to enterprise-grade tools natively:

G3DB: High-performance database connectivity with built-in connection pooling for SQLite, MySQL, PostgreSQL, MS SQL Server, Oracle, and MS Access.
G3IMAGE: Process, draw, manipulate, and convert images on the fly.
G3CRYPTO & G3MAIL: Generate hashes, encrypt data, and send SMTP emails with attachments out of the box.

You get the power of compiled Go libraries exposed directly to your JavaScript code, with virtually zero overhead.

ES5 vs. ES6+: The Synchronous Advantage

AxonASP features an AST-based JScript engine derived from Goja. It is mostly compliant with ECMAScript 5, supporting strict mode, JSON, and array methods like map and filter.

I know what you are thinking: ES5? No async/await? No arrow functions?

In a Node.js environment, async/await is strictly necessary because Node runs on a single-threaded event loop. If you block the thread with a synchronous database query, the entire server freezes. This forces you to write asynchronous code for everything.

AxonASP, however, relies on native Go concurrency for handling multiple requests. Every HTTP request is handled in its own isolated goroutine. This means you can write straightforward, synchronous, top-down JavaScript without worrying about blocking the server.

You query the database, you get the result on the next line, and you send it to the client. No callbacks, no promises, no mental gymnastics. Just clean, linear procedural code that is incredibly easy to debug and maintain.

The Power of Native ASP Objects

When you build an API in Express.js or Fastify, you spend time configuring routing, middleware, and request parsers.

In AxonASP, the file system is the router. You drop an api.asp file into your directory, and it's instantly live. More importantly, you have instant access to the robust, battle-tested standard ASP objects.

Reading headers, parsing query strings, and handling form data is done natively through the Request object. Outputting data is handled by the Response object. It is a frictionless layer between the HTTP protocol and your business logic. Furthermore, you can even mix JavaScript and VBScript seamlessly in the same application if needed.

Deployment and Footprint

Deploying Node.js apps usually involves managing process managers like PM2, copying over thousands of files, and dealing with memory bloat.

AxonASP requires minimal resource consumption and boasts a server startup time measured in milliseconds. You can run it natively on Windows, Linux, or macOS, and it is entirely Docker-friendly. You can expose it via its built-in HTTP proxy mode or integrate it directly into Nginx or Apache using FastCGI.

Conclusion: Pragmatism Over Hype

Is Node.js or Bun faster at pure mathematical compute? Probably. Do they have newer language syntax? Yes.

But when it comes to shipping a business application or a micro-API quickly, stability and simplicity win. AxonASP allows us to write standard JavaScript, connect to a robust GoLang-backed database pool, and deploy a single binary to a lightweight Linux server.

It is not about chasing the latest framework; it is about building stable, fast, and easily maintainable systems. Sometimes, the best way forward is looking at what already worked, stripping away the bloat, and supercharging it with modern system architecture.

Server-Side JavaScript in ASP? Building APIs on Linux with AxonASP

Lucas Guimarães — Wed, 29 Apr 2026 11:00:00 +0000

When we talk about Classic ASP, the first thing that comes to mind is usually VBScript. It’s a great, straightforward language, but let's be honest: in the modern web ecosystem, everything talks JSON. And generating JSON manually by concatenating strings in VBScript is a nightmare no developer should have to endure today.

But here is a forgotten fact: Classic ASP on Windows always supported JScript.

With AxonASP (https://github.com/guimaraeslucas/axonasp), a GoLang-based server that runs Classic ASP natively on Linux, macOS, and Windows — this capability isn't just preserved; it becomes a powerful tool. AxonASP implements an ECMAScript 5.0 (ES5) engine, allowing you to write server-side JavaScript seamlessly integrated with your ASP pages.

The Best of Both Worlds
By using JavaScript as your primary language in an ASP page, you can naturally mix HTML content with server-rendered JS. More importantly, it completely eliminates the friction of building APIs. You get the native syntax of JavaScript (including built-in JSON.stringify and JSON.parse) combined with the robust, battle-tested standard ASP objects like Response, Request, and Server.

Add to this ecosystem libraries like G3DB, which makes connecting to and querying multiple databases simultaneously a breeze, and you suddenly have a highly capable, extremely lightweight backend stack running directly on a Linux server or inside a Docker container.

Real-World Example: A Micro-API Endpoint
To show you how this looks in practice, let's build a simple, secure API endpoint.

Imagine you need to serve data to a modern Vue.js or React frontend. Instead of setting up a heavy framework, you can drop this .asp file into your AxonASP www folder. It reads a query parameter, queries a database using G3DB, formats the result as JSON, and serves it with the correct HTTP headers.

<%@ Language="JavaScript" %>
<%
// 1. Setup modern HTTP headers for our API
Response.ContentType = "application/json";
Response.Charset = "UTF-8";
Response.AddHeader("Access-Control-Allow-Origin", "*");

// 2. Define our data retrieval logic
function getRecordData(recordId) {
    // Instantiate the library with the primary ProgID.
    var db = Server.CreateObject("G3DB");

    // Opens using configuration/env values.
    // Returns True on successful open from config/env; False otherwise.
    var isConnected = db.OpenFromEnv("mysql"); 

    if (!isConnected) {
        // Returns the current error string.
        throw new Error("Database connection failed: " + db.GetError()); 
    }

    // Use parameterized queries to ensure security against SQL Injection
    var sql = "SELECT id, status, created_at, assigned_user FROM workflow_queue WHERE id = ?";

    // Executes a query and returns a forward-only result set.
    // Placeholder rewriting converts ? markers to the active driver format when needed.
    var rs = db.Query(sql, recordId); 

    var result = null;

    // Check if the result set is valid (G3DB returns Empty on failure).
    if (rs != null) {
        if (!rs.EOF) {
            // Map the Recordset directly into a native JavaScript Object
            result = {
                id: String(rs("id")),
                status: String(rs("status")),
                createdAt: String(rs("created_at")),
                assignedTo: String(rs("assigned_user"))
            };
        }
        // Always clean up the Recordset
        rs.Close();
    } else {
        // Capture execution failures using the read-only LastError property.
        throw new Error("Query execution failed: " + db.LastError);
    }

    // Closes the current database pool managed by the G3DB object.
    db.Close(); 

    return result;
}

// 3. Process the incoming request
try {
    // Extract the ID from the URL (e.g., api.asp?id=1042)
    var reqId = String(Request.QueryString("id"));

    if (reqId === "undefined" || reqId === "") {
        Response.Status = "400 Bad Request";
        Response.Write(JSON.stringify({ 
            success: false, 
            error: "Missing required parameter: id." 
        }));
    } else {
        var record = getRecordData(reqId);

        if (record) {
            // Success: output standard JSON using native ES5 stringify
            Response.Write(JSON.stringify({ 
                success: true, 
                data: record 
            }));
        } else {
            Response.Status = "404 Not Found";
            Response.Write(JSON.stringify({ 
                success: false, 
                error: "Record not found in the database." 
            }));
        }
    }
} catch (e) {
    // Global error handler
    Response.Status = "500 Internal Server Error";
    Response.Write(JSON.stringify({ 
        success: false, 
        error: e.message 
    }));
}
%>

Why This Matters
Look at the code above. It is valid JavaScript, it runs incredibly fast, and it does exactly what it needs to do without layers of middleware or complex routing configurations.

Because AxonASP is built on GoLang, this entire environment is completely decoupled from Windows Server. You can write your legacy or new ASP systems using the syntax you already know, leverage standard ASP objects, query your databases with G3DB, and deploy it all on a minimal Linux distribution.

If you are maintaining Classic ASP applications, migrating them doesn't have to mean rewriting them from scratch in another language. You can modernize the infrastructure, switch to JavaScript where it makes sense (like API endpoints), and keep your systems running smoothly for the next decade.

Running Classic ASP on Linux in 2026

Lucas Guimarães — Wed, 29 Apr 2026 00:25:52 +0000

Yes, it is 2026, and Classic ASP is still very much alive.

While many consider it a relic of the past, the reality is that many companies still rely on it for internal systems, legacy enterprise tools, and even public-facing pages. For a long time, the biggest drawback was the platform lock-in: if you wanted to run ASP, you were tied to Windows and IIS.

But things have changed. VBScript is a remarkably straightforward language that deserves to be preserved, and for those who prefer it, modern implementations even allow you to mix in JavaScript.

I’ve been working on a solution to bring this stack into the modern era of infrastructure. It’s called AxonASP.

Why AxonASP?
Written in GoLang, AxonASP is a cross-platform server that allows you to run Classic ASP on Linux, macOS, and Windows. This means you can finally containerize your legacy applications using Docker or deploy them on ultra-lightweight Linux instances.

How lightweight? A simple AWS T2.nano virtual machine with just 512 MB of RAM is more than enough to serve your website. You can maintain your legacy systems (or build new ones) directly from a Linux environment with minimal overhead.

Installation Guide
You can find the project and the latest releases on GitHub: github.com/guimaraeslucas/axonasp.

To get started on Linux, you can download the package specific to your distribution using wget. Replace the extension according to your needs (.rpm, .deb, or .apk):

# For Alpine (APK)
wget https://github.com/guimaraeslucas/axonasp/releases/download/v1.2.2/axonasp_1.2.2_x86_64.apk

# For Debian/Ubuntu (DEB)
wget https://github.com/guimaraeslucas/axonasp/releases/download/v1.2.2/axonasp_1.2.2_x86_64.deb

# For RHEL/Fedora/Amazon Linux (RPM)
wget https://github.com/guimaraeslucas/axonasp/releases/download/v1.2.2/axonasp_1.2.2_x86_64.rpm

Since Amazon Linux is the standard for AWS environments, here is how you install it using dnf:

sudo dnf install ./axonasp_1.2.2_x86_64.rpm

Running the Server
After installation, the server files are located in /opt/axonasp. To do a quick test, navigate to the directory and run the HTTP binary:

cd /opt/axonasp
./axonasp-http

By default, the server will look for your files in the opt/axonasp/www/ folder. You can tweak the behavior, ports, and logic by editing the configuration file at config/axonasp.toml. Your site will be live at localhost:8801.

Production Deployment (Nginx Reverse Proxy)
To expose your application to the public web with proper security and SSL, you should use a reverse proxy like Nginx. Here is example configuration:

upstream axonasp_backend {
    server localhost:8801 max_fails=3 fail_timeout=30s;
}

server {
    listen 80;
    server_name myapp.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name myapp.example.com;

    ssl_certificate /etc/ssl/certs/myapp.crt;
    ssl_certificate_key /etc/ssl/private/myapp.key;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    location / {
        proxy_pass http://axonasp_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_buffering off;
        proxy_request_buffering off;
    }
}

Running as a Daemon
In a production Linux environment, you don't want to run the binary manually. AxonASP comes with a helper to handle the systemd installation automatically:

sudo ./axonasp-service install
sudo ./axonasp-service start

This will register AxonASP as a service, ensuring it starts automatically on boot.

Classic ASP doesn't have to be stuck in 1998. With the right tools, it's a viable, lightweight, and incredibly fast option for 2026.

We brought Classic ASP to Linux: Check out the AxonASP video and our new live manual!

Lucas Guimarães — Sun, 19 Apr 2026 22:00:31 +0000

Hey DEV community! 👋

Recently, I shared how I completely rewrote the Classic ASP engine from scratch in Go to save legacy applications from Microsoft's VBScript deprecation. Today, I'm super excited to share a short video presentation I just put together showing AxonASP 2.0 in action!

You can watch the full breakdown of how we achieved zero-AST execution, extreme speeds, and cross-platform compatibility right here:
👉 (Insert your YouTube Video Link here)

📖 More than just docs: A complete learning hub
One of the biggest challenges with older technology is that the old forums, tutorials, and documentation are slowly disappearing from the web. To fix this, we didn't just build an engine; we built a comprehensive, modern manual.

Whether you are a veteran migrating a legacy enterprise app or a modern developer wondering what ASP even is, the manual has you covered. It features:

The Basics: A complete, friendly refresher on fundamental Classic ASP concepts.

The Modern Extensions: Detailed, copy-pasteable examples on how to use our new native Go objects directly inside your VBScript. You'll learn how to parse APIs with G3JSON, fetch external resources with G3HTTP, and even render Markdown to HTML instantly using G3MD.

Containerization: Step-by-step guides on using our Docker containers so you can containerize your 20-year-old apps in seconds.

Real-time CLI: Instructions on how to use our interactive command-line interface. You can actually write, test, and learn ASP snippets in real-time, right from your terminal!

🤯 Eating our own dog food
Here is my favorite part: The manual itself is a Classic ASP application. If you visit the link below, you aren't just reading static files. That entire documentation site is currently running live in production, powered natively by the AxonASP engine, sitting securely behind an Nginx reverse proxy on a Linux server. It's fast, stable, and proves exactly what this architecture is capable of handling in the real world.

🔗 Explore it yourself
I'd love for you to watch the video, poke around the docs, and try it out. Let me know what you think of the architecture in the comments!

Read the live manual (running on AxonASP + Linux + Nginx): https://g3pix.com.br/axonasp/manual/default.asp

Check out the source code and drop a star: https://github.com/guimaraeslucas/axonasp

A 30-year-old language optimized for future: Building a Zero-AST Virtual Machine in Go that can run ASP

Lucas Guimarães — Tue, 14 Apr 2026 13:10:00 +0000

Hey DEV community! 👋 I'm back again.

If you think Classic ASP is dead, let me tell you: it is now more alive than ever.

Recently, I completed a total refactoring of the codebase for version 2.0 of AxonASP, my open-source Go engine for VBScript and Classic ASP. The goal wasn't just to keep legacy code breathing; I wanted to push the boundaries of what this 90s language could actually achieve on modern hardware.

I want to share some of the deep engineering optimizations we implemented under the hood to make this happen.

⚡ Zero AST, Pure Bytecode
In this rewrite, I made a huge architectural leap: threw out the Abstract Syntax Tree (AST).

Instead, the new single-pass compiler emits bytecode directly to a stack-based Virtual Machine. By eliminating the AST, AxonASP executes scripts with virtually zero-allocation overhead. The memory footprint drops drastically, and execution is fast.

🔄 IIS-Style VM Pooling & Advanced Caching
To handle high concurrency, I implemented an advanced VM pool modeled perfectly after the original IIS architecture, but backed by Go's native goroutines. Also I combined this with aggressive script caching, and even implemented compilation caching for dynamic execution (eval, execute, and executeglobal). The result is that request processing times are faster compared to traditional ASP

🛠️ Making ASP a Joy to Write Again
Pure speed is great, but developer experience matters just as much. We didn't stop at just supporting the legacy standard library. We injected over 60 custom Axon functions directly into the runtime. You now have access to advanced array manipulation, native JSON handling, and cryptographic tools right out of the box. It actually makes writing ASP a joy again.

🧪 Test-Driven ASP (Yes, really)
Say goodbye to broken scripts and regressions. I wanted to bring modern development practices to the language, so we built the new axonasp-testsuite executable. It allows you to write and run automated test suites natively, directly against your .asp files! TDD in Classic ASP is finally a reality.

If you are curious about how all of this works, or if you have a legacy application you want to rescue, we’ve put together a complete, comprehensive manual right inside the repository to help you get started.

Classic ASP might be a piece of retro-computing history, but with these optimizations, it's ready for the modern web. I'd love to hear what you guys think of.

👉 Check out the repo and the source code here: https://github.com/guimaraeslucas/axonasp

Microsoft killed VBScript, so I built a custom Go VM to bring Classic ASP into 2026

Lucas Guimarães — Sun, 12 Apr 2026 19:55:19 +0000

Hey DEV community! 👋

I don't have a formal IT degree—my day job is actually as a Doctor —but I am a self-taught Go developer with a massive passion for 90s retro-computing and legacy software preservation.

Recently, with Microsoft officially pulling the plug on VBScript and Classic ASP having been neglected for years, I realized a lot of legacy code was going to be left in the dark. Instead of letting it die, I decided to do something a little crazy: I completely rewrote the engine from scratch in Go.

Let me introduce you to AxonASP 2.0.

It’s an open-source project designed not just to keep legacy code alive, but to allow Classic ASP to actually evolve into the modern web era.

⚡ The Go Architecture: Why it's so fast
Writing an interpreter in Go has been an incredible engineering journey. I wanted to achieve extreme performance, so I threw out the traditional Abstract Syntax Tree (AST) approach.

Under the hood, AxonASP features a single-pass compiler that emits bytecode directly to a highly optimized, register-based Virtual Machine (AxonVM). By aggressively avoiding reflection and minimizing heap allocations in Go, the script execution overhead is practically zero. It’s insanely fast and memory-optimized, mimicking an IIS-style VM pool using Go's native concurrency (goroutines).

🛠️ Bringing ASP to the Modern Age
I didn't just want a 1:1 clone; I wanted to build the tools that ASP developers wished they had 20 years ago. Here is what the runtime currently includes:

Native AI Integration: It has a built-in MCP (Model Context Protocol) server. You can hook your AI agents/LLMs directly into the runtime to autonomously write and refactor ASP code based on your local environment.

A Real CLI & TUI: You can finally execute ASP and VBScript directly from your terminal! It features a Text User Interface, making it perfect for running cron jobs or system admin scripts.

Modern Workflows: AxonASP comes with a native test suite (axonasp-testsuite) so you can write automated assertions for your old ASP scripts.

Truly Cross-Platform: It runs natively on Windows, Linux, and macOS across most architectures. You are no longer chained to Windows Server.

Flexible Serving: It ships with both a FastCGI daemon (perfect for Nginx/Apache) and a built-in HTTP server.

📦 Try it out!
I would absolutely love to get feedback from this community. What do you think of the architecture? What modern features would you add to a language from the 90s?

You can check out the source code, the complete documentation, and architectural examples (yes, MVC in Classic ASP!) right here:

👉 https://github.com/guimaraeslucas/axonasp

Ah! You can also import and convert Access databases in Windows, and create prompts for IA Agents to code the ASP pages you want.

Note: If you just want to take it for a spin, the repo includes a simple Windows installer and a fully configured Docker setup so you can run it in seconds.

Let me know what you think in the comments! 💻🩺