DEV Community: Lucas Guimarães

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! 💻🩺