DEV Community: Lucas Guimarães

How to Render Web Pages with JavaScript and Caddy using AxonASP: Step-by-Step

Lucas Guimarães — Sun, 26 Jul 2026 23:10:52 +0000

Web development is constantly evolving, and sometimes the best way to move forward is to rethink how we serve our applications. If you are looking for a lightning-fast, zero-friction way to render server-side JavaScript pages natively within your web server, it is time to look at AxonASP integrated with the Caddy web server.

We are rewriting the future of server-side page rendering. By embedding the AxonASP runtime directly into Caddy, you get a powerful environment that executes server-side JavaScript right inside your HTTP handlers. Add Caddy's automatic HTTPS, and you can launch secure, dynamic services in seconds.

Here is a step-by-step guide on how to create a JavaScript-powered web page and launch it immediately using Caddy and AxonASP.

Step 1: Grab the Web Server

AxonASP provides a custom Caddy module that handles everything internally. This Zero-Process Architecture means you don't have to configure FastCGI workers, reverse proxies, or external daemons.

You have two simple options to get the server:

Option A: Download the Pre-Compiled Binary

The fastest way to start is to download a pre-compiled Caddy executable containing the embedded AxonASP module directly from the AxonASP repository release channel. Grab the version for your OS (Windows, Linux, or macOS) and place it in your system's binary path.

Option B: Build it from Source

If you prefer compiling it yourself or want to add other Caddy plugins, you can use xcaddy (the official Caddy builder tool).

# Install xcaddy
go install github.com/caddyserver/xcaddy/cmd/xcaddy@latest

# Build Caddy with the AxonASP module
xcaddy build --with g3pix.com.br/axonasp/caddy

Step 2: Configure the Caddyfile

Caddy's configuration is famously simple. To enable AxonASP processing, you just need to add the axonasp directive inside a route block alongside the standard file_server.

Create a file named Caddyfile in your project folder with the following configuration:

:8080 {
    root * ./www
    route {
        axonasp {
            site_name My_Web_site
            global_asa_path ./www/global.asa
        }
        file_server
    }
}

This tells Caddy to serve files from the ./www directory and route applicable pages through the AxonASP execution engine.

Step 3: Write Your Server-Side JavaScript Page

Now for the fun part. Let's create a dynamic web page using server-side JavaScript.

Create a folder named www in the same directory as your Caddyfile. Inside that folder, create a file named default.asp.

Add the following code to default.asp:

<%@Language="JavaScript"%>
<%
    // Server-side JavaScript logic
    var serverTime = new Date();
    var engine = Request.ServerVariables("SERVER_SOFTWARE");
    var visitorIP = Request.ServerVariables("REMOTE_ADDR");
