NLog: una alternativa para Serilog en .Net

Como vimos en la entrega anterior, el proyecto NLog es una alternativa a Serilog.

"NLog es una plataforma de registro flexible y gratuita para diversas plataformas .NET, incluyendo .NET Standard. NLog facilita la escritura en múltiples destinos (consola, archivo, base de datos, etc.) y permite modificar la configuración de registro sobre la marcha".

Iniciando con NLog

1. Creamos un proyecto con dotnet:

$ dotnet new console -n DemoNLog
$ cd DemoNLog

2. Agregamos el paquete NLog en el archivo ``DemoNLog.csproj``:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

<ItemGroup>
   <PackageReference Include="NLog" Version="6.1.1" />
   <None Update="NLog.config">
    <CopyToOutputDirectory>Always</CopyToOutputDirectory>
  </None>
</ItemGroup>

</Project>

En este archivo XML agregamos el paquete NLog y especificamos la versión compatible a .Net 10.

También lo podemos hacer desde la terminal:

$ dotnet add package NLog --version 6.1.1

3. Creamos y configuramos el archivo ``NLog.config``:

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <!-- Definir los targets -->
  <targets>
    <!-- Log en consola -->
    <target xsi:type="Console" name="console" layout="${longdate} | ${level:uppercase=true} | ${message}" />

    <!-- Log en archivo -->
    <target xsi:type="File" name="file" fileName="C:\\Users\\HP\\Documents\\pruebasCSharp\\pruebasNLog\\DemoNLog\\logfile.txt"
            layout="${longdate} | ${level:uppercase=true} | ${message} ${exception}" />
  </targets>

  <!-- Definir las reglas -->
  <rules>
    <!-- Todos los niveles a consola -->
    <logger name="*" minlevel="Debug" writeTo="console" />
    <!-- Solo Info y superior a archivo -->
    <logger name="*" minlevel="Info" writeTo="file" />
  </rules>
</nlog>

En este archivo configuramos el archivo y la ruta de la salida. Además los niveles de loggers. Similar a lo que se hace en Java (log4j).

4. Modificamos el programa principal ``Program.cs``

using NLog;

class Program
{
    private static readonly Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        LogManager.Setup().LoadConfigurationFromFile();
        logger.Info("Aplicación iniciada");
        logger.Debug("Este es un mensaje de depuración");
        logger.Error("Ocurrió un error simulado");

        LogManager.Shutdown(); 
    }
}

En el programa importamos el paquete NLog y cargamos la configuración del archivo NLog.config. El programa solo mostrará algunos mensajes con los niveles Info, Debug y Error.

5. Construimos y ejecutamos la aplicación:

$ dotnet build
$ dotnet run

Salida:

2026-03-16 12:10:36.3512 | INFO | Aplicación iniciada
2026-03-16 12:10:36.4258 | DEBUG | Este es un mensaje de depuración
2026-03-16 12:10:36.4258 | ERROR | Ocurrió un error simulado

Como se puede observar es similar a lo que se hizo con el paquete Serilog. Aunque tiene algunos detalles como la configuración del archivo XML.

¡Hemos creado nuestro primer programa usando NLog!

Serilog es recomendable para proyectos modernos como microservicios y aplicaciones Cloud.

NLog está más enfocado en proyectos legados, aunque es una aletrnativa a Serilog.

Continuaremos con esta serie sobre C# en próximas entregas.

Enlaces:

https://nlog-project.org/
https://www.nuget.org/

Serilog: registrando eventos en .Net

Para quienes llevan tiempo programando saben que llevar un registro de eventos de nuestras aplicaciones (web, principalmente) es muy importante para dar soporte a ciertas incidencias que pudieran presentarse.

Los loggers son registros que contienen la fecha y hora de ciertos eventos. Estos son importantes cuando queremos saber qué acción disparó el usuario y, en ciertos casos, el resultado que arrojó.

El resultado puede ser satisfactorio o pueden presentarse errores que debemos atender.

.NET nos permite usar librerías como Serilog para realizar estas actividades. La documentación oficial nos dice:

"Serilog proporciona registro de diagnóstico en archivos, la consola y otros lugares".

Además promete ser fácil de configurar y usar.

"Es fácil de configurar, tiene una API limpia y es portable entre las plataformas .NET más recientes".

"Es útil incluso en las aplicaciones más sencillas, la compatibilidad de Serilog con el registro estructurado destaca al instrumentar aplicaciones y sistemas complejos, distribuidos y asíncronos".

Instalando Serilog

La instalación de Serilog la haremos gracias a los NuGets. Podemos abrir una terminal para hacerlo:

$ dotnet add package Serilog
$ dotnet add package Serilog.Sinks.Console

Esto siguiendo los pasos del sitio oficial de Serilog.

El sitio de Nuget nos da solo esta acción:

$ dotnet add package Serilog --version 4.3.1

Nos quedaremos con esta última opción de instalación.

Empezando con Serilog

1. Crearemos una aplicación de consola y nos ubicamos en el directorio creado:

$ dotnet new console -n DemoSerilog
$ cd DemoSerilog

2. Agregamos Serilog:

$ dotnet add package Serilog --version 4.3.1

3. Validamos la instalación:

$ dotnet list package

Nota: En caso de necesitar más paquetes deberás remover Serilog e instalar todos los siguientes paquetes:

$ dotnet remove package Serilog

$ dotnet add package Serilog
$ dotnet add package Serilog.Sinks.Console
$ dotnet add package Serilog.Sinks.File
$ dotnet add package Serilog.Settings.Configuration

4. Abrimos el Program.cs y lo editamos.

using System;
using Serilog;

/**
 * @author Codemonkey Junior
 * @date 2026/03/14
 *
 */
class Program
{
     public Program()
    {
        Console.WriteLine("Objeto 'Program' creado e inicializado.");
    }

    ~Program() { }

    public static void Main(string[] args)
    {
        using var log = new LoggerConfiguration()
        .WriteTo.Console()
        .WriteTo.File("log.txt")
        .CreateLogger();
        
        log.Information("Hola, Serilog!");
        Log.Information("Nuestra primera configuracion Serilog.");
    }
}

5. Construimos el proyecto y lo ejecutamos:

$ dotnet build
$ dotnet run

Salida:

[14:17:07 INF] Hola, Serilog!
[14:17:07 INF] Nuestra primera configuracion Serilog.

NLog: alternativa a Serilog

El proyecto https://nlog-project.org es una alternativa a Serilog. El cual es:

..."una plataforma de registro flexible y gratuita para diversas plataformas .NET, incluyendo .NET Standard. NLog facilita la escritura en múltiples destinos (consola, archivo, base de datos, etc.) y permite modificar la configuración de registro sobre la marcha".

Esta alternativa a Serilog la veremos en otra entrega.

Hemos visto que serilog es una biblioteca de registro de diagnóstico para aplicaciones .NET. El cual es fácil de configurar, tiene una API limpia y se ejecuta en todas las plataformas .NET recientes.

También hemos visto cómo instalar, listar y remover paquetes Nuget. En próximas entregas veremos más a fondo esta librería.

Enlaces:

https://serilog.net/
Top 13 Libraries in .NET With Alteratives
https://github.com/serilog/serilog/wiki/Getting-Started

WebSockets: un canal permanente para enviar y recibir datos

Los WebSockets son un protocolo que permite comunicación bidireccional en tiempo real entre cliente y servidor, a diferencia de HTTP que funciona en modo solicitud-respuesta.

Es como un canal permanente, donde ambos lados (cliente y servidor) pueden enviar datos en cualquier momento.

Son útiles en cualquier escenario donde se requiera interacción instantánea:

• Chats y mensajería: WhatsApp Web, Slack, Discord. 
• Juegos online: sincronización de movimientos en tiempo real. 
• Colaboración en documentos: Google Docs, Notion, donde ves cambios de otros usuarios al instante.
• Notificaciones en vivo: alertas de bolsa, actualizaciones deportivas, sistemas de monitoreo. 
• Aplicaciones financieras: transmisión de precios de criptomonedas o acciones en tiempo real. 
• IoT y dashboards: dispositivos que envían datos continuamente a una interfaz web .

