DEV Community: Lucas Guimarães

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

Rodando Classic ASP no Linux em 2026

Lucas Guimarães — Sun, 28 Jun 2026 20:41:06 +0000

Sim, estamos em 2026 e o Classic ASP continua vivíssimo. Você sabia que até a Microsoft ainda roda ele internamente?

Embora muita gente o considere uma relíquia do passado, a realidade é que muitas empresas ainda dependem dele para sistemas internos, ferramentas legadas corporativas e até páginas públicas e por um simples motivo: funciona. Por muito tempo, o maior problema era o aprisionamento tecnológico (lock-in): se você quisesse rodar ASP, ficava totalmente preso ao Windows e ao IIS.

Mas as coisas mudaram. O VBScript é uma linguagem incrivelmente direta que merece ser preservada — e para quem prefere, implementações modernas hoje permitem até misturar JavaScript na jogada.

Eu tenho trabalhado em uma solução para trazer essa stack para a era moderna da infraestrutura. O projeto se chama AxonASP.

Por que o AxonASP?
Escrito em GoLang, o AxonASP é um servidor multiplataforma que permite rodar Classic ASP no Linux, macOS e Windows. Isso significa que você finalmente pode conteinerizar suas aplicações legadas usando Docker ou implantá-las em instâncias Linux superleves.

Quão leves? Uma máquina virtual simples como a T2.nano da AWS, com apenas 512 MB de RAM, é mais do que suficiente para servir o seu site. Você consegue manter seus sistemas direto de um ambiente Linux com o mínimo de overhead. Sem pagar licenças Windows.

Guia de Instalação
Você pode encontrar o projeto e as últimas versões direto no GitHub: [github.com/guimaraeslucas/axonasp](https://github.com/guimaraeslucas/axonasp).

Para começar no Linux, você pode baixar o pacote específico da sua distribuição usando o wget. Altere a extensão de acordo com o que você precisa (.rpm, .deb ou .apk):

# Para Alpine (APK)
wget https://github.com/guimaraeslucas/axonasp/releases/download/v2.2.8/axonasp_2.2.8_x86_64.apk

# Para Debian/Ubuntu (DEB)
wget https://github.com/guimaraeslucas/axonasp/releases/download/v2.2.8/axonasp_2.2.8_amd64.deb

# Para RHEL/Fedora/Amazon Linux (RPM)
wget https://github.com/guimaraeslucas/axonasp/releases/download/v2.2.8/axonasp-2.2.8-1.x86_64.rpm

Como o Amazon Linux é o padrão para ambientes AWS, aqui está como fazer a instalação usando o dnf:

sudo dnf install ./axonasp-2.2.8-1.x86_64.rpm

Rodando o Servidor
Após a instalação, os arquivos do servidor ficam localizados em /opt/axonasp. Para fazer um teste rápido, navegue até o diretório e execute o binário HTTP:

cd /opt/axonasp
./axonasp-http

Por padrão, o servidor vai procurar seus arquivos na pasta opt/axonasp/www/. Você pode ajustar o comportamento, as portas e a lógica editando o arquivo de configuração em _config/axonasp.toml_. Seu site estará rodando em localhost:8801.

Implantação em Produção (Proxy Reverso com Nginx)
Para expor sua aplicação para a web com a segurança adequada e SSL, o ideal é usar um proxy reverso como o Nginx. Aqui está um exemplo de configuração:

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

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

server {
    listen 443 ssl http2;
    server_name meuapp.exemplo.com;

    ssl_certificate /etc/ssl/certs/meuapp.crt;
    ssl_certificate_key /etc/ssl/private/meuapp.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;
    }
}

Rodando como Daemon
Em um ambiente Linux em produção, você não vai querer rodar o binário manualmente. O AxonASP já vem com um utilitário para cuidar da instalação no systemd de forma automática:

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

Isso vai registrar o AxonASP como um serviço, garantindo que ele inicialize sozinho sempre que o sistema for ligado.

O Classic ASP não precisa ficar preso em 1998. Com as ferramentas certas, ele se torna uma opção viável, leve e incrivelmente rápida para 2026. E quer saber? Para que usar o Asp.net e gastar 300mb de memória para rodar apenas uma landing page?

A Microsoft matou o VBScript, então eu criei uma VM customizada em Go para trazer o Classic ASP para 2026

Lucas Guimarães — Sun, 28 Jun 2026 20:25:31 +0000

Olá, comunidade DEV! 👋

Eu não tenho uma formação acadêmica formal em TI — meu trabalho principal é, na verdade, como Médico — mas sou um desenvolvedor Go autodidata com uma enorme paixão por computação retrô dos anos 90 e preservação de softwares legados.