%>
<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>AxonASP JavaScript Rendering</title>
    <style>
        body { font-family: system-ui, sans-serif; background: #f4f4f9; color: #333; padding: 2rem; }
        .card { background: #fff; padding: 2rem; border-radius: 8px; box-shadow: 0 4px 6px rgba(0,0,0,0.1); max-width: 600px; margin: 0 auto; }
        h1 { color: #0056b3; }
        .metric { font-weight: bold; color: #e83e8c; }
    </style>
</head>
<body>
    <div class="card">
        <h1>Rendered Natively with JS! 🚀</h1>
        <p>This page was generated completely server-side using JavaScript inside Caddy.</p>
        <hr>
        <ul>
            <li><strong>Current Server Time:</strong> <span class="metric"><%=serverTime.toUTCString()%></span></li>
            <li><strong>Powered by:</strong> <span class="metric"><%=engine%></span></li>
            <li><strong>Your IP:</strong> <span class="metric"><%=visitorIP %></span></li>
        </ul>
    </div>
</body>
</html>

By declaring <%@Language="JavaScript"%> at the top, AxonASP knows to evaluate the server-side blocks using its JavaScript engine before sending the final HTML to the client.

Step 4: Launch the Service Immediately

With your Caddyfile and your default.asp page ready, it is time to go live.

Open your terminal, navigate to the folder containing your Caddyfile, and run:

caddy run

Open your browser and navigate to http://localhost:8080.

You will immediately see your page, dynamically rendered by JavaScript on the server. Because AxonASP integrates deeply with Caddy, it natively respects standard index files (like default.asp), meaning you don't even need to type the file name in the URL.

What's Next?

You just spun up a fully functional server-side JavaScript rendering engine in less than a minute. This setup scales beautifully, natively supports Caddy's automatic HTTPS for production domains, and gives you a rapid, highly performant environment for building the next generation of web services.

Have you built any dynamic services with Caddy recently? Drop your thoughts in the comments below!

Run a Full JavaScript Website with AxonASP — No Node.js Required

Lucas Guimarães — Sat, 18 Jul 2026 21:36:45 +0000

AxonASP is a high-performance Classic ASP engine written in Go — but here's the twist: it runs JavaScript (JScript) natively on the server side. You get a synchronous, predictable execution model, full ECMAScript 5/6+ support, and zero dependency on Node.js or any third-party JavaScript runtime.

And yes — you can build an entire production website with it.

Why AxonASP Changes the Game for Server-Side JS

Most developers associate server-side JavaScript exclusively with Node.js. And Node.js is great — until you're drowning in async/await chains, package.json conflicts, and the 47th minor version bump of a dependency that broke your build.

AxonASP takes a fundamentally different approach.

Instead of wrapping everything in an event loop and forcing asynchronous patterns everywhere, AxonASP's JavaScript engine executes code synchronously by default. You write your server logic the same way you write your frontend logic — line by line, top to bottom. It compiles through a high-performance AST parser and runs directly on a custom Go-based virtual machine.

The result? Cleaner code, simpler debugging, and a massive reduction in cognitive overhead.

What You Get Out of the Box

Full ES5 + ES6 support (classes, arrow functions, template literals, destructuring, proxies, for...of, Map, Set, Symbol, typed arrays — 37+ modern features documented)
Synchronous execution — no callback pyramid, no promise chains for basic I/O
ASP intrinsic objects — Request, Response, Session, Application, Server — all accessible directly from your JS code
No npm install required — just write .asp or .js files and point the server at them
CLI execution — run JavaScript files from the command line for automation, batch processing, or testing

The Philosophy: Simplicity Over Complexity

Here's a hard truth: most web applications don't need 2,000 npm modules.

They need to read a database, render HTML, handle form submissions, and maybe serve a JSON API. That's it.

The modern JavaScript ecosystem has convinced people that every project requires a build pipeline, a bundler, a linter, a type checker, and a module graph resolver. But the reality is that a well-structured server-rendered application — where you can see the actual HTML structure of your pages and inject backend logic only where you need it — is often simpler, faster, and more maintainable than a single-page application backed by a microservice mesh.

With AxonASP, you write plain HTML with embedded server-side JavaScript. The <% %> delimiters mark exactly where the backend logic lives. You can see the entire page structure in one file. No hidden abstraction layers. No magic.

Bridging Frontend and Backend with G3TEMPLATE

One of the hidden gems in the AxonASP ecosystem is the G3TEMPLATE library — a high-performance template rendering engine powered by Go's html/template underneath.

Here's why it matters for teams:

The Designer-Developer Gap

If you've ever worked on a project where a frontend designer hands off HTML to a backend developer, you know the pain. The designer builds a beautiful page. The developer cuts it apart into templates, sprinkles in logic, and suddenly the design breaks because someone closed a <div> in the wrong partial.

G3TEMPLATE solves this by keeping your template files pure HTML with Go-style template syntax. The designer can open the template file directly in any browser and see exactly what the page will look like. The backend developer binds data through a clean Render(path, data) API.

No stepping on each other's toes. No broken layouts.

// Server-side JavaScript using G3TEMPLATE
<%@ Language="javascript" %>
<%
var template = Server.CreateObject("G3TEMPLATE");
var data = Server.CreateObject("Scripting.Dictionary");

data.Add("title", "My JavaScript-Powered Site");
data.Add("user", "Lucas");

var html = template.Render("/views/index.html", data);
Response.Write(html);
%>

The template file (/views/index.html) is a plain HTML file that your designer can open, edit, and preview without ever touching the server:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{{.title}}</title>
</head>
<body>
    <h1>Welcome, {{.user}}!</h1>
</body>
</html>

That's it. No template inheritance hierarchies. No custom DSL to learn. Just clean separation of concerns.

Step-by-Step: Building a JavaScript Website on AxonASP

Let's walk through creating an actual website. The entire thing, from scratch.

Step 1: Get AxonASP Running

Clone the repository and build the server:

git clone https://github.com/guimaraeslucas/axonasp.git
cd axonasp
./build.ps1

This gives you three executables:

axonasp-http.exe — standalone HTTP server
axonasp-fastcgi.exe — FastCGI server (for IIS/nginx integration)
axonasp-cli.exe — CLI runner for batch scripts

Start the HTTP server:

./axonasp-http.exe

By default, it serves files from the www/ directory on http://localhost:8801/.

Step 2: Create Your First JavaScript Page

Create www/index.html (yes, AxonASP serves static files too) or www/index.asp for a dynamic page:

<%@ Language="javascript" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title><%= Server.HTMLEncode(pageTitle) %></title>
    <link rel="stylesheet" href="/css/style.css">
</head>
<body>
    <header>
        <h1>Welcome to My JS-Powered Site</h1>
        <nav>
            <a href="/">Home</a>
            <a href="/about.asp">About</a>
            <a href="/api/products.asp">Products API</a>
        </nav>
    </header>

    <main>
<%
var features = [
    "Server-side JavaScript with ES6 support",
    "Zero npm dependencies",
    "Synchronous execution model",
    "Full ASP intrinsic object access",
    "G3TEMPLATE for clean template separation"
];

for (var i = 0; i < features.length; i++) {
%>
        <div class="feature-card">
            <h3>Feature #<%= i + 1 %></h3>
            <p><%= features[i] %></p>
        </div>
<%
}
%>
    </main>

    <footer>
        <p>Page generated at: <%= new Date().toString() %></p>
    </footer>
</body>
</html>

Step 3: Build a JSON API

One of my favorite use cases — a REST API endpoint with zero dependencies:

<%@ Language="javascript" %>
<%
Response.ContentType = "application/json";

var products = [
    { id: 1, name: "Wireless Mouse", price: 29.99, inStock: true },
    { id: 2, name: "Mechanical Keyboard", price: 89.99, inStock: true },
    { id: 3, name: "USB-C Hub", price: 49.99, inStock: false }
];

var idParam = Request.QueryString("id");

if (idParam !== "") {
    var id = parseInt(idParam, 10);
    var found = null;
    for (var i = 0; i < products.length; i++) {
        if (products[i].id === id) {
            found = products[i];
            break;
        }
    }
    Response.Write(JSON.stringify({
        success: true,
        data: found || null
    }));
} else {
    Response.Write(JSON.stringify({
        success: true,
        count: products.length,
        data: products
    }));
}
%>

No Express, no router, no body-parser, no cors middleware. Five lines of setup, then just JavaScript.

Step 4: Use Modern ES6 Features

Yes, you can use arrow functions, template literals, destructuring, Map, Set, for...of, and even Proxy:

<%@ Language="javascript" %>
<%
// Classes
class Product {
    constructor(name, price) {
        this.name = name;
        this.price = price;
    }

    get formatted() {
        return `${this.name} — $${this.price.toFixed(2)}`;
    }
}

// Arrow functions + template literals
const products = [
    new Product("Widget A", 9.99),
    new Product("Widget B", 14.99)
];

const html = products
    .map(p => `<li>${p.formatted}</li>`)
    .join('\n');
%>
<ul><%= html %></ul>

Step 5: Run from the CLI

Need to automate something? Write a JavaScript file and run it directly:

./axonasp-cli.exe -r scripts/generate-report.js -m javascript

Your scripts have full access to Response, Server, custom libraries (G3JSON, G3FILES, G3CRYPTO, and more), and the console object for logging. Perfect for scheduled tasks, data transformations, or batch processing.

The Full Architecture Picture

Here's what the project structure looks like for a typical AxonASP JS website:

axonasp/
├── axonasp-http.exe       # HTTP server binary
├── axonasp-cli.exe        # CLI runner binary
├── global.asa             # App/session lifecycle (JS or VBScript)
├── config/
│   └── axonasp.toml       # Server configuration
├── www/                   # Web root
│   ├── index.asp          # JavaScript-powered homepage
│   ├── about.asp
│   ├── css/
│   │   └── style.css
│   ├── js/                # Client-side JS files (static)
│   ├── views/             # G3TEMPLATE template files
│   │   ├── header.html
│   │   ├── footer.html
│   │   └── layout.html
│   └── api/               # REST API endpoints
│       └── products.asp
└── scripts/               # CLI automation scripts
    └── cleanup.js

No node_modules/. No package.json. No webpack.config.js. No .babelrc.

Just your code, your templates, and a server that runs them.

When Should You Use This?

AxonASP with server-side JavaScript is a strong fit when:

You want full-stack JS without the Node.js ecosystem overhead
You're building server-rendered websites where clean HTML matters
You need a simple API layer without framework boilerplate
You work with designers who need to see and edit HTML templates directly
You value synchronous, predictable code flow over async abstractions
You're migrating legacy Classic ASP applications and want to modernize gradually

It's not a replacement for Node.js in every scenario — if you need WebSockets, streaming, or event-driven microservices, stick with what works. But for the vast majority of web applications — content sites, dashboards, API backends, CMS platforms — this stack is remarkably efficient.

Dive Deeper

The official AxonASP documentation has an entire section dedicated to JavaScript support, with detailed pages for every ES6 feature, the G3TEMPLATE library, and the ASP intrinsic objects:

👉 JavaScript Support in AxonASP

You can also explore the full source code, download binaries for Mac, Linux, FreeBSD and Windows or contribute on GitHub:

👉 AxonASP on GitHub

Have you tried running server-side JavaScript without Node.js? I'd love to hear about your experience in the comments. If you found this useful, follow me for more deep dives into practical, no-nonsense web development.

Modernizando o Classic ASP: Um guia prático para hospedar o AxonASP usando o IIS

Lucas Guimarães — Fri, 03 Jul 2026 11:00:00 +0000

Sejamos honestos: quando a maioria dos desenvolvedores ouve falar em "Classic ASP", logo imaginam servidores Windows legados, registros complexos de objetos COM e uma arquitetura profundamente atrelada ao asp.dll e ao processo de trabalho do IIS (w3wp.exe).

Mas o código em si — muitas vezes milhares de linhas de lógica de negócios crítica escritas em VBScript ou JavaScript no lado do servidor — ainda cumpre exatamente o seu papel. O problema não é necessariamente a linguagem; é a arquitetura de hospedagem monolítica e envelhecida.

É aqui que o AxonASP muda o jogo. Construído em Go, ele desvincula completamente o ASP do sistema operacional Windows, executando o código nativamente e reduzindo o uso de memória em modo ocioso para cerca de 18MB.

No entanto, mudar para esse motor exige uma virada de chave fundamental na forma como você pensa sobre a hospedagem das suas aplicações.

A mudança de paradigma: Arquitetura centrada na aplicação

Em relação à arquitetura de hospedagem: o AxonASP não é um substituto direto para o IIS; ele é um ambiente de execução (runtime) de Classic ASP. Ele opera em uma arquitetura moderna e centrada na aplicação — estruturalmente idêntica à forma como aplicações modernas em .NET Core ou Docker são implantadas.

Isso significa que todas as suas configurações existentes do IIS continuam totalmente válidas. Para orquestrar o AxonASP adequadamente dentro do IIS, você deve usar o módulo HttpPlatformHandler v1.2+. Você pode ler mais sobre essa configuração no manual oficial aqui:

Por exemplo, no arquivo axonasp.toml, você pode definir o diretório raiz para coincidir com o diretório padrão do seu site no IIS. Isso permite que você sirva seus arquivos estáticos (CSS, JS, imagens) nativamente pelo IIS, enquanto o AxonASP cuida da lógica da aplicação e das requisições dinâmicas .asp.

A ideia principal é universalizar e implementar práticas modernas de administração para o ASP, permitindo que ele rode em qualquer plataforma ou servidor. Dessa forma, se um site sair do controle ou esgotar a memória, ele não derrubará as outras aplicações nem o servidor principal, porque cada aplicação roda sua própria instância isolada e distinta do axonasp-http.exe.

Essa estrutura também permite que você rode o ASP dentro de containers Docker, reduzindo significativamente os custos associados a servidores Windows. Pode parecer um pouco complexo no início, mas com certeza vale a pena migrar para essa abordagem — ela é mais segura, altamente distribuível, mais barata e, no fim das contas, mais fácil de gerenciar.

Passo a passo: Implementando o AxonASP no IIS

Como o IIS gerencia o FastCGI via named pipes do Windows (que são incompatíveis com os protocolos FastCGI padrão baseados em TCP), não podemos simplesmente plugar o AxonASP como um módulo legado. Em vez disso, o IIS agirá como um proxy reverso, ficando na borda da sua rede (Portas 80/443) e encaminhando as requisições dinâmicas para instâncias isoladas do AxonASP que rodam em portas locais de loopback (ex: 8801, 8802).

Veja como configurar:

1. Pré-requisitos

Você precisará do IIS HttpPlatformHandler v1.2+. Este é o exato mesmo módulo que a Microsoft recomenda para gerenciar aplicações Python ou Java atrás do IIS. Ele cuida do gerenciamento de processos, atribui portas dinamicamente e garante que o executável do AxonASP continue rodando.

2. Diretórios e permissões

Digamos que o seu site esteja localizado em C:\Sites\App1\.
Dentro desta pasta, você deve ter:

O binário axonasp-http.exe.
O arquivo de configuração axonasp.toml.
O script de inicialização iis-http.cmd (fornecido com o AxonASP).
A sua pasta www contendo os arquivos .asp.

Passo crucial: A identidade de usuário do IIS (geralmente IIS_IUSRS ou a ApplicationPoolIdentity específica) deve ter permissões de leitura e escrita nesta pasta. O AxonASP precisa gravar em seu diretório temporário (temp) e executar os binários. Se faltarem permissões, o IIS falhará silenciosamente e retornará um erro 500 Internal Server Error.

3. A configuração do `web.config`

Insira um arquivo web.config na raiz do seu site no IIS. Isso instrui o IIS a interromper a tentativa de processar o código nativamente e, em vez disso, passá-lo para o processo do AxonASP.

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <system.webServer>
        <handlers>
            <add name="httpPlatformHandler" path="*" verb="*" modules="httpPlatformHandler" resourceType="Unspecified" />
        </handlers>

        <httpPlatform processPath="C:\Sites\App1\iis-http.cmd"
                      arguments="--server.server_port %HTTP_PLATFORM_PORT%"
                      stdoutLogEnabled="true"
                      stdoutLogFile="C:\Sites\App1\temp\axonasp.log"
                      startupTimeLimit="5"
                      processesPerApplication="1">
            <environmentVariables>
                <environmentVariable name="SERVER_PORT" value="%HTTP_PLATFORM_PORT%" />
            </environmentVariables>
        </httpPlatform>
    </system.webServer>
</configuration>

Entendendo a mecânica da configuração

Existem dois detalhes críticos no XML acima que ditam como a sua aplicação vai se comportar:

%HTTP_PLATFORM_PORT%: Você não precisa atribuir manualmente a porta 8801 para o Site A e 8802 para o Site B. O IIS gera uma porta disponível de forma dinâmica, injeta-a na variável de ambiente, inicializa o processo do AxonASP e direciona o tráfego para ela automaticamente.
processesPerApplication="1": Não altere este valor para um número maior. O Classic ASP depende muito de estado em memória (variáveis de Session e o ciclo de vida do global.asa). Se o IIS gerar múltiplos processos de trabalho (worker processes) para um único site, as sessões dos usuários ficarão fragmentadas entre eles. O AxonASP gerencia a concorrência internamente por meio de goroutines; ele precisa de apenas um processo do sistema operacional por site.

Por que esta arquitetura é o futuro do ASP

Ao desacoplar o motor de execução do sistema operacional, você não fica mais preso à infraestrutura legada do Windows.

A era pós-COM: O AxonASP intercepta chamadas de Server.CreateObject("ProgID") nativamente. Em vez de depender do frágil Registro do Windows para carregar uma DLL antiga, o AxonASP mapeia essa chamada para um código GoLang moderno de alta velocidade pré-compilado dentro da VM.
Infraestrutura como código: Suas regras de roteamento, configurações e variáveis de ambiente agora são arquivos de texto simples (.toml e .config) que acompanham o repositório da sua aplicação.
O horizonte com Docker: Depois de migrar com sucesso um site para este modelo de proxy no IIS, migrar esse mesmo site para um container Docker em Linux atrás do Nginx ou Caddy exigirá praticamente zero alterações na lógica da aplicação.

O Classic ASP pode ter décadas de idade, mas com um motor construído em Go e uma arquitetura que reflete os microsserviços modernos, não há razão para que ele não possa rodar na vanguarda da infraestrutura web atual.

🛑 Why You Shouldn't Migrate from Classic ASP to ASP.NET (If You Have AxonASP)

Lucas Guimarães — Thu, 02 Jul 2026 14:31:49 +0000

For over two decades, the standard advice for any team maintaining a Classic ASP application has been identical: "You need to migrate to ASP.NET."

The arguments are always the same. Classic ASP is dated, VBScript is a relic, and modern development requires modern frameworks. For a long time, rewriting your entire application in ASP.NET seemed like the only logical path forward, despite the astronomical costs and the high risk of breaking core business logic.

But what if the industry's default advice is no longer the best option?

Let’s be clear: ASP.NET is an incredibly powerful, feature-rich ecosystem. We aren't here to bash it. But when it comes to modernizing existing legacy applications, forcing a migration might actually do more harm than good.

Here is why staying with Classic ASP—powered by AxonASP—is not only viable but often the smarter engineering choice for the modern web.

🧠 The Memory Tax of ASP.NET

When you migrate a lightweight, procedural Classic ASP application to the ASP.NET ecosystem, you are fundamentally changing the architectural footprint of your software.

ASP.NET is robust, but that robustness comes with a significant overhead. The framework is notorious for its intensive memory usage, spinning up complex application pools, managing heavy object lifecycles, and relying on a massive runtime environment. If your application currently serves dynamic pages with minimal server strain, moving to ASP.NET can drastically inflate your infrastructure costs and hardware requirements. You end up paying for a massive enterprise toolset when all you needed was to render a page and query a database.

Because AxonASP is built under the hood as a cross-platform runtime server written in GoLang, it turns this dynamic on its head. You get the blistering speed, concurrency, and minimal memory footprint of Go, while executing your existing legacy code. It sips memory where heavy frameworks gulp it.

📦 "But What About Modern Libraries?"

The strongest argument against Classic ASP has always been the ecosystem. Developers migrate because they want access to modern cryptographic functions, API integrations, and JSON handling, which native VBScript struggles to provide.

This is where the paradigm shifts. AxonASP bridges this exact gap by exposing modern libraries directly to the legacy environment. You don't need a heavy framework to parse modern data structures or communicate with RESTful microservices. The runtime injects the capabilities you expect from a 2026 tech stack right into your existing pages. You retain the simplicity of your original architecture without being cut off from modern web standards.

🤝 VBScript + JavaScript: The Ultimate Polyglot Harmony

Perhaps the most daunting part of any migration is the human element. Maybe nobody wants to write or maintain thousands of lines of VBScript anymore, and finding developers who can is getting harder every day.

But what if you didn't have to choose between rewriting it all or forcing new devs to learn VBScript?

AxonASP allows VBScript and JavaScript to run simultaneously on the exact same page. This is the secret weapon for modernizing without migrating:

Keep the Foundation: Leave your complex, battle-tested VBScript business rules and database queries exactly as they are. They work. Don't touch them.
Write the Future in JS: When a new requirement comes in, your new hires can simply open a <script runat="server" language="javascript"> tag and write the new features using the modern JavaScript syntax they already know.

By combining VBScript and JavaScript seamlessly, you instantly modernize the developer experience. Your team can utilize arrays, modern loops, and JS logic while interacting directly with the legacy state.

🚀 Stop Migrating, Start Evolving

Rewriting a system to ASP.NET just to escape VBScript is like knocking down a structurally sound house because you don't like the wallpaper.

By leveraging a lightweight GoLang-powered runtime, bringing in modern library support, and mixing JS with VBScript, AxonASP proves that Classic ASP still belongs in the modern world. You bypass the massive memory overhead of heavy frameworks, save thousands of hours of development time, and eliminate the risk of a "big bang" rewrite.

Sometimes, the best migration strategy is realizing you don't need to migrate at all.

Rodando ASP Classic no Linux, macOS, BSD e Windows em 2026

Lucas Guimarães — Thu, 02 Jul 2026 11:00:00 +0000

Se você já se pegou pesquisando como rodar ASP no Linux ou tentando descobrir como colocar no Docker uma aplicação antiga dependente do IIS, você já conhece o tamanho do desafio. Por anos, o Classic ASP e o VBScript ficaram totalmente presos ao ecossistema Windows. Tudo bem que temos o ASP.NET, mas mais de centenas de megabytes de memória e de executáveis para rodar uma simples página? Não, obrigado.

Seja para a manutenção de um sistema corporativo legado ou para buscar um motor de scripts leve no lado do servidor para um novo projeto, migrar para fora do Windows Server historicamente significava uma reescrita completa do código.

É aí que entra o AxonASP, um runtime de código aberto e alta performance escrito em GoLang que permite rodar o ASP Classic nativamente no Linux, macOS, BSD e Windows e o melhor, com suporte a VBScript mas também a JavaScript.

Mas o AxonASP não é apenas um emulador para códigos antigos — ele é um motor modernizado e projetado para o futuro do desenvolvimento web. Abaixo, mostramos uma visão técnica de como ele funciona, o que ele suporta e por que ele pode ser a ferramenta certa para a sua próxima mudança arquitetônica.

Uma arquitetura moderna para uma stack clássica

Em sua essência, o AxonASP foi construído com foco em velocidade, baixo consumo de memória e infraestrutura moderna. Ele conta com uma arquitetura de Máquina Virtual com alocação zero (zero-allocation) que processa requisições de forma incrivelmente rápida.

Quando você decide rodar ASP Classic no Linux usando o AxonASP, você não está executando uma camada de compatibilidade pesada. O motor compila o VBScript por meio de um compilador de passagem única (single-pass), emitindo bytecode diretamente para uma VM baseada em pilha. Isso resulta em velocidades extremas de processamento com um consumo mínimo de memória. Uma configuração padrão consegue lidar com 2000 requisições por minuto consumindo apenas cerca de 100MB de RAM. Uma API pura em VBScript rodando no AxonASP consome apenas 17MB em modo ocioso (em comparação com os 30MB do Node.js).

Flexibilidade de implantação: Do Docker ao WASM

O DevOps moderno exige flexibilidade. O AxonASP foi desenvolvido para se encaixar em pipelines de CI/CD atuais sem esforço, oferecendo múltiplas estratégias de implantação prontas para uso:

Servidor Proxy Autônomo: Rode diretamente com seu servidor HTTP embutido. Trazemos o conceito de aplicações para seu desenvolvimento, você não depende mais do servidor. Faça o envio do pacote do AxonASP, redirecione seu servidor via proxy para o endereço local e tudo funciona como deve.
FastCGI: Integre perfeitamente com Nginx ou Apache (axonasp-fastcgi).
Docker: "Conteinerize" suas aplicações Classic ASP nativamente para Kubernetes ou Docker Swarm.
Interface de Linha de Comando (CLI): Execute scripts ASP diretamente do seu terminal. E quer um detalhe? Você pode programar e até executar scripts Javascript podendo administrar seu sistema sem grandes complicações. Faça a manutenção do Linux ou do Windows usando a suíte do AxonASP.
WebAssembly (WASM): Você pode até compilar e rodar VBScript de alta performance diretamente no navegador.

Além do VBScript: Suporte de primeira classe para JavaScript (ES6+)

Um dos recursos mais poderosos do AxonASP é o seu motor JavaScript. Ao contrário dos ambientes ASP tradicionais que tinham um suporte limitado ao JScript, o AxonASP traz suporte totalmente compatível com o ECMAScript 6+.

E o melhor de tudo: você pode misturar VBScript e JavaScript na mesmíssima aplicação. Isso muda completamente o jogo na hora de modernizar sistemas. Em vez de uma reescrita do tipo "arrancar e substituir" — que é cara e de alto risco —, você pode manter sua lógica de negócios principal em VBScript rodando perfeitamente enquanto escreve novos módulos, integrações de API e utilitários em JavaScript moderno. Você pode organizar seu código JS facilmente usando a sintaxe de módulos CommonJS/ES6 diretamente ao lado dos seus arquivos .asp.

Como o motor JavaScript utiliza um modelo de execução direta baseado em AST (em vez de forçar um paradigma baseado em Promises para cada operação simples), ele é extremamente eficiente em termos de memória. Uma API pura em JS rodando no AxonASP consome cerca de ~18MB de memória em modo ocioso.

Feito para a era da IA: O servidor MCP

Desenvolver em 2026 exige ferramentas modernas. O AxonASP já vem integrado com um servidor MCP (Model Context Protocol).

Isso permite que agentes de programação baseados em IA e IDEs alimentadas por LLMs (como Cursor ou Claude) se conectem diretamente ao seu ambiente de execução. A IA consegue analisar o ambiente do seu servidor, entender as bibliotecas nativas G3 disponíveis (como G3JSON, G3DB e G3CRYPTO) e criar ou depurar páginas ASP de forma autônoma.

Ele também traz uma suíte de testes completa (testsuite) para garantir que sua base de código permaneça estável à medida que você avança.

Não apenas para legados: Construindo o futuro com o AxonLive

Embora o AxonASP seja a solução perfeita para rodar ASP Classic no Linux ou Mac, ele também serve como um framework para a construção de novas aplicações modernas.

O motor inclui o AxonLive, um framework de componentes reativos de alta performance integrado diretamente na VM. Se você já tem familiaridade com ferramentas como HTMX, Livewire ou Blazor, o AxonLive oferece um paradigma semelhante, mas nativo no ASP.

Com o AxonLive, as interações da interface do usuário (cliques, formulários, temporizadores) são enviadas ao servidor de forma assíncrona. Toda a lógica de negócios e validação acontecem de forma segura no backend, e o servidor responde com patches JSON direcionados que atualizam o DOM de forma limpa — sem exigir recarregamentos completos da página. O cliente age simplesmente como um terminal leve de renderização, entregando interatividade de Single Page Application (SPA) com a performance bruta do servidor direto no metal.

Como começar

Você pode fazer o download no repositório dos releases, que já conta com as versões empacotadas para sistemas baseados em Debian, RedHat, Alpine e Windows (versão ZIP e com instalador), essa é a forma mais fácil e direta.

Agora por ser escrito em Go, se você quiser compilar a partir do código-fonte (requer GoLang 1.26+), basta utilizar os scripts de compilação inclusos:

Linux / macOS:

./build.sh --platform "linux" --architecture "amd64"

Windows:

.\build.ps1

O AxonASP também vem acompanhado de mais de 60 bibliotecas nativas (manipulação de JSON, conectores de banco de dados para PostgreSQL/MySQL/Oracle, SMTP, processamento de imagem e pacotes de compressão), o que significa que você pode construir aplicações corporativas robustas com zero overhead e sem depender de DLLs de terceiros. E distribuir é simples, apenas faça o deploy do executável, da pasta de configuração e do diretório ./www/. Pronto.

Junte-se à comunidade Open Source

O AxonASP é orgulhosamente de código aberto. Se você é um desenvolvedor querendo libertar suas aplicações legadas do IIS, ou se quer explorar um motor server-side altamente eficiente que une a simplicidade do ASP com recursos modernos da web, conheça o projeto.

Repositório no GitHub: https://github.com/guimaraeslucas/axonasp
Manual Oficial & Documentação: https://g3pix.com.br/axonasp/manual/
Playground & Exemplos Online: Explore páginas rodando nativamente no AxonASP 2.2 e teste nosso Playground em WASM em https://g3pix.com.br/axonasp/wasm/

Não deixe que a infraestrutura legada segure o seu código. Conteinerize, rode no Linux, misture com JavaScript moderno e comece a construir.

Como rodar Classic ASP no Linux: Um guia passo a passo para instalar o AxonASP no Ubuntu ou Debian

Lucas Guimarães — Wed, 01 Jul 2026 11:00:00 +0000

Introdução
Hospedar aplicações Classic ASP (Active Server Pages) tradicionalmente significava estar acorrentado ao Windows Server e ao IIS. Para desenvolvedores que dão manutenção em aplicações legadas ou que buscam migrar sistemas VBScript antigos para uma infraestrutura moderna e de melhor custo-benefício, encontrar uma alternativa nativa para Linux sempre foi um grande desafio. E para nós no Brasil mais ainda, frente aos altos valores de licenciamento do Windows Server.

É aí que entra o AxonASP, um ambiente de execução (runtime) de código aberto e multiplataforma construído em GoLang. Ele foi projetado especificamente para hospedar aplicações Classic ASP nativamente em sistemas modernos como Linux, BSD e macOS. Em vez de depender de máquinas virtuais pesadas, emuladores ou gambiarras complexas, o AxonASP oferece um ambiente enxuto para rodar seus arquivos VBScript/JavaScript diretamente.

Neste tutorial, vamos passar pelo processo de instalação do runtime AxonASP em um servidor Ubuntu ou Debian usando o pacote .deb pré-compilado.

Pré-requisitos

Um servidor rodando uma distribuição Linux baseada em Ubuntu ou Debian.
Acesso à linha de comando com privilégios de sudo.
wget ou curl instalado para baixar o pacote.

Passo 1: Baixar o pacote de codificação
A maneira mais fácil de instalar o AxonASP em sistemas baseados em Debian é através dos pacotes .deb oficiais disponibilizados no repositório do projeto no GitHub.

Abra o seu terminal e use o wget para baixar a versão desejada. (Nota: A URL abaixo usa a versão 2.1.7 como exemplo. Sempre verifique o repositório para obter a versão mais recente).

wget https://github.com/guimaraeslucas/axonasp/releases/download/v2.2.8/axonasp_2.2.8_amd64.deb

Passo 2: Instalar o pacote `.debAssim que o download for concluído, use o comandodpkg` para instalar o pacote no seu sistema.

sudo dpkg -i axonasp_2.2.8_amd64.deb

Dica: Se você encontrar qualquer erro de dependência durante a instalação, basta rodar sudo apt-get install -f para resolvê-los facilmente.

Passo 3: Entender a estrutura de diretórios
Após o sucesso da instalação, o runtime é descompactado de forma organizada no diretório /opt/axonasp/. É útil conhecer os componentes principais incluídos nesse caminho:

/opt/axonasp/ - O diretório principal da instalação.
/opt/axonasp/axonasp-http - O binário do servidor web HTTP autônomo, perfeito para implantações rápidas, testes ou desenvolvimento.
/opt/axonasp/axonasp-fastcgi - O binário do servidor de aplicação FastCGI, ideal para ambientes de produção ao integrá-lo com proxies reversos como Nginx ou Apache.

Passo 4: Instalar e ativar o serviço em segundo plano
Para garantir que o runtime do AxonASP rode continuamente e inicialize de forma automática sempre que o seu servidor for reiniciado, você precisa configurá-lo como um serviço do systemd. O pacote de instalação inclui um script em bash bem prático para automatizar exatamente esse processo.

Navegue até o diretório de instalação e execute o script de instalação do serviço:

cd /opt/axonasp
sudo bash install-service.sh

Em seguida, inicialize o serviço e ative-o para que ele persista após as reinicializações do sistema:

sudo systemctl start axonasp
sudo systemctl enable axonasp

Passo 5: Verificar a instalação
Análise se está tudo rodando perfeitamente checando o status do serviço com o systemctl:

sudo systemctl status axonasp

Você deverá ver uma saída indicando que o serviço está "active (running)" (ativo/em execução). A partir de agora, seu servidor Linux está oficialmente pronto para processar arquivos .asp e executar VBScript/JavaScript nativamente!

Conclusão
Rodar Classic ASP não significa que sua infraestrutura precisa ficar presa para sempre a sistemas operacionais antigos e que o sistema precise ser recriado do zero. Ao utilizar um runtime moderno como o AxonASP, você consegue dar uma nova vida a aplicações web antigas, aproveitando a estabilidade, a segurança e a performance dos ambientes Linux. E criar aplicações compatíveis com o ambiente moderno Web.

Para configurações mais avançadas — incluindo a definição do Nginx como proxy reverso, configuração de hosts virtuais ou exploração da implementação FastCGI — confira a documentação oficial do AxonASP.

Além da IA: Por que a colaboração humana é o verdadeiro motor do Open Source

Lucas Guimarães — Wed, 01 Jul 2026 00:00:00 +0000

A narrativa atual da tecnologia está fortemente inclinada para a automação. Com agentes de IA escrevendo boilerplate, gerando componentes e até estruturando projetos inteiros, é fácil olhar para o futuro do desenvolvimento de software e assumir que o elemento humano está diminuindo.

Mas se você mantém ou contribui ativamente para um projeto open source, sabe que a realidade é bem diferente. A IA pode escrever código, mas não consegue validá-lo contextualmente contra décadas de edge cases obscuros. Ela não sabe dizer por que uma regra de negócio específica falha em produção.

Mais importante ainda: a IA não constrói comunidade. A evolução de um software robusto ainda depende inteiramente de pessoas colaborando, quebrando código, reportando bugs e validando se o código realmente funciona no mundo real.

Para ver isso na prática, precisamos olhar para projetos que tentam fechar lacunas geracionais gigantescas na tecnologia. Um exemplo perfeito disso é o AxonASP.

A Filosofia do AxonASP: Modernizando o Legado

Por muito tempo, o ASP Clássico e o VBScript foram considerados presos a um modelo de servidor obsoleto — amarrados ao IIS e deixados para trás pelas práticas modernas de deploy. O AxonASP muda esse cenário. É um runtime open source e cross-platform que trata o ASP Clássico como uma Aplicação moderna, em vez de uma relíquia do passado. Ele traz o VBScript, o ASP e, principalmente, o suporte ao JavaScript Síncrono para o futuro.

Construir um runtime que lida com código legado enquanto opera em um ecossistema moderno e multiplataforma não é algo que você consegue simplesmente pedindo para um LLM. Exige um ciclo de feedback agressivo.

O AxonASP está em franca evolução e apresenta altíssima compatibilidade com o ASP Clássico. Mas essa compatibilidade não é mágica — ela é o resultado direto de usuários pegando seus scripts legados de 15 a 20 anos atrás, rodando no motor, vendo onde falham e reportando exatamente o que aconteceu. Cada issue aberta e cada bug reportado por um desenvolvedor testando seu código do mundo real é o que fortalece a plataforma.

A Métrica Silenciosa do Open Source: Apoio Financeiro

Falamos muito sobre pull requests e issue tracking, mas há outro pilar da colaboração humana sobre o qual costumamos falar baixo: o suporte financeiro.

Mantenedores de projetos abertos são desenvolvedores com contas a pagar. Quando uma comunidade apoia financeiramente um projeto, ele deixa de ser um hobby de fim de semana e passa a ter foco dedicado. Contribuições monetárias compram o tempo de foco profundo necessário para resolver desafios arquitetônicos complexos que PRs casuais raramente resolvem.

Neste mês, por exemplo, o aporte financeiro da comunidade permitiu que a equipe do AxonASP dedicasse horas sérias para expandir significativamente a compatibilidade com bibliotecas legadas. Graças a esse apoio direto, o projeto conseguiu entregar uma atualização técnica massiva:

A Biblioteca G3DATE: Uma nova biblioteca nativa que finalmente permite ao AxonASP calcular diferenças entre datas e lidar com timezones de forma fluida.
Implementação de STA (Single-Threaded Apartment): Um upgrade arquitetônico vital que garante muito mais estabilidade e segurança ao servidor durante a execução de componentes OLE legados.
Objeto Math Aprimorado: Lançado com métodos e propriedades adicionais para lidar nativamente com cálculos mais complexos.
Motor JScript Fortalecido: Adição de testes abrangentes para a funcionalidade do JScript, cobrindo explicitamente Date, typeof e os notórios comportamentos de coerção de tipos (coercion).
Melhoria na Manipulação de Tipos: Uma implementação fortemente refinada do Object.prototype.toString para lidar adequadamente com Arrays e outros tipos nativos.

Nada disso seria possível sem uma abordagem de três frentes para a colaboração: desenvolvedores enviando código, usuários caçando bugs implacavelmente e apoiadores fornecendo o fôlego financeiro para que o trabalho pesado seja feito.

O Toque Humano Segue Invicto

A IA é uma ferramenta fantástica para acelerar a sintaxe, mas o open source é fundamentalmente um ecossistema humano. Ele se baseia no atrito compartilhado por desenvolvedores tentando resolver problemas reais.

Projetos como o AxonASP provam que, quando você combina uma visão técnica ousada — como ressuscitar o JS Síncrono e o ASP Clássico para ambientes modernos e multiplataforma — com uma comunidade ativa, que testa e apoia, os resultados são incríveis.

O código pode ser o que executa na máquina, mas as pessoas fazem o sistema funcionar.

Se você quiser ver como estamos trazendo o ASP Clássico para a era moderna, dê uma olhada no repositório do AxonASP. Traga o seu código legado mais antigo e complexo, tente quebrar o runtime e nos diga o que acontece.

Modernização de Sistemas Legados: Reduzindo o Débito Técnico com AxonASP

Lucas Guimarães — Tue, 30 Jun 2026 14:00:33 +0000

O mercado de modernização de software está crescendo em ritmo acelerado, com projeções indicando que o setor atingirá mais de US$ 66 bilhões nos próximos anos, segundo relatórios recentes da Keyhole Software. À medida que o débito técnico se acumula e a adoção da nuvem se torna padrão, as empresas percebem que reescrever sistemas inteiros do zero é uma estratégia cara, demorada e com altas taxas de falha. A tendência dominante hoje é a modernização incremental, focada em reduzir riscos sem interromper as operações do negócio.
É nesse cenário de transição que ambientes de execução cross-platform desenvolvidos em GoLang, como o AxonASP, ganham protagonismo. Projetado para revolucionar a forma como mantemos e escalamos aplicações Classic ASP, o AxonASP entrega a ponte perfeita entre a estabilidade do código legado e a agilidade das arquiteturas modernas, com mínimo esforço de adaptação.

Adaptação Sem Atrito: De Objetos COM a Objetos G3

Um dos maiores gargalos na modernização de aplicações antigas é o profundo acoplamento com objetos COM nativos. Em métodos tradicionais, migrar essas dependências significa reescrever vastas camadas de regras de negócios, paralisando outras entregas de TI.
O AxonASP contorna essa barreira de forma direta e eficiente. A plataforma permite que a base do código original permaneça intacta, exigindo apenas o mínimo esforço para adaptar as configurações existentes. Ao redirecionar velhas chamadas de objetos COM para objetos G3, o desenvolvedor consegue integrar o sistema legado às bibliotecas e serviços da nova infraestrutura. Esse processo mantém as engrenagens vitais da aplicação rodando com alta performance e isolamento adequado, dispensando os riscos de um "big bang" (reescrita total).

A Inovação da Interoperabilidade: VBScript e JavaScript Lado a Lado

O envelhecimento da força de trabalho especializada e a dificuldade de encontrar profissionais fluentes em linguagens antigas inflacionam drasticamente os custos de manutenção corporativa.
Para combater essa dor do mercado, o AxonASP introduz sua funcionalidade mais transformadora: o suporte combinado e nativo de JavaScript e VBScript dentro da mesma página.
Em vez de forçar a equipe a traduzir linhas e mais linhas de VBScript para linguagens modernas antes de adicionar novas funcionalidades, o AxonASP permite que o código antigo continue existindo perfeitamente ao lado de novos blocos de lógica escritos em JavaScript.

Capacitando a Nova Geração de Desenvolvedores

Essa coexistência de linguagens muda radicalmente o perfil das equipes que podem atuar no projeto, resolvendo de vez o problema da escassez de talentos para sistemas legados:

Integração Imediata de Novos Programadores: Desenvolvedores recém-contratados, que dominam ecossistemas modernos (como Node, JavaScript puro e frameworks como Vue.js), não precisam enfrentar a curva de aprendizado do VBScript. Eles podem abrir um arquivo .asp, compreender a estrutura e começar a codificar atualizações diretamente em JavaScript.
Modernização Módulo a Módulo: A equipe de engenharia pode refatorar a aplicação progressivamente. Funções críticas em VBScript podem ser substituídas aos poucos por funções em JavaScript, diluindo o risco técnico em sprints menores.
Manutenção Descomplicada: Como as regras antigas ainda funcionam e as novas podem ser escritas na linguagem mais popular do mundo, a manutenção deixa de ser um peso morto e passa a fluir de maneira natural no ciclo de desenvolvimento contínuo.

Conclusão

As tendências de mercado deixam claro que modernizar não precisa ser sinônimo de descartar. Estratégias inteligentes de transição são aquelas que valorizam o capital intelectual já investido no software.
Ao viabilizar a transição suave de componentes para objetos G3 e promover a interoperabilidade revolucionária entre VBScript e JavaScript, o AxonASP prova que é possível modernizar com precisão e baixo custo. É a solução definitiva para estender a vida útil das suas aplicações, garantindo que qualquer desenvolvedor moderno possa manter e escalar seu código rumo ao futuro.

Modernizing Legacy Systems: How to Slay Technical Debt with AxonASP

Lucas Guimarães — Tue, 30 Jun 2026 13:57:01 +0000

If you've been following the software engineering space recently, you've probably noticed a massive shift. According to recent market analysis on legacy modernization trends, the sector is skyrocketing, projected to reach over $66 billion in the coming years. Why? Because technical debt is compounding, and enterprises are realizing that tearing down decades of business logic for a "big bang" rewrite is simply too expensive, risky, and slow.
The new standard is incremental modernization. And if you are dealing with Classic ASP environments, this is where AxonASP—an open-source, cross-platform runtime server written in GoLang—completely changes the game.

The Frictionless Shift: From COM to G3 Objects

One of the biggest nightmares when modernizing legacy web apps is the deep entanglement with native COM objects. Traditionally, moving away from these dependencies meant completely rewriting complex business rules, stalling new feature delivery, and risking operational downtime.
AxonASP takes a much smarter approach. It allows your original codebase to remain largely intact, requiring only minimal effort to adapt existing configurations. By simply transitioning legacy COM object calls to G3 objects, developers can seamlessly bridge legacy logic with modern infrastructure. This keeps the application's vital components running with high performance and proper isolation, entirely bypassing the risks of a full rewrite.

The Game-Changer: VBScript and JavaScript on the Same Page

Let’s talk about the elephant in the room: the developer talent pool. The aging workforce specialized in older languages makes maintaining legacy code incredibly costly. Trying to find developers eager to write VBScript today is an uphill battle.
To solve this, AxonASP introduces its most powerful feature: native, combined support for both JavaScript and VBScript within the exact same page.
Instead of forcing your engineering team to translate thousands of lines of VBScript into a modern language before they can add a single new feature, AxonASP lets the old code peacefully coexist with new logic written entirely in JavaScript.

Empowering the Next Generation of Devs

This interoperability completely flips the script on legacy maintenance, making your codebase accessible to anyone:

Zero-Friction Onboarding: New hires familiar with modern ecosystems (like Node.js, Vue, or vanilla JS) don't need to learn VBScript. They can open an .asp file, understand the structure, and start coding new updates and maintaining the system using JavaScript right away.
Module-by-Module Refactoring: Engineering teams can refactor the application progressively. Critical VBScript functions can be swapped out for JavaScript functions one sprint at a time, drastically reducing technical risk.
Painless Maintenance: Because the old rules still work and new ones can be written in the world's most popular language, maintenance stops being a bottleneck and becomes a natural part of your development lifecycle.

Conclusion

The industry trends are clear: modernization doesn't have to mean throwing everything away. The smartest transition strategies leverage the intellectual capital already invested in your software.
By enabling a smooth transition to G3 objects and offering groundbreaking VBScript/JavaScript interoperability, AxonASP proves that you can modernize legacy apps with precision and minimal cost. It’s the ultimate bridge to the future, ensuring any modern developer can jump in, maintain, and scale your code today.

JavaScript no lado do servidor sem node.js? APIs no Linux com AxonASP

Lucas Guimarães — Tue, 30 Jun 2026 11:00:00 +0000

Quando falamos de Classic ASP, a primeira coisa que costuma vir à mente é o VBScript. É uma linguagem excelente e direta, mas sejamos honestos: no ecossistema da web moderna, tudo conversa em JSON. E gerar JSON manualmente concatenando strings no VBScript é um pesadelo que nenhum desenvolvedor deveria ter que suportar hoje em dia. Mesmo que tenhamos a G3JSON do AxonASP ao nosso lado, é chato pensar em ter de chamar uma biblioteca apenas para isso.

Mas aqui está um fato esquecido: o Classic ASP no Windows sempre ofereceu suporte ao JScript, que nada mais é do que JavaScript. E esse, garanto que você sabe.

Com o AxonASP (https://github.com/guimaraeslucas/axonasp) — uma engine baseada em GoLang que roda Classic ASP nativamente no Linux, macOS, BSD e Windows — essa capacidade não foi apenas preservada; ela se tornou uma ferramenta poderosa. O AxonASP implementa um motor ECMAScript que suporta completamente a versão 6.0 e além, permitindo que você escreva JavaScript no lado do servidor perfeitamente integrado às suas páginas ASP.

O melhor dos dois mundos
Ao adotar o JavaScript como sua linguagem principal em uma página ASP, você consegue misturar naturalmente conteúdo HTML com JavaScript renderizado no servidor. E o mais importante: isso elimina completamente o atrito na hora de construir APIs. Você ganha a sintaxe nativa do JavaScript (incluindo os métodos embutidos JSON.stringify e JSON.parse) combinada com os objetos padrão e já consagrados do ASP, como Response, Request e Server.

Some a esse ecossistema bibliotecas como a G3DB — que facilita absurdamente a conexão e a execução de consultas em múltiplos bancos de dados simultaneamente — e, de repente, você tem uma stack de backend extremamente leve e capaz, rodando direto em um servidor Linux ou dentro de um container Docker.

Exemplo prático: Um endpoint de Micro-API
Para mostrar como isso funciona na prática, vamos construir um endpoint de API simples e seguro.

Imagine que você precisa servir dados para um frontend moderno em Vue.js ou React. Em vez de configurar um framework pesado, você pode simplesmente jogar este arquivo .asp na pasta www do seu AxonASP. Ele lê um parâmetro da URL, faz uma consulta no banco de dados usando a biblioteca G3DB, formata o resultado em JSON e serve a resposta com os cabeçalhos HTTP corretos.

<%@ Language="JavaScript" %>
<%
// 1. Configuração dos cabeçalhos HTTP modernos para a nossa API
Response.ContentType = "application/json";
Response.Charset = "UTF-8";
Response.AddHeader("Access-Control-Allow-Origin", "*");

// 2. Definição da lógica de busca de dados
function getRecordData(recordId) {
    // Instancia a biblioteca usando o ProgID principal
    var db = Server.CreateObject("G3DB");

    // Abre a conexão utilizando valores de configuração/ambiente
    // Retorna True se a abertura via config/env for bem-sucedida; False caso contrário
    var isConnected = db.OpenFromEnv("mysql"); 

    if (!isConnected) {
        // Retorna a string do erro atual
        throw new Error("Falha na conexão com o banco: " + db.GetError()); 
    }

    // Uso de consultas parametrizadas para garantir segurança contra SQL Injection
    var sql = "SELECT id, status, created_at, assigned_user FROM workflow_queue WHERE id = ?";

    // Executa a consulta e retorna um result set do tipo forward-only
    // A reescrita de placeholders converte os marcadores '?' para o formato do driver ativo quando necessário
    var rs = db.Query(sql, recordId); 

    var result = null;

    // Verifica se o result set é válido (a G3DB retorna Empty em caso de falha)
    if (rs != null) {
        if (!rs.EOF) {
            // Mapeia o Recordset diretamente para um objeto nativo do JavaScript
            result = {
                id: String(rs("id")),
                status: String(rs("status")),
                createdAt: String(rs("created_at")),
                assignedTo: String(rs("assigned_user"))
            };
        }
        // Sempre limpa e fecha o Recordset
        rs.Close();
    } else {
        // Captura falhas de execução usando a propriedade somente leitura LastError
        throw new Error("Falha na execução da consulta: " + db.LastError);
    }

    // Fecha o pool de conexões atual gerenciado pelo objeto G3DB
    db.Close(); 

    return result;
}

// 3. Processamento da requisição recebida
try {
    // Extrai o ID da URL (ex: 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: "Parâmetro obrigatório ausente: id." 
        }));
    } else {
        var record = getRecordData(reqId);

        if (record) {
            // Sucesso: renderiza o JSON padrão usando o stringify nativo do ES5
            Response.Write(JSON.stringify({ 
                success: true, 
                data: record 
            }));
        } else {
            Response.Status = "404 Not Found";
            Response.Write(JSON.stringify({ 
                success: false, 
                error: "Registro não encontrado no banco de dados." 
            }));
        }
    }
} catch (e) {
    // Tratamento global de erros
    Response.Status = "500 Internal Server Error";
    Response.Write(JSON.stringify({ 
        success: false, 
        error: e.message 
    }));
}
%>

Por que isso importa?
Olhe para o código acima. É JavaScript perfeitamente válido, roda com uma velocidade incrível e faz exatamente o que precisa fazer, sem camadas complexas de middleware ou configurações complicadas de roteamento.

Como o AxonASP é construído em GoLang, todo esse ambiente fica completamente desacoplado do Windows Server. Na verdade, ele roda em qualquer servidor que você quiser. Você pode criar novos módulos usando a sintaxe que você já domina, aproveitando os objetos clássicos do ASP, consultando seus bancos com a G3DB e implantando tudo em uma distribuição Linux mínima. E sabe o que é melhor? Com uma otimização de memória muito boa. Uma API Node.js muitas vezes utiliza 50mb a 80mb para ficar em espera, enquanto o AxonASP consegue manter a espera em 18mb. Isso é fantástico para economizar recursos, e cá entre nós, sabemos o quanto esses recursos são caros para nós que pagamos em reais convertidos em dólar.

Se você gerencia aplicações em Classic ASP, migrá-las não significa necessariamente ter que reescrevê-las do zero em outra linguagem. Você pode modernizar a infraestrutura, mudar para JavaScript onde fizer mais sentido (como em endpoints de API), e até misturar VBScript com JavaScript na mesma página, e manter seus sistemas rodando tranquilamente. E sem pagar licenças.

Nós fizemos o AxonASP para ser uma engine potente. E precisamos também de sua ajuda como desenvolvedor. Se você puder colaborar testando código JavaScript, VBScript ou até mesmo melhorando o código GoLang, isso será de grande ajuda.

Uma linguagem de 30 anos otimizada para o futuro: Construindo uma Máquina Virtual Zero-AST em Go capaz de rodar ASP

Lucas Guimarães — Mon, 29 Jun 2026 11:00:00 +0000

Olá, comunidade DEV! 👋 Estou de volta.

Se você acha que o Classic ASP está morto, deixe-me dizer: ele agora está mais vivo do que nunca.

Recentemente, concluí uma refatoração total da base de código para a versão 2.2 do AxonASP, meu motor em Go de código aberto para VBScript e Classic ASP. O objetivo não era apenas manter o código legado respirando; eu queria expandir os limites do que essa linguagem dos anos 90 pode realmente alcançar em hardware moderno.

Quero compartilhar com vocês algumas das otimizações profundas de engenharia que implementamos por baixo do capô para fazer isso acontecer.

⚡ Zero AST, Bytecode Puro
Nesta reescrita, demos um enorme salto arquitetônico: descartei a Árvore de Sintaxe Abstrata (AST).

Em vez disso, o novo compilador de passagem única (single-pass) emite bytecode diretamente para uma Máquina Virtual baseada em pilha. Ao eliminar a AST, o AxonASP executa scripts com overhead de alocação praticamente zero. O consumo de memória despenca drasticamente e a execução é rápida.

🔄 Pool de VMs no Estilo IIS & Cache Avançado
Para lidar com alta concorrência, implementei um pool avançado de VMs perfeitamente modelado com base na arquitetura original do IIS, mas sustentado pelas goroutines nativas do Go. Além disso, combinei isso com um cache agressivo de scripts e até implementei cache de compilação para execuções dinâmicas (eval, execute e executeglobal). O resultado é que o tempo de processamento de requisições é mais rápido se comparado ao ASP tradicional.

🛠️ Tornando o ASP um Prazer de Escrever Novamente
Velocidade pura é ótimo, mas a experiência do desenvolvedor importa tanto quanto. Não paramos apenas no suporte à biblioteca padrão legada. Injetamos mais de 60 funções personalizadas diretamente no runtime. Agora você tem acesso a manipulação avançada de arrays, manipulação nativa de JSON e ferramentas criptográficas prontas para uso. Isso realmente faz com que escrever ASP seja um prazer novamente.

🧪 Desenvolvimento Guiado por Testes em ASP (Sim, sério)
Diga adeus a scripts quebrados e regressões. Eu queria trazer práticas de desenvolvimento modernas para a linguagem, então construímos o novo executável axonasp-testsuite. Ele permite que você escreva e rode suítes de testes automatizados nativamente, direto nos seus arquivos .asp! O TDD no Classic ASP finalmente é uma realidade.

Se você está curioso sobre como tudo isso funciona, ou se tem uma aplicação legada que deseja resgatar, preparamos um manual completo e abrangente bem dentro do repositório para te ajudar a começar.

O Classic ASP pode ser um pedaço da história da computação retrô, mas com essas otimizações, ele está pronto para a web moderna. Adoraria saber o que vocês acham.

👉 Confira o repositório e o código-fonte aqui: https://github.com/guimaraeslucas/axonasp

Trouxemos o Classic ASP para o Linux: Assista ao vídeo do AxonASP e confira nosso novo manual online!

Lucas Guimarães — Mon, 29 Jun 2026 00:00:00 +0000

Olá, comunidade DEV! 👋

Recentemente, compartilhei como reescrevi completamente o motor do Classic ASP do zero em Go para salvar aplicações legadas da descontinuação do VBScript pela Microsoft. Hoje, estou super animado para compartilhar uma breve apresentação em vídeo que acabei de produzir, mostrando o AxonASP em ação!

Você pode assistir à análise detalhada de como alcançamos uma execução zero-AST, velocidades extremas e compatibilidade multiplataforma bem aqui:
👉 https://www.youtube.com/watch?v=2COGf_lfwSs

📖 Mais do que apenas documentação: Um centro de aprendizado completo
Um dos maiores desafios com tecnologias mais antigas é que os fóruns, tutoriais e documentações de antigamente estão desaparecendo lentamente da web. Para resolver isso, não construímos apenas um motor; nós criamos um manual moderno e abrangente.

Seja você um veterano migrando uma aplicação empresarial legada ou um desenvolvedor moderno se perguntando o que diabos é ASP, o manual tem tudo o que você precisa. Ele traz:

O Básico: Uma recapitulação completa e amigável sobre os conceitos fundamentais do Classic ASP.
As Extensões Modernas: Exemplos detalhados e prontos para copiar e colar de como usar nossos novos objetos nativos em Go diretamente dentro do seu VBScript. Você aprenderá como fazer o parse de APIs com o G3JSON, buscar recursos externos com o G3HTTP e até renderizar Markdown para HTML instantaneamente usando o G3MD.
Conteinerização: Guias passo a passo sobre como usar nossos containers Docker para que você possa conteinerizar suas aplicações de 20 anos atrás em questão de segundos.
CLI em Tempo Real: Instruções de como usar nossa interface de linha de comando interativa. Você pode, de fato, escrever, testar e aprender trechos de ASP em tempo real, direto do seu terminal!

O AxonASP é mais do que apenas VBScript — ele também traz suporte nativo a JavaScript

E o melhor: com total acesso aos objetos clássicos do ASP (Request, Response, Session, etc.). Se você é novo no ecossistema ASP, não se preocupe: é o mesmíssimo JavaScript que você já roda no navegador ou no Node.js. A grande vantagem aqui? No AxonASP, o JavaScript pode ser executado de forma totalmente síncrona. Chega de inferno de callbacks ou promises para operações simples; você escreve o código de forma direta e vê o resultado na hora, sem complicações.

🤯 Provando que funciona
Aqui está a minha parte favorita: o manual em si é uma aplicação em Classic ASP. Se você acessar o link abaixo, não estará apenas lendo arquivos estáticos. Todo aquele site de documentação está rodando ao vivo em produção agora, alimentado nativamente pelo motor do AxonASP, rodando de forma segura atrás de um proxy reverso Nginx em um servidor Linux. É rápido, estável e prova exatamente do que essa arquitetura é capaz de dar conta no mundo real.

🔗 Explore você mesmo
Eu adoraria que você assistisse ao vídeo, desse uma olhada na documentação e experimentasse. Deixe-me saber o que achou da arquitetura nos comentários!

Leia o manual online (rodando em AxonASP + Linux + Nginx): https://g3pix.com.br/axonasp/manual/default.asp

Confira o código-fonte e deixe uma estrela: https://github.com/guimaraeslucas/axonasp