Project Overview

LameCode is a high-performance code execution engine designed to mirror the multi-language sandboxing behavior of online judging systems. The core engineering challenge was executing untrusted user binaries securely, efficiently, and deterministically without incurring the heavy container overhead or cold-start times of traditional Docker isolation.

Technical Highlights

• WASM Sandboxing: Every untrusted runtime submission isolates into an ephemeral, independent Wasmtime instance with strictly throttled CPU time slices and hard memory ceilings.
• Zero-Javascript Architecture: Utilizes Go, HTMX, and Templ to build a single-page application experience driven entirely by memory-efficient, server-side rendered state.
• Dynamic Toolchain Compilers: Features a background backend pipeline that handles multi-tenant compiler requests, converting C, C++, and Rust source arrays into WASI-compliant WebAssembly binaries on the fly.

Supported Languages

• C/C++: via Emscripten toolchains
• Rust: compiled via the native wasm32-wasi target
• Go: compiled targeting TinyGo and standard Go web targets

Architected with infrastructure parity in mind; the system is natively cloud-ready and fully containerized, optimized to scale microservices horizontally or run lightweight standalone nodes on edge infrastructure.

Project Overview

Developed as a strategic joint venture by my firm, Logias, for SferaSoft’s enterprise ERP ecosystem. I architected, deployed, and currently maintain a cloud-native platform that extends legacy native Windows applications, securely replicating complex access and permission layers to offer a natural language data extraction engine.

This engine solves the traditional “reporting bottleneck” in corporate environments. Instead of waiting for IT to write custom SQL reports or wrestling with complex filter interfaces, users query the database natively:

“Show me all invoices from last month grouped by client.”

Beyond introducing modern AI capabilities, this project serves as the foundational architecture for migrating the company’s legacy systems toward a high-performance, cloud-native future.

Key Features

• Natural Language to SQL: Leverages Gemini models to dynamically map and execute complex SQL queries against a relational ERP schema.
• Streaming NDJSON: Results are streamed via a secure database proxy, minimizing memory overhead and allowing the UI to render large datasets in real time.
• Automated Persistence: Query results and generated schemas are persisted to Cloudflare R2 for low-latency sharing and compliance tracking.
• Interactive UI: Engineered a high-throughput UI allowing corporate users to instantly filter, sort, and export live data to CSV/PDF.

Project Overview

Patito is a custom, statically-typed imperative programming language built to explore the mechanics of compiler optimization, semantic validation, and low-level runtime instruction execution. The architecture spans from a lexical scanning frontend to a custom bytecode format executed inside a native, custom-built virtual machine.

Core Architecture

• Language Design: Features a structured, deterministic syntax optimized for clarity, with native Spanish keywords mapped directly to core operations.
• Full Compiler Pipeline: Built utilizing sedlex for deterministic lexical analysis and Menhir for LR parsing, synthesizing raw tokens into a fully validated Abstract Syntax Tree (AST).
• Type Safety & Semantic Analysis: Implements a rigorous semantic analysis pass over the AST, handling type checking across primitive types and strictly defining intermediate representations.
• IR & Custom VM: Features a custom-designed execution engine that transforms the intermediate AST into discrete linear instructions (quadruples) executed via an isolated stack-based virtual machine.

Design quirks

Some of these quirks are of my own choosing and some where part of the specifications of the language given to me.

1. Spanish keywords. This is not a big deal really since there are <10 of them.
2. resultado implicit variables.

That is a big one, but I did it (in part) as a time saving measure during finals. All functions except those of type null have an implicit variable called resultado of the same type as the function, and at the end of the function’s execution, its value will be the value of the expression.

It was inspired by Nim’s result variable, but I might get around to creating a return keyword. It should be easy to add now that the pipeline is complete.

3. Double set of parenthesis over functions.

This might have been me being pedantic, but the language definition, as provided in a diagram, included accidentally two sets of parenthesis:

My best guess is that the intention was to have one set of parenthesis that included the variable definitions and the statements, but since these diagrams define the statments:

VARS and CUERPO are within while CUERPO itself is just parenthesis and statements.

Examples

Factorial - Recursive

programa FactorialRecur;

entero factorialRecur(n : entero) {
  {
    si (n == 0) {
      resultado = 1;
    }
    sino {
      resultado = n * factorialRecur(n - 1);
    };
  }
};

inicio
{
  escribe("Factorial Recursivo de 5 es:", factorialRecur(5));
}
fin

A consequence of the resultado variable (and lack of return statement) is that there is no early return that would allow for something like this:

entero factorialRecur(n : entero) {
  {
    si (n == 0) {
      regresa 1;
    }
    regresa n * factorialRecur(n - 1);
  }
};

It would be a slightly more elegant and ergonomic solution.

Fibonacci - Iterative

programa FibonacciIter;
  vars a: entero;

entero fibonacciIter(n : entero) {
  vars
    a, b, temp, i : entero;
  {
    si (n < 2) {
      resultado = n;
    }
    sino {
      a = 0;
      b = 1;
      i = 2;
      mientras (i < n + 1) haz {
        temp = a + b;
        a = b;
        b = temp;
        i = i + 1;
      };
      resultado = b;
    };
  }
};

inicio
{
  a = 25;
  escribe("Fibonacci Iterativo de ", a, " es:", fibonacciIter(a));
}
fin

Project Overview

This website serves as both my digital business card and possibly in the future write some of the stuff I’ve learned making stuff. I built it with Astro so I can stay centered on content but still get a lot of control on how that content is rendered.