Recentemente, com a Microsoft puxando oficialmente o plugue do VBScript e o Classic ASP estando negligenciado há anos, percebi que muito código legado seria deixado no escuro. Em vez de deixá-lo morrer, decidi fazer algo um pouco louco: reescrevi o motor completamente do zero em Go.

Deixem-me apresentar o AxonASP.

É um projeto de código aberto projetado não apenas para manter o código legado vivo, mas para permitir que o Classic ASP realmente evolua para a era da web moderna.

⚡ A Arquitetura em Go: Por que é tão rápido

Escrever um interpretador em Go tem sido uma jornada de engenharia incrível. Eu queria alcançar um desempenho extremo, então descartei a abordagem tradicional de Árvore de Sintaxe Abstrata (AST).

Por baixo do capô, o AxonASP possui um compilador de passagem única (single-pass) que emite bytecode diretamente para uma Máquina Virtual baseada em registradores altamente otimizada (AxonVM). Ao evitar agressivamente reflection e minimizar as alocações de heap no Go, o overhead de execução do script é praticamente zero. É insanamente rápido e otimizado para memória, imitando um pool de VMs no estilo IIS usando a concorrência nativa do Go (goroutines).

🛠️ Trazendo o ASP para a Era Moderna

Eu não queria apenas um clone 1:1; eu queria construir as ferramentas que os desenvolvedores ASP gostariam de ter tido há 20 anos. Aqui está o que o ambiente de execução inclui atualmente:

Integração Nativa com IA: Possui um servidor MCP integrado. Você pode conectar seus agentes de IA/LLMs diretamente ao runtime para escrever e refatorar códigos ASP de forma autônoma com base no seu ambiente local.
Uma CLI & TUI de Verdade: Você finalmente pode executar ASP e VBScript diretamente do seu terminal! Ele possui uma Interface de Usuário em Modo Texto (TUI), tornando-o perfeito para rodar tarefas cron ou scripts de administração de sistema.
Fluxos de Trabalho Modernos: O AxonASP vem com uma suíte de testes nativa (axonasp-testsuite) para que você possa escrever asserções automatizadas para os seus scripts ASP antigos.
Verdadeiramente Multiplataforma: Roda nativamente no Windows, Linux e macOS na maioria das arquiteturas. Você não está mais acorrentado ao Windows Server.
Servidor Flexível: Ele já vem tanto com um daemon FastCGI (perfeito para Nginx/Apache) quanto com um servidor HTTP embutido.
Suporte Javascript: O AxonASP conta com suporte avançado a JavaScript, o que permite que você desenvolva web-sites e aplicações usando a facilidade do ASP e a sincronicidade do JavaScript. Escreva uma vez e pronto.

📦 Experimente!

Eu adoraria receber o feedback da comunidade. O que você achou da arquitetura? Quais recursos modernos você adicionaria a uma linguagem dos anos 90?

Você pode conferir o código-fonte, a documentação completa e exemplos de arquitetura bem aqui:

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

Ah! Você também pode importar e converter bancos de dados Access no Windows, e criar prompts para agentes de IA programarem as páginas ASP que você desejar.

Nota: Se você quiser apenas experimentar, o repositório inclui um instalador simples para Windows e uma configuração do Docker totalmente estruturada para que você possa executá-lo em segundos.

Me contem o que acharam! 💻🩺

DEV Community: Lucas Guimarães

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

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

Passo a passo: Implementando o AxonASP no IIS

1. Pré-requisitos

2. Diretórios e permissões

3. A configuração do web.config

Entendendo a mecânica da configuração

Por que esta arquitetura é o futuro do ASP

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

🧠 The Memory Tax of ASP.NET

📦 "But What About Modern Libraries?"

🤝 VBScript + JavaScript: The Ultimate Polyglot Harmony

🚀 Stop Migrating, Start Evolving

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

Uma arquitetura moderna para uma stack clássica

Flexibilidade de implantação: Do Docker ao WASM

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

Feito para a era da IA: O servidor MCP

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

Como começar

Junte-se à comunidade Open Source

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

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

A Filosofia do AxonASP: Modernizando o Legado

A Métrica Silenciosa do Open Source: Apoio Financeiro

O Toque Humano Segue Invicto

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

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

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

Capacitando a Nova Geração de Desenvolvedores

Conclusão

Modernizing Legacy Systems: How to Slay Technical Debt with AxonASP

The Frictionless Shift: From COM to G3 Objects

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

Empowering the Next Generation of Devs

Conclusion

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

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

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

Rodando Classic ASP no Linux em 2026

A Microsoft matou o VBScript, então eu criei uma VM customizada em Go para trazer o Classic ASP para 2026

⚡ A Arquitetura em Go: Por que é tão rápido

🛠️ Trazendo o ASP para a Era Moderna

📦 Experimente!

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