Entre las ventajas principales encontramos:

• Baja latencia: no hay que abrir y cerrar conexiones constantemente. 
• Menor consumo de recursos: menos overhead que múltiples peticiones HTTP. 
• Escalabilidad: ideal para aplicaciones con miles de usuarios conectados simultáneamente.  
• Flexibilidad: permite enviar datos en ambos sentidos (cliente ↔ servidor).

Entre los riesgos y consideraciones a tomar tenemos:

• Seguridad: al ser persistentes, requieren cifrado (wss://) para evitar ataques de interceptación. 
• Escalabilidad: manejar miles de conexiones simultáneas exige servidores optimizados. 
• Compatibilidad: aunque ampliamente soportados, algunos entornos antiguos pueden no tener soporte completo.

WebSockets

Iniciemos pues con los WebSockets. Haremos un sencillo ejemplo. Para ello necesitamos:

• Tener Node instalado en nuestras máquinas. 
• Tener conocimiento de Javascript y Node. 
• Instalar Express y Socket.IO

¿Qué haremos? Una aplicación que nos muestre un ejemplo del uso de WebSockets, con ayuda de JS y Node.

1. Crearemos un directorio y nos ubicaremos en el:

$ mkdir websocket-demo
$ cd websocket-demo

2. Una vez dentro del directorio, crearemos un proyecto Node:

$ npm init -y

Esto nos generará el proyecto Node.

3. Instalar las dependencias (Express y Socket.IO) con ayuda de la herramienta ``npm``:

$ npm install express socket.io

Podemos validar la descarga con este comando:

$ npm list

Salida:

+-- express@5.2.1
`-- socket.io@4.8.3

4. Creando un servidor que escuche ``server.js``:

const express = require('express');
const http = require('http');
const { Server } = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = new Server(server);

app.use(express.static('public'));

io.on('connection', (socket) => {
  console.log('Un usuario se conectó');

  socket.on('chat message', (msg) => {
    console.log('Mensaje recibido: ' + msg);
    io.emit('chat message', msg);
  });

  socket.on('disconnect', () => {
    console.log('Un usuario se desconectó');
  });
});

server.listen(3000, () => {
  console.log('Servidor escuchando en http://localhost:3000');
});

5. Crearemos un cliente para hacer petciones al servidor:

public\index.html

<!DOCTYPE html>
<html>
<head>
  <title>Chat con Socket.IO</title>
</head>
<body>
  <h1>Chat sencillo</h1>
  <ul id="mensajes"></ul>
  <form id="form">
    <input id="input" autocomplete="off" /><button>Enviar</button>
  </form>
  <script src="/socket.io/socket.io.js"></script>
  <script>
    const socket = io();

    const form = document.getElementById('form');
    const input = document.getElementById('input');
    const messages = document.getElementById('mensajes');

    form.addEventListener('submit', (e) => {
      e.preventDefault();
      if (input.value) {
        socket.emit('chat message', input.value);
        input.value = '';
      }
    });

    socket.on('chat message', (msg) => {
      const item = document.createElement('li');
      item.textContent = msg;
      messages.appendChild(item);
    });
  </script>
</body>
</html>

6. Ejecutamos la aplicación:

$ node server.js

Si todo va bien veremos este mensaje:

Servidor escuchando en http://localhost:3000

Abrimos un navegador en la ruta: http://localhost:3000/

Veremos lo siguiente:

Mandamos un mensaje y obtendremos una respuesta:

¡Hemos creado nuestra primera aplicación con WebSockets!

Continuaremos con estos temas en próximas entregas.

Enlaces:

https://en.wikipedia.org/wiki/WebSocket
https://socket.io/
https://expressjs.com/

gRPC: una alternativa para servicios de alto rendimiento

gRPC (google Remote Procedure Calls) es un framework que nos sirve para realizar llamadas a procedimientos remotos.

Es de alto rendimiento. Multilenguaje (clientes y servidores). Además de tener un Streaming avanzado, lo que permite comunicaciones tipo: unary, server streaming, client streaming y streaming bidirectional.

Es ideal para microservicios gracias a su alto rendimiento, tipado fuerte y soporte multiplataforma.

Ya hemos hecho una comparativa entre otras alternativas como GraphQL:

gRPC y GraphQL

Usa Protocol buffers (*.proto) como mecanismo de serialización (y deserialización); el cual es un formato binario, más pequeño, rápido y sencillo que XML y JSON. Además de soportar diversos lenguajes como: Java, Python, Go, etc.

También usa HTTP/2 como protocolo de comunicación, el cual es una mejora del HTTP clásico. El cual prioriza solicitudes, permite la comprensión de encabezados, multiplexación (múltiples llamadas simultáneas) y tiene mayor seguridad.

Empezando con gRPC y .NET

Crearemos una aplicación Cliente-Servidor para mostrar el uso de gRPC. Como lenguaje base usaremos C# y la herramienta dotnet para crear los proyectos.

Quien ha trabajado con aplicaciones Cliente-Servidor podrá entender el flujo. Una aplicación Cliente hará solicitudes y el Servidor las atenderá.

Para este ejemplo necesitaremos crear:

• Un proyecto servidor. 
• Un proyecto cliente.

Empecemos con el Servidor

Creamos el proyecto servidor con soporte a gRPC:

$ dotnet new grpc -o GrpcServer
$ cd GrpcServer

Una vez ubicados en el directorio podemos ejecutarlo:

$ dotnet run

Abrimos el navegador en la ruta: http://localhost:5057

Si todo va bien, veremos un mensaje.

Continuemos con el Cliente

Creamos el proyecto cliente de tipo consola:

$ dotnet new console -o GrpcClient
$ cd GrpcClient

Una vez ubicados en el directorio del Cliente, copiamos el directorio y archivo Protos\greet.proto del proyecto Servidor al Cliente.

Editamos el archivo GrpcClient.csproj de para agregar el archivo copiado. De tal manera que quede de esta forma:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Google.Protobuf" Version="3.33.5" />
    <PackageReference Include="Grpc.Net.Client" Version="2.76.0" />
    <PackageReference Include="Grpc.Tools" Version="2.78.0">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
	
	<Protobuf Include="Protos\greet.proto" GrpcServices="Client" />

  </ItemGroup>

</Project>

El archivo Protos\greet.proto es el siguiente:

syntax = "proto3";

option csharp_namespace = "Greet";

package greet;


service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}


message HelloReply {
  string message = 1;
}

Este archivo *.proto define el contrato de comunicación entre Cliente y Servidor en gRPC, y permite a un Cliente enviar un nombre y recibir un saludo como respuesta.

Compilamos y ejecutamos el proyecto Cliente:

$ dotnet build
$ dotnet run

Si todo va bien, veremos algo como esto en el Cliente:

Respuesta del servidor: Hello Code Monkey Junior

Y en el Servidor:

Usando la configuración de inicio de C:\Users\HP\Documents\pruebasCSharp\pruebasGRPC\GrpcServer\Properties\launchSettings.json...
Compilando...
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5057
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: C:\Users\HP\Documents\pruebasCSharp\pruebasGRPC\GrpcServer
info: GrpcServer.Services.GreeterService[0]
      The message is received from Code Monkey Junior

Este solo es un ejemplo de gRPC. Aún falta saber más de Protobuf y HTTP/2 a profundidad.

Como mencionamos con gRPC podemos crear aplicaciones con diversos lenguajes de programación.

Por ejemplo, si tenemos un servidor creado en lenguaje de programación C# no habrá problema que clientes hechos en otros lenguajes como Java, Python, Go, etc. puedan realizar solicitudes y recibir respuestas.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://grpc.io/
https://protobuf.dev/
https://dotnet.microsoft.com
https://alquimistadecodigo.blogspot.com/2024/05/grpc-protobuff-protocol-buffers.html
https://alquimistadecodigo.blogspot.com/2024/05/grpc-en-java-y-protobuff.html

OpenClaw: un agente de IA en tu propia máquina

OpenClaw es un agente de Inteligencia Artificial de código abierto. Actúa como un asistente personal avanzado. Convirtiendo a las personas en meros "solicitantes de código" (broma).

Es una alternativa a herramientas como Claude Code u OpenCode.

Con la peculiaridad que se ejecuta en un entorno local.

Es una tecnología relativamente nueva que nació en enero del 2026.

Es importante saber que su configuración requiere un alto conocimiento sobre comandos Bash, Powershell, etc. además de otras habilidades más avanzadas (redes, sistemas operativos, arquitectura, etc.).

Se recomienda que no se instale en un entorno empresarial donde haya acceso a base de datos o información confidencial.

Este agente se conecta a diversos canales de comunicación como WhatsApp o Telegram, entre otros.

Este vídeo explica paso a paso cómo instalar y usar OpenClaw:

Se recomienda tener alto conocimiento en seguridad, ya que empresas como CISCO han descubierto vulnerabilidades importantes en esta herramienta. Además de la complejidad (que si existe) al instalar la herramienta en nuestro entorno local. Además de estar conciente de las vulnerabilidades de seguridad al instalar estas herramientas.

OpenClaw surge como una alternativa a herramientas como ChatGPT, DeepSeek, Grok, etc. Convirtiendo al Vibe Coding como una pauta a seguir en el 2026.

El programador poco a poco se esta convirtiendo en un espectador, un solicitador de código.

Enlaces:

https://codemonkeyjunior.blogspot.com/2026/01/claude-code-un-nuevo-enfoque-de-la.html
https://lapascalinaatomica.blogspot.com/2026/02/fortran-oberon-y-pascal-frente-la-ia.html
https://www.enriquedans.com/2025/12/el-espejismo-del-vibe-coding-cuando-la-relajacion-progresiva-convierte-al-programador-en-espectador.html
https://www.enriquedans.com/2025/11/cuando-el-software-se-escribe-a-ojo-por-que-el-vibe-coding-seduce-y-por-que-conviene-desconfiar.html
https://en.wikipedia.org/wiki/OpenClaw

Hablemos de GraalVM: una JVM políglota

GraalVM es una herramienta que nos ayuda a compilar y ejecutar aplicaciones poliglota con alto rendimiento. Emplear esta herramienta nos permite mejorar la velocidad de ejecución de un programa y reducir el consumo de memoria.

Soporta múltiples lenguajes de programación como: Java, Javascript, Python, Ruby, R, etc.

Se considera una opción "mejorada" de la JVM tradicional.

Con GraalVM tenemos el concepto de Native Images (imágenes nativas), lo que consiste en la creación de ejecutables nativos a partir de aplicaciones Java; permitiendo un arranque mucho más rápido y menor uso de memoria.

GraalVM y la JVM

Observemos la siguiente tabla comparativa entre GraalVM y la JVM.

Comparativa: GraalVM vs JVM HotSpot

Aspecto	GraalVM	JVM HotSpot
Arquitectura	Diseño modular con compilador Graal y soporte poliglota.	Optimizada para Java, con JIT clásico y soporte limitado a la JVM.
Lenguajes soportados	Java, JavaScript, Python, Ruby, R, LLVM bitcode, entre otros.	Principalmente Java y lenguajes basados en la JVM (Scala, Kotlin, Groovy).
Rendimiento	Mejor optimización en tiempo de ejecución, menor consumo de memoria.	Buen rendimiento para Java, pero menos eficiente en arranque y memoria.
Native Images	Permite compilar aplicaciones a ejecutables nativos con arranque rápido.	No soporta generación de binarios nativos directamente.
Tiempo de arranque	Muy rápido gracias a Native Image, ideal para microservicios.	Más lento, requiere inicialización completa de la JVM.
Casos de uso	Microservicios, aplicaciones poliglota, optimización en la nube.	Aplicaciones Java tradicionales, sistemas empresariales robustos.
Interoperabilidad	Alta, permite mezclar lenguajes en una misma aplicación.	Limitada a lenguajes JVM.

Para instalarlo deberás ir a este sitio: https://www.graalvm.org/downloads/

En tu sistema deberás crear la variable de JAVA_HOME y GRAALVM_HOME apuntando al directorio.

Abre una terminal y teclea:

$ java --version

Salida:

java 25.0.2 2026-01-20 LTS
Java(TM) SE Runtime Environment Oracle GraalVM 25.0.2+10.1 (build 25.0.2+10-LTS-jvmci-b01)
Java HotSpot(TM) 64-Bit Server VM Oracle GraalVM 25.0.2+10.1 (build 25.0.2+10-LTS-jvmci-b01, mixed mode, sharing)

Ejemplo 1. El clásico programa de "Hola, mundo".

HolaMundo.java

public class HolaMundo{
   public static void main(String[] args){
      String mundo = new String("mundo!!");
      System.out.printf("Hola, %s\n",mundo);
   }
}

Compilamos:

$ javac HolaMundo.java

Ejecutamos:

$ java HolaMundo

Salida:

Hola, mundo!!

Ahora creemos una imagen nativa.

$ native-image HolaMundo

El proceso de creación de la imagen nativa puede tardar un tiempo considerable.

Si todo va bien, tendremos un ejecutable llamado holamundo.exe.

Podemos crear un batch con el siguiente contenido:

ejecutable.bat

@echo off
echo Start Time: %time%
holamundo.exe
echo End Time: %time%

Lo ejecutamos y observamos el tiempo que tarda en ejecutarse:

Start Time: 10:55:17.00
Hola, mundo!!
End Time: 10:55:17.04

Ahora modifiquemos el bat:

ejecutable.bat

@echo off
echo Start Time: %time%
java HolaMundo
echo End Time: %time%

Lo ejecutamos y observamos la salida:

Start Time: 10:58:58.59
Hola, mundo!!
End Time: 10:58:58.92

La ejecución del .exe apenas duró unos 4 milisegundos. Mientras que el .class tuvo una duración de 33 milisegundos.

GraalVM puede ser una herramienta de gran ayuda para desarrolladores backend, pues permite optimizar el funcionamiento de las APIs y mejorar el consumo de recursos de memoria. Continuaremos con este tema en próximas entregas.

Enlaces:

https://www.graalvm.org/
https://csantanapr.medium.com/book-review-supercharge-your-applications-with-graalvm-9f330ec38c07
https://github.com/graalvm/graalvm-ce-builds/releases/

Minilux: un lenguaje de programación para la automatización

 

@lachicadesistemas nos muestra cómo creó su propio lenguaje de programación: minilux.

Minilux se trata de un lenguaje de programación que toma su inspiración de lenguajes como C, Rust y Python. El sitio oficial nos dice:

"Un lenguaje de programación simple para scripts, automatización y mucho más".

Minilux se creó como un proyecto de aprendizaje para comprender:

• Diseño e implementación del lenguaje.
• Análisis léxico y análisis sintáctico.
• Construcción de intérpretes.
• Programación en Rust.

El vídeo donde se explica el por qué de este lenguaje lo puedes ver en su sitio de Youtube.

Minilux en un vistazo

La extensión de un programa hecho en este lenguaje es *.mi

Es un lenguaje originalmente hecho en C y después en Rust.

Se enfoca en el desarrollo de scripts, como Python o Bash.

Necesitarás tener instalado Rust (y Cargo).

Para su instalación ve a este sitio: https://minilux.org/docs/installation/

Ejemplo. Un hola mundo en este lenguaje.

holamundo.mi

#!/usr/bin/env minilux
printf("Hola, Mundo!")

Actualmente solo puedes usarlo desde la extensión de Visual Studio Code o Antigravity.

A primera vista es un lenguaje de programación que puede servir para ciertas tareas de automatización como las que podrías hacer en lenguajes como Powershell, Bash y Python.

Enlaces:

https://minilux.org/
https://www.youtube.com/watch?v=3zzVG-6JQ64